:type modlist: List[Tuple]
        :param modlist: List of additions (2-tuple) or modifications (3-tuple)
194034
def _unparse_change_record(self, modlist):
        
        mod_len = len(modlist[0])
        self._unparse_changetype(mod_len)

        for mod in modlist:
            if len(mod) != mod_len:
                raise ValueError("Subsequent modlist item of wrong length")

            if mod_len == 2:
                mod_type, mod_vals = mod
            elif mod_len == 3:
                mod_op, mod_type, mod_vals = mod
                self._unparse_attr(MOD_OPS[mod_op], mod_type)

            for mod_val in mod_vals:
                self._unparse_attr(mod_type, mod_val)

            if mod_len == 3:
                self._output_file.write(b'-' + self._line_sep)
405898
def _build_exclusion_list(exclude):
    """"""
    mod_files = []
    if exclude:
        for mod in exclude:
            mdir = None
            mod_file = None
            for token in mod.split("."):
                try:
                    mfile, mdir, _ = imp.find_module(token, mdir and [mdir])
                    if mfile:
                        mod_file = mfile.name
                        mfile.close()
                except ImportError:
                    msg = "Source for module {mod_name} could not be found"
                    raise ValueError(msg.format(mod_name=mod))
            if mod_file:
                mod_files.append(mod_file.replace(".pyc", ".py"))
    return mod_files
331049
def get_mods(self, project_path, vars):
        
        # Start with answers from interactive command
        mods = [var.name for var in self.vars if vars[var.name].lower() == 'yes']
        mods = set(mods)

        # Base mods
        for name in self.mods_list:
            mods.add(name)
        
        # Conditionnal mods dependancies
        if 'accounts' in mods or 'contact_form' in mods:
            mods.add('crispy_forms')
            mods.add('recaptcha')
        
        return mods
812982
public void applyModifications(Properties mods)
    {
        String key;
        String value;

        for (Iterator it = mods.keySet().iterator(); it.hasNext();)
        {
            key   = (String)it.next();
            value = mods.getProperty(key);
            setProperty(key, value);
        }
    }
861844
private int incrementAndGetModulo(int modulo) {
        for (;;) {
            int current = nextIndex.get();
            int next = (current + 1) % modulo;
            if (nextIndex.compareAndSet(current, next) && current < modulo)
                return current;
        }
    }
361649
private int incrementAndGetModulo(int modulo) {
        for (;;) {
            int current = nextServerCyclicCounter.get();
            int next = (current + 1) % modulo;
            if (nextServerCyclicCounter.compareAndSet(current, next))
                return next;
        }
    }
661239
def modver(self, *args):
        
        g = get_root(self).globals
        if self.ok():
            tname = self.val.get()
            if tname in self.successes:
                # known to be in simbad
                self.verify.config(bg=g.COL['start'])
            elif tname in self.failures:
                # known not to be in simbad
                self.verify.config(bg=g.COL['stop'])
            else:
                # not known whether in simbad
                self.verify.config(bg=g.COL['main'])
            self.verify.config(state='normal')
        else:
            self.verify.config(bg=g.COL['main'])
            self.verify.config(state='disable')

        if self.callback is not None:
            self.callback()
527581
def show_modules(config, modules_list):
    
    details = config["full"]
    core_mods = not config["user"]
    user_mods = not config["core"]

    modules = core_module_docstrings(
        include_core=core_mods, include_user=user_mods, config=config
    )

    new_modules = []
    if modules_list:
        from fnmatch import fnmatch

        for _filter in modules_list:
            for name in modules.keys():
                if fnmatch(name, _filter):
                    if name not in new_modules:
                        new_modules.append(name)
    else:
        new_modules = modules.keys()

    for name in sorted(new_modules):
        module = _to_docstring(modules[name])
        desc = module[0][:-1]
        if details:
            dash_len = len(name) + 4
            print("#" * dash_len)
            print("# {} #".format(name))
            print("#" * dash_len)
            for description in module:
                print(description[:-1])
        else:
            print("%-22s %s" % (name, desc))
697101
def _new_mods(pre_mods, post_mods):
    '''
    
    '''
    pre = set()
    post = set()
    for mod in pre_mods:
        pre.add(mod['module'])
    for mod in post_mods:
        post.add(mod['module'])
    return post - pre
651762
def _add_modifiers(self, sql, blueprint, column):
        
        for modifier in self._modifiers:
            method = '_modify_%s' % modifier

            if hasattr(self, method):
                sql += getattr(self, method)(blueprint, column)

        return sql
36023
def modSymbolsFromLabelInfo(labelDescriptor):
    
    modSymbols = set()
    for labelStateEntry in viewvalues(labelDescriptor.labels):
        for labelPositionEntry in viewvalues(labelStateEntry['aminoAcidLabels']):
            for modSymbol in aux.toList(labelPositionEntry):
                if modSymbol != '':
                    modSymbols.add(modSymbol)
    return modSymbols
56946
public void addModifier(String modifier) {
		if (!Strings.isEmpty(modifier)) {
			getSarlAction().getModifiers().add(modifier);
		}
	}
188781
def mods(self, uuid):
        """"""
        picker = lambda x: x.get('mods', {})
        return self._get(('mods', uuid), picker)
628823
def process_mod(self, data, name):
        
        ret = []
        try:
            lines = [x.strip() for x in data.split(bytes(b'\n'))]
            for idx, line in enumerate(lines):
                sub = self.process_mod_line(line, name, idx)
                ret.append(sub)

        except Exception as e:
            logger.debug('Error in line mod file processing %s : %s' % (name, e))
            self.trace_logger.log(e)
        return ret
661764
def _compute_mod_regs(self, regs_init, regs_fini):
        
        assert regs_init.keys() == regs_fini.keys()

        modified_regs = []

        for reg in regs_init:
            if regs_init[reg] != regs_fini[reg]:
                modified_regs.append(reg)

        return modified_regs
763618
def update_module(self, modname, underlined=None):
        
        try:
            pymodule = self.project.get_module(modname)
            self._add_names(pymodule, modname, underlined)
        except exceptions.ModuleNotFoundError:
            pass
811725
def add_modifier(self, m_type=XenaModifierType.standard, **kwargs):
        

        if m_type == XenaModifierType.standard:
            modifier = XenaModifier(self, index='{}/{}'.format(self.index, len(self.modifiers)))
        else:
            modifier = XenaXModifier(self, index='{}/{}'.format(self.index, len(self.xmodifiers)))
        modifier._create()
        modifier.get()
        modifier.set(**kwargs)
        return modifier