def __init__(self, cliargs=None, **kwargs): defaults = cliargs or {} for k in [k for k in defaults.keys() if not defaults[k]]: del defaults[k] defaults.setdefault('socket-path', '/run/amavisvtd.sock') defaults.setdefault('positive-expire', str(21 * 86400)) defaults.setdefault('negative-expire', str(12 * 3600)) defaults.setdefault('unknown-expire', str(12 * 3600)) defaults.setdefault('timeout', '10') defaults.setdefault('hits-required', "5") defaults.setdefault('pretend', 'false') defaults.setdefault('api-url', "https://www.virustotal.com/vtapi/v2/file/report") defaults.setdefault('report-url', "https://www.virustotal.com/vtapi/v2/file/scan") defaults.setdefault('database-path', '/var/lib/amavisvt/amavisvt.sqlite3') defaults.setdefault('filename-pattern-detection', 'false') defaults.setdefault('min-filename-patterns', '20') defaults.setdefault('infected-percent', '0.7') defaults.setdefault('auto-report', 'false') ConfigParser.__init__(self, defaults=defaults) paths = kwargs.get('path', None) if paths: paths = [paths] else: paths = [ '/etc/amavisvt.cfg', os.path.expanduser('~/.amavisvt.cfg'), 'amavisvt.cfg' ] files_read = self.read(paths) logger.info("Read configuration files: %s", files_read)
def __init__(self, piefolder=None, headerfile=None): SafeConfigParser.__init__(self) assert piefolder or headerfile if piefolder: assert type(piefolder) == PieFolder assert piefolder.initialised == 1 if piefolder: self.add_section(_('Folder Information')) self.set(_('Folder Information'), _('Name'), piefolder.EndName.encode('utf8')) self.set(_('Folder Information'), _('Area'), piefolder.Root.encode('utf8')) self.set(_('Folder Information'), _('Record System No.'), piefolder.RecordFile.encode('utf8')) self.set(_('Folder Information'), _('Security Level'), SECURITY_CLASSES[piefolder.SecurityLevel]) self.path = piefolder.path() elif headerfile: assert os.path.isfile(headerfile) self.read(headerfile) self.recordfile = self.get(_('Folder Information'), _('Record System No.')) self.securitylevel = self.get(_('Folder Information'), _('Security Level'))
def __init__(self): # enforce singleton pattern if(not Configuration.__configuration == None): raise Configuration.__configuration Configuration.__configuration = self SafeConfigParser.__init__(self) # get a logger self.__logger = logging.getLogger("chattest.server.Configuration") self.__logger.debug("Created a new Configuration object...") # create the default sections self.add_section("network") self.add_section("database") self.add_section("miscellaneous") self.add_section("telnet") # set the default values self.set("miscellaneous", "daemon", "true") self.set("miscellaneous", "ping", "1") self.set("miscellaneous", "timeout", "5") self.set("network", "port", "8376") self.set("database", "type", "local") self.set("database", "host", "localhost") self.set("database", "database", "chattest") self.set("database", "user", "root") self.set("database", "password", "password") self.set("telnet", "port", "8377") self.set("telnet", "user", "telnet") self.set("telnet", "password", "telnet")
def __init__(self, defaults=global_defaults, configfile=None): self.__dict__ = self.__shared_state if getattr(self, "baseconfig", None): if not configfile or self.baseconfig == os.path.realpath(configfile): return raise AquilonError("Could not configure with %s, already " "configured with %s" % (configfile, self.baseconfig)) # This is a small race condition here... baseconfig could be # checked here, pre-empted, checked again elsewhere, and also # get here. If that ever happens, it is only a problem if one # passed in a configfile and the other didn't. Punting for now. if configfile: self.baseconfig = os.path.realpath(configfile) else: self.baseconfig = os.path.realpath(os.environ.get("AQDCONF", "/etc/aqd.conf")) SafeConfigParser.__init__(self, defaults) src_defaults = lookup_file_path("aqd.conf.defaults") read_files = self.read([src_defaults, self.baseconfig]) for file in [src_defaults, self.baseconfig]: if file not in read_files: raise AquilonError("Could not read configuration file %s." % file) # Allow a section to "pull in" another section, as though all the # values defined in the alternate were actually defined there. for section in self.sections(): section_option = "%s_section" % section if self.has_option(section, section_option): alternate_section = self.get(section, section_option) if self.has_section(alternate_section): for (name, value) in self.items(alternate_section): self.set(section, name, value)
def __init__(self, defaults = {}, types = {}): """Constructor. If any filenames given tries to parse them Input: (string) filename. You can pass pultiple file names (dict) defaults: {'section': {'attrib': 'value'}}, (dict) types: {'section': {'attrib': 'type'}}; types supported are: int, str, string, float, bool; default: string Output: (Config) class instance """ # call base class constructors SafeConfigParser.__init__(self) #UserDict.__init__(self) ### IMPORTANT!!! Link self.data to self._sections to provide connectivity between UserDict and SafeConfigParser self.data = self._sections self._types = types self._defaultOptions = defaults self._rawData = {} for (section, attributes) in defaults.items(): section = str(section) if not self.has_section(section): self.add_section(section) for (key, value) in attributes.items(): key = self.optionxform(str(key)) self.set(section, key, value)
def __init__(self): self._log = logging.getLogger('%s.%s' % (__name__, self.__class__.__name__)) self._log.addHandler(NullHandler.NullHandler()) SafeConfigParser.__init__(self) self.add_section('scoreboard') self.set('scoreboard', 'errors', "ERROR") self.set('scoreboard', 'warnings', "WARNING WARN") self.set('scoreboard', 'test_begin', "TEST_BEGIN") self.set('scoreboard', 'test_end', "TEST_END") # logging.error("HERE IS AN ERROR") # self.logger = logging.getLogger(__name__) # self.logger.addHandler(NullHandler.NullHandler()) # logging.getLogger(__name__).addHandler(NullHandler.NullHandler()) self.rc_files = [] self.successful_rc_files = [] if (sys.platform in unix_plats): self.rc_files = [ '/etc/simshop/simshoprc', os.path.normpath(os.path.expanduser("~") + "/.simshoprc"), ] elif (sys.platform in win_plats): self.rc_files = [ os.path.normpath(os.environ['ALLUSERSPROFILE'] + "/simshoprc"), os.path.normpath(os.environ['USERPROFILE'] + "/simshoprc"), ]
def __init__(self): self._log = logging.getLogger('%s.%s' % (__name__, self.__class__.__name__)) self._log.addHandler(NullHandler.NullHandler()) SafeConfigParser.__init__(self) self.add_section('scoreboard') self.set('scoreboard', 'errors', "ERROR") self.set('scoreboard', 'warnings', "WARNING WARN") self.set('scoreboard', 'test_begin', "TEST_BEGIN") self.set('scoreboard', 'test_end', "TEST_END") # logging.error("HERE IS AN ERROR") # self.logger = logging.getLogger(__name__) # self.logger.addHandler(NullHandler.NullHandler()) # logging.getLogger(__name__).addHandler(NullHandler.NullHandler()) self.rc_files = [] self.successful_rc_files = [] if(sys.platform in unix_plats): self.rc_files = [ '/etc/simshop/simshoprc', os.path.normpath(os.path.expanduser("~") + "/.simshoprc"), ] elif(sys.platform in win_plats): self.rc_files = [ os.path.normpath(os.environ['ALLUSERSPROFILE'] + "/simshoprc"), os.path.normpath(os.environ['USERPROFILE'] + "/simshoprc"), ]
def __init__(self, path): # with open(path, 'r') as cfg_file: # cfg_txt = os.path.expandvars(cfg_file.read()) # SafeConfigParser.__init__(self) # self.readfp(StringIO.StringIO(cfg_txt)) SafeConfigParser.__init__(self, os.environ) self.read(path)
def __init__(self, filename): # Do singleton checking. if Config.INSTANCE != None: raise Exception('Singleton error: an instance of Config already exists.') # Create the parent dir if it does not exist. if not os.path.exists(filename): dirname = os.path.dirname(filename) if dirname != '': os.mkdir(dirname) # Initialize the config by reading in the file and then checking if # standard values must be plugged in... SafeConfigParser.__init__(self) self._filename = filename self.read(self._filename) self._dirty = False self.set_defaults() # Write the config file if necessary. if self._dirty: with open(self._filename, 'wb') as configfile: self.write(configfile) self._dirty = False # Set the singleton pointer. Config.INSTANCE = self
def __init__(self, request): # Note that SafeConfigParser if not a new class so we have to explicitly # call the __init__method SafeConfigParser.__init__(self) try: host = request.session['host'] username = request.session['username'] user_conf = os.path.join(settings.USERCONFDIR, '%s@%s.conf' % (username,host)) if not os.path.isfile(user_conf): # Touch the user configuration file open(user_conf, 'w').close() server_conf = os.path.join(settings.SERVERCONFDIR, '%s.conf' % host ) config_files = [ settings.FACTORYCONF, settings.DEFAULTCONF, user_conf, server_conf, settings.SYSTEMCONF ] except KeyError: config_files = [ settings.FACTORYCONF, settings.DEFAULTCONF ] self.read( config_files )
def __init__(self, file='C:\plexus\config.ini', part_number="",hwrev="",ccode="", operatorID="", mac="",product="" ): SafeConfigParser.__init__(self) if os.path.isfile( file ): self.no_log = False else: self.no_log = True print "PlexusLog config file not found: %s" % file self.file = file self.read(file) logging.debug("loading: %s " % self.file) self.operatorID = operatorID self.mac = ''.join(mac) self.AssemblyNo = "113-%s-%s-%s" % ( part_number, hwrev, ccode) self.FixtureID = self.get_data('Datalog','FixtureID','NoFixture') self.SystemID = self.get_data('Datalog','SystemID','NoSystemID') self.Extension = self.get_data('Datalog','Extension','NoExtension') self.EventTyp = self.get_data('Datalog','EventTyp','NoEventTyp') self.ProcessTyp = self.get_data('Datalog','ProcessTyp','NoProcessTyp') # self.TestSystemID = self.get_data('Datalog','TestSystemID','NoTestSystemID') self.CustomerID = self.get_data('Datalog','CustomerID','NoCustomerID') self.EcRevLvl = hwrev self.product = product self.TestSystemID = self.product + self.ProcessTyp + self.SystemID default_path = file.replace('config.ini','Log') self.Result_path = self.get_data('Path','Result_path', default_path) if os.path.isdir( self.Result_path ) == False: self.no_log = True print "PlexusLog path not found: %s" % self.Result_path
def __init__(self, cliargs=None, **kwargs): defaults = cliargs or {} for k in [k for k in defaults.keys() if not defaults[k]]: del defaults[k] defaults.setdefault("socket-path", "/run/amavisvtd.sock") defaults.setdefault("positive-expire", str(21 * 86400)) defaults.setdefault("negative-expire", str(12 * 3600)) defaults.setdefault("unknown-expire", str(12 * 3600)) defaults.setdefault("timeout", "10") defaults.setdefault("hits-required", "5") defaults.setdefault("pretend", "false") defaults.setdefault("api-url", "https://www.virustotal.com/vtapi/v2/file/report") defaults.setdefault("report-url", "https://www.virustotal.com/vtapi/v2/file/scan") defaults.setdefault("database-path", "/var/lib/amavisvt/amavisvt.sqlite3") defaults.setdefault("filename-pattern-detection", "false") defaults.setdefault("min-filename-patterns", "20") defaults.setdefault("infected-percent", "0.7") defaults.setdefault("auto-report", "false") ConfigParser.__init__(self, defaults=defaults) paths = kwargs.get("path", None) if paths: paths = [paths] else: paths = ["/etc/amavisvt.cfg", os.path.expanduser("~/.amavisvt.cfg"), "amavisvt.cfg"] files_read = self.read(paths) logger.info("Read configuration files: %s", files_read)
def __init__(self, env): SafeConfigParser.__init__(self) self._updated = {} self.env = env if os.path.exists(self._userconfigfile): self.read(self._userconfigfile) elif os.path.exists(self._globalconfigfile): self.read(self._globalconfigfile) else: SafeConfigParser.set(self, "general", "threshold_timeout", "5") SafeConfigParser.set(self, "general", "x11_idle_timeout", "5") SafeConfigParser.set(self, "idmef", "profile", "requiem-notify") SafeConfigParser.set(self, "idmef", "filter", "") SafeConfigParser.set(self, "manager", "addresses", "127.0.0.1") SafeConfigParser.set(self, "confutatis", "url", "http://localhost:8000") SafeConfigParser.set(self, "ui", "theme", "default") SafeConfigParser.set(self, "ui", "browser", "auto") _configtheme = SafeConfigParser.get(self,"ui","theme") if os.path.isdir( userthemespath + "/" + _configtheme ): self.theme = userthemespath + "/" + _configtheme elif os.path.isdir( globalthemespath + "/" + _configtheme ): self.theme = globalthemespath + "/" + _configtheme else: self.theme = globalthemespath + "/" + "default"
def __init__(self, server, fd): """""" SafeConfigParser.__init__(self) self.readfp(fd) self.server = server self.version = self.get(SECTION_MAIN, OPTION_VERSION) self.services = self.items(SECTION_UPDATES)
def __init__(self, files=None, keep_dashes=True): """Initialize files[in] The files to parse searching for configuration items. keep_dashes[in] If False, dashes in options are replaced with underscores. Raises ValueError if defaults is set to True but defaults files cannot be found. """ # Regular expression to allow options with no value(For Python v2.6) self.OPTCRE = re.compile( # pylint: disable=C0103 r'(?P<option>[^:=\s][^:=]*)' r'\s*(?:' r'(?P<vi>[:=])\s*' r'(?P<value>.*))?$' ) self._options_dict = {} SafeConfigParser.__init__(self) self.default_extension = DEFAULT_EXTENSIONS[os.name] self.keep_dashes = keep_dashes if not files: raise ValueError('files argument should be given') if isinstance(files, str): self.files = [files] else: self.files = files self._parse_options(list(self.files)) self._sections = self.get_groups_as_dict()
def __init__(self, conf): """""" SafeConfigParser.__init__(self) self.read(conf) if self.has_section("pages"): for option in self.options("pages"): if self.has_section(option): css = None if self.has_option(option, "css"): css = self.get(option, "css") t = Template(self.get(option, "title"), css) advanced_options = [] if self.has_option(option, "advanced"): advanced = self.get(option, "advanced") if self.has_section(advanced): for advanced_option in self.options(advanced): tmp = [ advanced_option, self.get(advanced, advanced_option) ] if self.has_section(advanced_option): tmp.append(self.items(advanced_option)) advanced_options.append(tmp) t.add_content(option, advanced_options) t.save(self.get("pages", option))
def __init__(self): SafeConfigParser.__init__(self) self.add_section('pungi') self.set('pungi', 'osdir', 'os') self.set('pungi', 'sourcedir', 'source') self.set('pungi', 'debugdir', 'debug') self.set('pungi', 'isodir', 'iso') self.set('pungi', 'relnotefilere', 'GPL README-BURNING-ISOS-en_US.txt ^RPM-GPG') self.set('pungi', 'relnotedirre', '') self.set('pungi', 'relnotepkgs', 'fedora-release fedora-release-notes') self.set('pungi', 'product_path', 'Packages') self.set('pungi', 'cachedir', '/var/cache/pungi') self.set('pungi', 'compress_type', 'xz') self.set('pungi', 'arch', yum.rpmUtils.arch.getBaseArch()) self.set('pungi', 'name', 'Fedora') self.set('pungi', 'iso_basename', 'Fedora') self.set('pungi', 'version', time.strftime('%Y%m%d', time.localtime())) self.set('pungi', 'flavor', '') self.set('pungi', 'destdir', os.getcwd()) self.set('pungi', 'workdirbase', "/work") self.set('pungi', 'bugurl', 'https://bugzilla.redhat.com') self.set('pungi', 'cdsize', '695.0') self.set('pungi', 'debuginfo', "True") self.set('pungi', 'bootiso', "False") self.set('pungi', 'alldeps', "True") self.set('pungi', 'isfinal', "False") self.set('pungi', 'nohash', "False") self.set('pungi', 'full_archlist', "False") self.set('pungi', 'multilib', '') self.set('pungi', 'lookaside_repos', '') self.set('pungi', 'resolve_deps', "True") self.set('pungi', 'no_dvd', "False")
def __init__(self): SafeConfigParser.__init__(self) self.default_config = """ # global options concerning all / multiple modules or theta itself [global] debug = False check_cache = True # minimizer options [minimizer] always_mcmc = False mcmc_iterations = 1000 bootstrap_mcmcpars = 0 # strategy can be 'fast' or 'robust' strategy = fast minuit_tolerance_factor = 1 [cls_limits] clb_cutoff = 0.01 create_debuglog = True [model] use_llvm = False [main] n_threads = 1 """ self.readfp(io.BytesIO(self.default_config))
def __init__(self): SafeConfigParser.__init__(self) self.add_section('pungi') self.add_section('lorax') self.set('pungi', 'osdir', 'os') self.set('pungi', 'sourcedir', 'source') self.set('pungi', 'debugdir', 'debug') self.set('pungi', 'isodir', 'iso') self.set('pungi', 'relnotefilere', 'GPL README-BURNING-ISOS-en_US.txt ^RPM-GPG') self.set('pungi', 'relnotedirre', '') self.set('pungi', 'relnotepkgs', 'fedora-release fedora-release-notes') self.set('pungi', 'product_path', 'Packages') self.set('pungi', 'cachedir', '/var/cache/pungi') self.set('pungi', 'compress_type', 'xz') self.set('pungi', 'arch', yum.rpmUtils.arch.getBaseArch()) self.set('pungi', 'name', 'Fedora') self.set('pungi', 'iso_basename', 'Fedora') self.set('pungi', 'version', time.strftime('%Y%m%d', time.localtime())) self.set('pungi', 'flavor', '') self.set('pungi', 'destdir', os.getcwd()) self.set('pungi', 'workdirbase', "/work") self.set('pungi', 'bugurl', 'https://bugzilla.redhat.com') self.set('pungi', 'cdsize', '695.0') self.set('pungi', 'debuginfo', "True") self.set('pungi', 'alldeps', "True") self.set('pungi', 'isfinal', "False") self.set('pungi', 'nohash', "False") self.set('pungi', 'full_archlist', "False") self.set('pungi', 'multilib', '') self.set('pungi', 'lookaside_repos', '') self.set('pungi', 'resolve_deps', "True") self.set('pungi', 'no_dvd', "False") self.set('pungi', 'nomacboot', "False")
def __init__(self, defaults = None, *args, **kwargs): if not defaults: defaults = {} SafeConfigParser.__init__(self, *args, **kwargs) self.defaults = defaults
def __init__(self, fp, defaults): SafeConfigParser.__init__(self) self.namespace = {} loggingcfg = None if fp: if fp.read(2) == '#!': fp.seek(0) exec fp.read() in globals(), self.namespace config = self.namespace['__doc__'] else: fp.seek(0) config = fp.read() # Look for a [[logging]] separator, that introduce a # standard logging section cfgs = config.split(LOGGING_SUPER_SECTION) if len(cfgs) == 2: tailorcfg, loggingcfg = cfgs else: tailorcfg = cfgs[0] self.readfp(StringIO(tailorcfg)) # Override the defaults with the command line options if defaults: self._defaults.update(defaults) self._setupLogging(loggingcfg and loggingcfg or BASIC_LOGGING_CONFIG)
def __init__(self, inifile, defaults=None): SafeConfigParser.__init__(self, defaults) self.inifile = inifile # Make the _sections list an ordered dict, so that the section # names occur in order. self._sections = OrderedDict() self.orderedKeys = {}
def __init__(self, files=None, keep_dashes=True): # pylint: disable=W0231 """Initialize If defaults is True, default option files are read first Raises ValueError if defaults is set to True but defaults files cannot be found. """ # Regular expression to allow options with no value(For Python v2.6) self.OPTCRE = re.compile( # pylint: disable=C0103 r'(?P<option>[^:=\s][^:=]*)' r'\s*(?:' r'(?P<vi>[:=])\s*' r'(?P<value>.*))?$') self._options_dict = {} if PY2: SafeConfigParser.__init__(self) else: SafeConfigParser.__init__(self, strict=False) self.default_extension = DEFAULT_EXTENSIONS[os.name] self.keep_dashes = keep_dashes if not files: raise ValueError('files argument should be given') if isinstance(files, str): self.files = [files] else: self.files = files self._parse_options(list(self.files)) self._sections = self.get_groups_as_dict()
def __init__(self, files=None, keep_dashes=True): """Initialize files[in] The files to parse searching for configuration items. keep_dashes[in] If False, dashes in options are replaced with underscores. Raises ValueError if defaults is set to True but defaults files cannot be found. """ # Regular expression to allow options with no value(For Python v2.6) self.OPTCRE = re.compile( # pylint: disable=C0103 r'(?P<option>[^:=\s][^:=]*)' r'\s*(?:' r'(?P<vi>[:=])\s*' r'(?P<value>.*))?$') self._options_dict = {} SafeConfigParser.__init__(self) self.default_extension = DEFAULT_EXTENSIONS[os.name] self.keep_dashes = keep_dashes if not files: raise ValueError('files argument should be given') if isinstance(files, str): self.files = [files] else: self.files = files self._parse_options(list(self.files)) self._sections = self.get_groups_as_dict()
def __init__(self, config_file=None, defaults=None, dict_type=None): if dict_type is not None: SafeConfigParser.__init__(self, defaults, dict_type) else: SafeConfigParser.__init__(self, defaults) if config_file is not None: self.read(config_file)
def __init__(self, defaults={}, types={}): """Constructor. If any filenames given tries to parse them Input: (string) filename. You can pass pultiple file names (dict) defaults: {'section': {'attrib': 'value'}}, (dict) types: {'section': {'attrib': 'type'}}; types supported are: int, str, string, float, bool; default: string Output: (Config) class instance """ # call base class constructors SafeConfigParser.__init__(self) #UserDict.__init__(self) ### IMPORTANT!!! Link self.data to self._sections to provide connectivity between UserDict and SafeConfigParser self.data = self._sections self._types = types self._defaultOptions = defaults self._rawData = {} for (section, attributes) in defaults.items(): section = str(section) if not self.has_section(section): self.add_section(section) for (key, value) in attributes.items(): key = self.optionxform(str(key)) self.set(section, key, value)
def __init__(self): # enforce singleton pattern if(not Configuration.__configuration == None): raise Configuration.__configuration Configuration.__configuration = self SafeConfigParser.__init__(self) # get a logger self.__logger = logging.getLogger("chattest.loadtest.Configuration") self.__logger.debug("Created a new Configuration object...") # create the default sections self.add_section("network") self.add_section("users") self.add_section("sleep") # set the default values self.set("network", "host", "localhost") self.set("network", "port", "8376") self.set("users", "amount", "50") self.set("users", "prefix", "loadtest") self.set("users", "password", "loadtest") self.set("sleep", "start", "5") self.set("sleep", "send", "1")
def __init__(self, file_path): """""" SafeConfigParser.__init__(self) try: self.read(file_path) #read config file except Exception as err: logger.info(err) self.create_config()
def __init__(self): """""" SafeConfigParser.__init__(self) if not os.path.exists(cons.CONFIG_PATH + HISTORY): self.save() self.read(cons.CONFIG_PATH + HISTORY) self.id = len(self.sections()) shared.events.connect(cons.EVENT_FILE_COMPLETE, self.add_history)
def __init__(self, path, fd=None): """""" SafeConfigParser.__init__(self) self.path = path if fd: self.readfp(fd) elif os.path.exists(os.path.join(self.path, CONF)): self.read(os.path.join(self.path, CONF))
def __init__(self, filename, codec): self._comments = {} SafeConfigParser.__init__(self) self.filename = filename self.codec = codec self.dirty = False self.stamp = 0xFFFFFFFF self.reload()
def __init__(self): SafeConfigParser.__init__(self) conf_file = os.path.expanduser('~/.glaciercmd') if os.path.isfile(conf_file): self.read(conf_file) else: self._error_messages.append("Could not locate the .glaciercmd configuration file.")
def __init__(self): SafeConfigParser.__init__(self) # self.config_file = './config.ini' config_path = os.path.dirname(__file__) self.config_file = os.path.join(config_path, 'config.ini') try: self.read(self.config_file) except Exception: traceback.format_exc()
def __init__(s,fn='site.cfg'): ConfigParser.__init__( s ) s.read(fn) if not s.has_section('site'): s.add_section('site') assert s.has_section('tasbot'), 'You need to have a tasbot section in your config file, see site.cfg.example' with open(SimpleConfig.tasbot_cfg_filename, 'w') as tasbot_cfg: for (name,val) in s.items('tasbot'): tasbot_cfg.write( '%s=%s;\n'%(name,val) )
def __init__(self, app=None, defaults=None, dict_type=_default_dict, allow_no_value=False): SafeConfigParser.__init__(self, defaults=defaults, dict_type=dict_type, allow_no_value=allow_no_value) # so the the normalization to lower case does not happen self.optionxform = str if app is not None: self.init_app(app)
def __init__(self, config_file=None): if config_file is None: config_file = settings.CONFIG_FILE logger.debug("levantando la config %s", config_file) SafeConfigParser.__init__(self, Configuracion.DEFAULT_CONFIG) self.config_file = config_file self.section = Configuracion.DEFAULT_SECTION self.reload_options()
def __init__(self, *args, **kwargs): self.reload() SafeConfigParser.__init__(self, *args, **kwargs) # The superclass _sections attr takes precedence over the property of # the same name defined below. Deleting it exposes that property to hook # the config loading mechanism into an attribute used by just about every # ConfigParser method. self._lazy_sections = self._sections del self._sections
def __init__(self): SafeConfigParser.__init__(self) filename = os.getenv('KB_API_CONFIG', None) if filename is None: raise ConfigurationError("KB_API_CONFIG not in environment") try: with open(filename, 'r') as f: self.readfp(f) except IOError as e: raise ConfigurationError("Could not load configuration file: {0}".format(e))
def __init__(self, configfile): SafeConfigParser.__init__(self) self.read( os.path.join( os.path.dirname(__file__), 'default.cfg' )) if configfile is not None: self.readfp(configfile)
def __init__(self, path=None, fp=None, do_load=True): ConfigParser.__init__(self, {"debug": 0}) if do_load: if path: self.load_from_path(path) elif fp: self.readfp(fp) else: self.read(NeneConfigLocations)
def __init__(self, section=None, strings=False): SafeConfigParser.__init__(self) self.section = section if strings: self.read(ConfigHandler.STRINGS_FILENAME) else: self.read(ConfigHandler.CONFIG_FILENAME) if section is not None: self.section_vars = dict(self.items(section))
def __init__(s, fn='site.cfg'): ConfigParser.__init__(s) s.read(fn) if not s.has_section('site'): s.add_section('site') assert s.has_section( 'tasbot' ), 'You need to have a tasbot section in your config file, see site.cfg.example' with open(SimpleConfig.tasbot_cfg_filename, 'w') as tasbot_cfg: for (name, val) in s.items('tasbot'): tasbot_cfg.write('%s=%s;\n' % (name, val))
def __init__(self): SafeConfigParser.__init__(self) try: default_config = pkg_resources.resource_stream( 'shaney.sourapples', 'defaults.ini') except NameError: # the import of pkg_resources must have failed. default_config = file(os.path.join( os.path.dirname(__file__), 'defaults.ini')) self.readfp(default_config) self.read(['make_config.ini'])
def __init__(self): SafeConfigParser.__init__(self) # LOCK Config() and read configuration file self._acquireLock() # Write Flag # Used to prevent writing back to config file if it was just opened for reading self.writeFlag = False #### Define default config values ### [main] ## Default DEBUG Value self.debug = False ### [gui] ## Filter checkbox self.filter = True ### [shows] ## My Shows self.myShows = [] ### [display] ## Past days to display self.numPastDays = 1 ## Lines self.linesFixed = 10 self.linesMin = 1 self.linesMax = 10 self.linesType = "Fixed" # Values: Fixed / Auto ## Format self.format = "$show:12:...$-S$season:2$E$episode:2$-$title$" ## Theme self.theme = Globals().defaultThemeName ## Date self.dateFormat = "%%d/%%m/%%y" ## Date Separator self.dateSeparator = "/" ## When format self.whenFormat = 0 ### [colors] self.myColors = {} self.myColors['default'] = "#111111" self.myColors['ranges'] = [(-99, -1, "#771111"), (0, 0, "#117711"), (1, 1, "#111177")] ### [misc] self.cacheExpiration = 1 self.browser = "firefox -remote 'openURL($url$,new-tab)'" #### Create necessary dir structure self._initConfigStorage()
def __init__(self, group_name, app_name, search_path=None, filename='app.ini', **kwargs): SafeConfigParser.__init__(self, **kwargs) self.config = None self.group_name = group_name self.app_name = app_name self.search_path = search_path self.filename = filename self.loaded_files = [] self.active_path = [] self.load()
def __init__(self, files=['/etc/decades/decades.ini', 'decades.ini']): SafeConfigParser.__init__(self) self.read(files) #get the Parameters parameters_file = self.get('Config', 'parameters_file') with open(parameters_file, 'r') as csvfile: self.add_section('Parameters') parameters = csv.DictReader( csvfile) #uses first line as fieldnames for line in parameters: self.set('Parameters', line['ParameterIdentifier'], line['ParameterName'])
def __init__(self): SafeConfigParser.__init__(self) try: f = file('options.cfg') self.read('options.cfg') except IOError: for (k, v) in DEFAULTS.items(): self.add_section(k) for (k2, v2) in v.items(): self.set(k, str(k2), str(v2)) f = file('options.cfg', 'w') self.write(f)
def __init__(self, filename="wxfalsecolor.cfg", logger=None): self._log = logger if logger else DummyLogger() self.filename = filename SafeConfigParser.__init__(self) self.set_defaults(BUILT_IN_CONFIG) ## read config file if it exists configfile = self.get_filepath() if os.path.isfile(configfile): self._log.info("reading config file '%s'" % configfile) self.read(configfile) ## set this after defaults and existing file have been loaded self._changed = False
def __init__(self, configfile=None): SafeConfigParser.__init__(self) configfiles = [] # Add the filename for the config file in the modules # directory self.opengrid_libdir = os.path.dirname( os.path.abspath(inspect.getfile(inspect.currentframe()))) configfiles.append(os.path.join(self.opengrid_libdir, 'opengrid.cfg')) # Add the filename for the config file in the 'current' directory configfiles.append('opengrid.cfg') # Add the filename for the config file passed in if configfile: configfiles.append(configfile) self.read(configfiles)
def __init__(self, path, **kwargs): SafeConfigParser.__init__(self, **kwargs) if isinstance(path, (list, tuple)): for p in path: self.check_file_existence(p) else: self.check_file_existence(path) self.path = path self.kwargs = kwargs logger.debug('Reading config(s) at %r. Given kwargs are:\n\n%s\n', self.path, pformat(self.kwargs))