setting_list : setting setting_list
                 | setting
775464
def p_setting_list(p):
    
    if len(p) == 3:
        p[0] = merge_map(p[1], p[2])
    elif len(p) == 2:
        p[0] = p[1]
    else:
        raise RuntimeError("Invalid production rules 'p_setting_list'")
620696
def set_setting(key, val, env=None):
    
    return settings.set(key, val, env=env)
47879
def setting(self, setting_name, default=None):  # type: (str) -> Any
        
        keys = setting_name.split(".")

        config = self._content
        for key in keys:
            if key not in config:
                return default

            config = config[key]

        return config
678884
def iter_settings(mixed: Settings) -> Iterator[Tuple[str, Any]]:
    
    if isinstance(mixed, types.ModuleType):
        for attr in dir(mixed):
            if not is_setting_key(attr):
                continue
            yield (attr, getattr(mixed, attr))
    else:
        yield from filter(lambda item: is_setting_key(item[0]), mixed.items())
23210
final public function setPreference(string $setting_name, string $setting_value): void
    {
        DB::table('module_setting')->updateOrInsert([
            'module_name'  => $this->name(),
            'setting_name' => $setting_name,
        ], [
            'setting_value' => $setting_value,
        ]);
    }
607493
def list(self):
        
        settings = []
        for setting in _SETTINGS:
            value = self.get(setting)
            is_set = self.is_set(setting)
            default_value = self.get_default_value(setting)
            is_supported = True
            settings.append((setting, value, default_value, is_set, is_supported))
        for setting in sorted(self.settings_state.list_keys()):
            if not self.is_supported(setting):
                value = self.get(setting)
                default_value = None
                is_set = True
                is_supported = False
                settings.append((setting, value, default_value, is_set, is_supported))
        return settings
1088931
async def list(self, setname=None):
        
        args = ['list']

        if setname is not None:
            args.append(setname)

        return await self.start(__class__.CMD, *args)
974673
def setup_list_pars(self):
        
        tdf = self.setup_temporal_list_pars()
        sdf = self.setup_spatial_list_pars()
        if tdf is None and sdf is None:
            return
        os.chdir(self.m.model_ws)
        try:
            apply_list_pars()
        except Exception as e:
            os.chdir("..")
            self.logger.lraise("error test running apply_list_pars():{0}".format(str(e)))
        os.chdir('..')
        line = "pyemu.helpers.apply_list_pars()\n"
        self.logger.statement("forward_run line:{0}".format(line))
        self.frun_pre_lines.append(line)
787045
public static function setPreference($setting_name, $setting_value): void
    {
        // The database column is only this long.
        $setting_value = mb_substr($setting_value, 0, 2000);

        if (self::getPreference($setting_name) !== $setting_value) {
            DB::table('site_setting')->updateOrInsert([
                'setting_name' => $setting_name,
            ], [
                'setting_value' => $setting_value,
            ]);

            self::$preferences[$setting_name] = $setting_value;

            Log::addConfigurationLog('Site preference "' . $setting_name . '" set to "' . $setting_value . '"', null);
        }
    }
459545
public function setPreference(string $setting_name, string $setting_value): Tree
    {
        if ($setting_value !== $this->getPreference($setting_name)) {
            DB::table('gedcom_setting')->updateOrInsert([
                'gedcom_id'    => $this->id,
                'setting_name' => $setting_name,
            ], [
                'setting_value' => $setting_value,
            ]);

            $this->preferences[$setting_name] = $setting_value;

            Log::addConfigurationLog('Tree preference "' . $setting_name . '" set to "' . $setting_value . '"', $this);
        }

        return $this;
    }
390647
def setting(self):
        
        prog_type = self.__program.program_type
        return self._setting / self.SETTING_DIVIDES[prog_type]
1006290
public void setList(final List<T> newList) {
		getListTableModel().setList(newList);

		adjustColumnWidths();

		// Réinitialise les hauteurs des lignes qui pourraient avoir été particularisées
		// avec setRowHeight(row, rowHeight).
		setRowHeight(getRowHeight());

		// remarque perf: on pourrait parcourir les colonnes pour affecter des renderers aux colonnes n'en ayant pas selon getDefaultRenderer(getColumnClass(i))
		// pour éliminer les appels à getDefaultRenderer pour chaque cellule
	}
489788
public void setList(List<?> list) {
		this.checkNull(list);
		this.list.add(list);
		this.type.add(List.class);
	}
1007108
def set(cls, obj, keys, value, fill_list_value=None):
        
        current = obj
        keys_list = keys.split(".")

        for idx, key in enumerate(keys_list, 1):
            if type(current) == list:
                # Validate this key works with a list.
                try:
                    key = int(key)
                except ValueError:
                    raise cls.Missing(key)

            try:
                # This is the last key, so set the value.
                if idx == len(keys_list):
                    if type(current) == list:
                        safe_list_set(
                            current,
                            key,
                            lambda: copy.copy(fill_list_value),
                            value
                        )
                    else:
                        current[key] = value

                    # done.
                    return

                # More keys left, ensure we have a container for this key.
                if type(key) == int:
                    try:
                        current[key]
                    except IndexError:
                        # Create a list for this key.
                        cnext = container_for_key(keys_list[idx])
                        if type(cnext) == list:
                            def fill_with():
                                return []
                        else:
                            def fill_with():
                                return {}

                        safe_list_set(
                            current,
                            key,
                            fill_with,
                            [] if type(cnext) == list else {}
                        )
                else:
                    if key not in current:
                        # Create a list for this key.
                        current[key] = container_for_key(keys_list[idx])

                # Move on to the next key.
                current = current[key]
            except (IndexError, KeyError, TypeError):
                raise cls.Missing(key)
996133
def __set_folder_list(self, section):
        
        for l in range(1, self.__folder_list_max_size + 1):
            value = {}
            key = 'folder_' + str(l) + '_'

            # Path is mandatory
            value['indice'] = str(l)
            value['path'] = self.config.get_value(section, key + 'path')
            if value['path'] is None:
                continue
            else:
                value['path'] = nativestr(value['path'])

            # Optional conf keys
            for i in ['careful', 'warning', 'critical']:
                # Read threshold
                value[i] = self.config.get_value(section, key + i)
                if value[i] is not None:
                    logger.debug("{} threshold for folder {} is {}".format(i, value["path"], value[i]))
                # Read action
                action = self.config.get_value(section, key + i + '_action')
                if action is not None:
                    value[i + '_action'] = action
                    logger.debug("{} action for folder {} is {}".format(i, value["path"], value[i + '_action']))

            # Add the item to the list
            self.__folder_list.append(value)
1057350
def compute_settings(args, rc_settings):
    
    settings = {}
    for key, value in args.items():
        if key in ['reverse', 'opposite']:
            settings[key] = value ^ rc_settings.get(key, False)
        else:
            settings[key] = value or rc_settings.get(key)

    if not settings['size']:
        settings['size'] = DEFAULT_SIZE
    return settings
91415
def use_settings(self, settings_module):
        '''
        
        '''
        self._previous_settings = self.settings_module
        self.settings_module = settings_module
        self.reconfigure()