Get list of all appropriate settings and their default values.
165967
def list_settings(self):
        
        result = super().list_settings()
        result.append((self.SETTING_TREE_FORMATING, {}))
        result.append((self.SETTING_TREE_STYLE, 'utf8.a'))
        return result
134960
def list_settings(self):
        
        result = super().list_settings()
        result.append((self.SETTING_LIST_FORMATING, {}))
        result.append((self.SETTING_LIST_STYLE, 'utf8.a'))
        result.append((self.SETTING_LIST_TYPE, 'unordered'))
        return result
1015473
def get_settings(self):
    '''
    '''
    config = self._load_config_user()
    if self.name in config:
        return config[self.name]
321253
def get_options():
    """"""
    options = collections.defaultdict(list)
    for opt_class in config_factory.get_options():
        if not issubclass(opt_class, config_base.Options):
            continue
        config_options = opt_class(None)
        options[config_options.group_name].extend(config_options.list())
    return [(key, value) for key, value in options.items()]
355931
def _defaults():
    
    d = {}
    d['url'] = os.environ.get('BUGZSCOUT_URL')
    d['user'] = os.environ.get('BUGZSCOUT_USER')
    d['project'] = os.environ.get('BUGZSCOUT_PROJECT')
    d['area'] = os.environ.get('BUGZSCOUT_AREA')
    return d
1101735
def defaults(values={}):
    """"""
    if values: return values
    save_types = basestring, int, float, tuple, list, dict, type(None)
    for k, v in globals().items():
        if isinstance(v, save_types) and not k.startswith("_"): values[k] = v
    return values
333912
private function getListSettings()
    {
        $settingsStorage = $this->getSettingsStorage();
        if (!$settingsStorage->exists(CspHeaderSettingsInterface::CSP_HEADER_LIST)) {
            return [];
        }

        return json_decode($settingsStorage->get(CspHeaderSettingsInterface::CSP_HEADER_LIST));
    }
306386
def settings(self):
        
        if self._settings is None:
            self._settings = SettingsList(self._version, )
        return self._settings
1132539
def get_setting(*args, **kwargs):
    """"""
    for name in args:
        if hasattr(settings, name):
            return getattr(settings, name)
    if kwargs.get('raise_error', False):
        setting_url = url % args[0].lower().replace('_', '-')
        raise ImproperlyConfigured('Please make sure you specified at '
            'least one of these settings: %s \r\nDocumentation: %s'
            % (args, setting_url))
    return kwargs.get('default_value', None)
305927
async def get_misc_settings(self) -> List[Setting]:
        """"""
        misc = await self.services["system"]["getDeviceMiscSettings"](target="")
        return [Setting.make(**x) for x in misc]
1119594
def _get_settings(self):
        
        # If user-defined settings exist...
        if isdefined(self.inputs.settings):
            # Note this in the log and return those settings.
            NIWORKFLOWS_LOG.info('User-defined settings, overriding defaults')
            return self.inputs.settings

        # Define a prefix for output files based on the modality of the moving image.
        filestart = '{}-mni_registration_{}_'.format(
            self.inputs.moving.lower(), self.inputs.flavor)

        # Get a list of settings files that match the flavor.
        filenames = [i for i in pkgr.resource_listdir('niworkflows', 'data')
                     if i.startswith(filestart) and i.endswith('.json')]
        # Return the settings files.
        return [pkgr.resource_filename('niworkflows.data', f)
                for f in sorted(filenames)]
715273
def settings(self):
        
        settings_file = os.path.join(os.getcwd(), 'settings', self.module.lower() + '.ini')

        # Loads the settings file once.
        if (not hasattr(self, '_settings') or self._settings is None) and os.path.isfile(settings_file):
            config = ConfigParser.ConfigParser()
            config.read(settings_file)

            settings = dict(config._sections)
            for key in settings:
                settings[key] = dict(config.defaults(), **settings[key])
                settings[key].pop('__name__', None)

            self._settings = SettingsDict(self, settings.get(self.name, {}))

        elif not hasattr(self, '_settings'):
            self._settings = SettingsDict(self, {})

        return self._settings
232177
def list_settings(self):
        
        result = super().list_settings()
        result.append((self.SETTING_FLAG_HEADER, True))
        result.append((self.SETTING_HEADER_CONTENT, 'Notice'))
        result.append((self.SETTING_HEADER_FORMATING, {}))
        return result
399037
def process_environment_settings(default_dictionary: dict, settings: typing.Optional[dict]=None,
                                 presets: typing.Optional[dict]=None):
    
    settings = settings if settings is not None else {}
    presets = presets if presets is not None else {}

    env_keys = sorted(set(default_dictionary.keys()) | set(presets.keys()))

    result_dict = {}

    for key in env_keys:
        if key in default_dictionary:
            new_dict = default_dictionary[key].copy()
        else:
            new_dict = {}

        new_dict.update(settings)

        if key in presets:
            new_dict.update(presets[key])

        result_dict[key] = new_dict

    return result_dict
925987
def _get_form_defaults(self):
        """"""

        return {
            'response_format': 'html',
            'bbox': self.service.full_extent,
            'size': '400,400',
            'dpi': 200,
            'image_projection': pyproj.Proj(str(self.service.projection)),
            'bbox_projection': pyproj.Proj(str(self.service.projection)),
            'image_format': 'png',
            'transparent': True
        }
45150
def __get_default_settings(self):
        

        LOGGER.debug("> Accessing '{0}' default settings file!".format(UiConstants.settings_file))
        self.__default_settings = QSettings(
            umbra.ui.common.get_resource_path(UiConstants.settings_file), QSettings.IniFormat)
1061192
def config():
    ''''''
    if hasattr(current_app, 'settings_file'):
        log.info('Loaded configuration from %s', current_app.settings_file)

    log.info(white('Current configuration'))
    for key in sorted(current_app.config):
        if key.startswith('__') or not key.isupper():
            continue
        echo('{0}: {1}'.format(white(key), current_app.config[key]))