def __init__(self, filename, mixer): from ConfigParser import RawConfigParser config = RawConfigParser() config.read(filename) self.play_intro = config.getboolean('Main', 'play_intro') if mixer: self.mixer = config.getboolean('Main', 'mixer') else: self.mixer = False self.music = GetDataPath(config.get('Main', 'music')) self.music = os.path.expanduser(self.music) width = config.getint('Defaults', 'width') height = config.getint('Defaults', 'height') self.subsettings = {} sections = config.sections() for defaults in ('Main', 'Defaults'): sections.remove(defaults) for sec in sections: op_dict = {} for op in config.options(sec): op_dict[op] = config.get(sec, op) if op in ('width', 'height'): op_dict[op] = eval(op_dict[op]) for op in ('width', 'height'): if op not in op_dict or op_dict[op] == 0: op_dict[op] = locals()[op] self.subsettings[sec] = op_dict
def __init__(self, *args): LoginAction.__init__(self, *args) self.set_values(DEFAULT_VALS) self.LOG = self.db.get_logger().getChild('ldap_auth') ldap_conf_file = os.path.join(self.db.config.ext['HOME'], 'ldap_config.ini') if os.path.exists(ldap_conf_file): self.LOG.debug("Reading configuration file 'ldap_config.ini'") cfg = RawConfigParser() cfg.read(ldap_conf_file) if cfg.has_section('ldap'): for (key, value) in cfg.items('ldap'): self.LOG.debug("Setting option %s to %s" % (key, value)) if key in ['use_local_auth', 'autocreate', 'bind_once']: setattr(self, key, cfg.getboolean('ldap', key)) elif key in ['referrals', 'start_tls', 'timeout']: setattr(self, key, cfg.getint('ldap', key)) elif key == 'debug' and cfg.getboolean('ldap', key): self.LOG.setLevel(logging.DEBUG) else: setattr(self, key, value) else: self.LOG.info( "Skipping parsing of file ldap_config.ini as it has no 'ldap' section." )
def _get_autoreload_programs(self, cfg_file): """Get the set of programs to auto-reload when code changes. Such programs will have autoreload=true in their config section. This can be affected by config file sections or command-line arguments, so we need to read it out of the merged config. """ cfg = RawConfigParser() cfg.readfp(cfg_file) reload_progs = {} graceful_reload_progs = {} for section in cfg.sections(): if section.startswith("program:"): try: patterns = ( cfg.get(section, "autoreload_patterns").split(",") if cfg.has_option(section, "autoreload_patterns") else AUTORELOAD_PATTERNS ) if cfg.getboolean(section, "autoreload"): if cfg.getboolean(section, "autoreload_graceful"): graceful_reload_progs[section.split(":", 1)[1]] = patterns else: reload_progs[section.split(":", 1)[1]] = patterns except NoOptionError: pass return (reload_progs, graceful_reload_progs)
def getboolean(self, section, option): try: return RawConfigParser.getboolean(self, section, option) except ValueError: rv = RawConfigParser.getboolean(self, 'DEFAULT', option) syslog(LOG_WARNING, "Invalid boolean value for %s in config file; assuming %s" % (option, rv)) return rv
class Config: def __init__(self, logger): self.logger = logger try: self.conf = RawConfigParser() self.file = httpConstants().getConf() self.conf.read(self.file) self.logger.output('kHTTPd Mini config file loaded.') except: self.logger.output('Can\'t open kHTTPd Mini config file!') def getDocRoot(self): try: return self.conf.get('main', 'root') except: self.logger.output('Can\'t load document root setting of server from '+ self.file +', defaulting to www.') return 'www' def getPort(self): try: return self.conf.getint('main', 'port') except: self.logger.output('Can\'t load port to bind server to from '+ self.file +', defaulting to port 80.') return 80 def getDebug(self): try: return self.conf.getboolean('main', 'debugmode') except: self.logger.output('Can\'t load debug mode setting from '+ self.file +', defaulting to off.') return False def getIndexFile(self): try: return self.conf.get('main', 'indexfile') except: self.logger.output('Can\'t load index file setting from '+ self.file +', defaulting to index.html.') return 'index.html' def getPhpEnabled(self): try: return self.conf.getboolean('php', 'phpenabled') except: self.logger.output('Can\'t load PHP mode setting from '+ self.file +', defaulting to off.') return False def getPhpExec(self): try: return self.conf.get('php', 'name') except: self.logger.output('Can\'t load PHP executable name from '+ self.file +', defaulting to php-cgi.') return 'php-cgi'
def _read_configuration_file(self, path): """Try to read and parse `path` as a configuration file. If the configurations were illegal (checked with `self._validate_options`), raises `IllegalConfiguration`. Returns (options, should_inherit). """ parser = RawConfigParser() options = None should_inherit = True if parser.read(path) and self._get_section_name(parser): option_list = dict([(o.dest, o.type or o.action) for o in self._parser.option_list]) # First, read the default values new_options, _ = self._parse_args([]) # Second, parse the configuration section_name = self._get_section_name(parser) for opt in parser.options(section_name): if opt == 'inherit': should_inherit = parser.getboolean(section_name, opt) continue if opt.replace('_', '-') not in self.CONFIG_FILE_OPTIONS: log.warning("Unknown option '{}' ignored".format(opt)) continue normalized_opt = opt.replace('-', '_') opt_type = option_list[normalized_opt] if opt_type in ('int', 'count'): value = parser.getint(section_name, opt) elif opt_type == 'string': value = parser.get(section_name, opt) else: assert opt_type in ('store_true', 'store_false') value = parser.getboolean(section_name, opt) setattr(new_options, normalized_opt, value) # Third, fix the set-options options = self._fix_set_options(new_options) if options is not None: if not self._validate_options(options): raise IllegalConfiguration('in file: {}'.format(path)) return options, should_inherit
def _readConfig(cls, filename): ''' Read the configuration file and return a pythonic configuration dict. ''' confParser = RawConfigParser( defaults={ # these keys can be commented out in the config file, # warning: the values are converted to strings 'user': None, 'pathRegexFilter': '', 'filenameRegexFilter': '', 'subPath': '', 'includes': '', 'macros': '', 'languages': '', 'metrics': '', 'settings': '', 'aggregateIssueLinks': '', 'shortBlockLines': 4 }) parsedFiles = confParser.read(filename) if not parsedFiles: msg = "Configuration file {} could not be read.".format(filename) raise Exception(msg) conf = { 'sina': {}, 'neteasy': {}, 'hanjie': {}, 'matching': {}, } # TODO: The 'configfie' entry is unused conf['consoleLog'] = confParser.getboolean('global', 'consoleLog') conf['debugMode'] = confParser.getboolean('global', 'debugMode') conf['encoding'] = confParser.get('global', 'encoding') conf['http_proxy'] = confParser.get('global', 'http_proxy') conf['configfile'] = os.path.abspath(filename) conf['basePath'] = os.path.abspath( convertOsPath(confParser.get('global', 'basePath'))) if confParser.has_section('sina'): conf['sina']['url'] = confParser.get('sina', 'url') conf['sina']['user'] = confParser.get('sina', 'user') conf['sina']['password'] = confParser.get('sina', 'password') if confParser.has_section('netease'): conf['netease']['url'] = confParser.get('netease', 'url') conf['netease']['user'] = confParser.get('netease', 'user') conf['netease']['password'] = confParser.get('netease', 'password') _convertDictUnicode(conf) return conf
def __init__(self): for file in ('', ): if os.path.exists(file): break else: file = None if file is None: reactor.callWhenRunning( log.msg, 'No config loaded, use default settings' ) else: with open(file, 'rb') as fp: parser = ConfigParser(); parser.readfp(fp) for section in parser.sections(): for key, value in parser.items(section): key, value = key.lower(), value.decode('utf8') if section == 'general': if key in ( 'timeout','connectionslimit',): value and setattr(self, key, parser.getint(section, key)) elif key in ( 'socksauth',): setattr(self, key, parser.getboolean(section, key)) elif key in ( 'usersfile','listeninterface',): value and setattr(self, key, parser.get(section, key)) else: raise ParsingError, 'unknown key "%s" in section "%s"' % (key, section) else: raise TypeError, 'unknown section "%s"' % (section)
def __init__(self, configuration_file, rewrite=False): parser = RawConfigParser() parser.read(configuration_file) dist_filename = parser.get('files', 'distances-filename') entropy_filename = parser.get('files', 'entropy-filename') self.mRMR_filename = parser.get('files', 'mRMR-filename') self.num_bins = parser.getint('parameters', 'num-bins') self.bin_width = parser.getfloat('parameters', 'bin-width') self.aa = parser.getboolean('parameters', 'aa') self.chains = parser.getint('parameters', 'chains') self.dist_range = [float(i) for i in parser.get('parameters', 'distance-range').split()] self.weights = [float(i) for i in parser.get('parameters', 'weights').split()] self.resi_select = parser.get('parameters', 'excluded-residues').split() if not self.resi_select: self.resi_select = None print "Loading distance file %s" % dist_filename init = time.time() self.dists = cPickle.load(open(dist_filename)) print "Loaded %s in %f seconds" % (dist_filename, time.time() - init) # If no entropy has been provided, entropy must be calculated for permitted residues. print colors.HEADER + "\tENTROPY CALCULATION" + colors.ENDC if os.path.exists(entropy_filename) and not rewrite: warn_file_exists(entropy_filename) self.entropy = cPickle.load(open(entropy_filename)) else: print "No entropy file was found or you have chosen to rewrite. Calculating entropies..." self.entropy = h_fast(self.dists) print "Dumping entopies to", entropy_filename cPickle.dump(self.entropy, open(entropy_filename, 'w'))
def __read_config(self): """ Obtiene la configuración de la persona de su archivo .person y devuelve True si es válida """ pparser = RawConfigParser() with codecs.open("config/" + self.person + '.person', 'r', encoding='utf-8') as cf: pparser.readfp(cf) if pparser.has_section("general"): if pparser.has_option('general', 'name'): self.name = pparser.get('general', 'name') if self.name == '': return False else: return False if pparser.has_option('general', 'notify'): self.notify = pparser.getboolean('general', 'notify') if pparser.has_option('general', 'alarm_threshold'): self.alarm_threshold = pparser.getint('general', 'alarm_threshold') if pparser.has_option('general', 'email'): self.email = pparser.get('general', 'email') if self.email == '' and self.notify: return False else: return False return True
class Configuration(object): """ Singleton class to access application's configuration. """ def __init__(self): self.parser = RawConfigParser() config_file = os.path.join(get_install_dir(), 'config.ini') self.parser.read(config_file) def get(self, section, option): return self.parser.get(section, option) def getboolean(self, section, option): return self.parser.getboolean(section, option) def getfloat(self, section, option): return self.parser.getfload(section, option) def getint(self, section, option): return self.parser.getint(section, option) def has_option(self, section, option): return self.parser.has_option(section, option) def has_section(self, section): return self.parser.has_section(section)
def _read_config(conf_file, running): parser = RawConfigParser() parser.read([conf_file]) for section in sorted(parser.sections()): if parser.has_option(section, 'pattern'): pattern = parser.get(section, 'pattern') else: pattern = None yield dict(command=parser.get(section, 'command'), period=parser.getint(section, 'period'), selected=parser.getboolean(section, 'selected'), active=parser.getboolean(section, 'active'), show_diffs=parser.getboolean(section, 'show_diffs'), pattern=pattern, layout=parser.get(section, 'layout'), graph=parser.getboolean(section, 'graph'))
def __read_config(self): """ Obtiene la configuración de la persona de su archivo .person y devuelve True si es válida """ pparser = RawConfigParser() with codecs.open("config/" + self.person + '.person', 'r', encoding='utf-8') as cf: pparser.readfp(cf) if pparser.has_section("general"): if pparser.has_option('general', 'name'): self.name = pparser.get('general', 'name') if self.name == '': return False else: return False if pparser.has_option('general', 'notify'): self.notify = pparser.getboolean('general', 'notify') if pparser.has_option('general', 'alarm_threshold'): self.alarm_threshold = pparser.getint( 'general', 'alarm_threshold') if pparser.has_option('general', 'email'): self.email = pparser.get('general', 'email') if self.email == '' and self.notify: return False else: return False return True
def read_options(): """Read options""" config = RawConfigParser() config.read(expanduser('~/.lumberrc')) parser = OptionParser() for short, option, section, default, metavar, helptext in OPTIONS: sectiontext = ' Configure in ~/.lumberrc as %s in %s section.' % ( option, section) try: if type(default) == type(True): action = 'store_true' cdefault = config.getboolean(section, option) else: action = 'store' cdefault = config.get(section, option) except (NoOptionError, NoSectionError): cdefault = default argl = [] if short: argl.append ('-'+short) argl.append('--'+option.replace('_', '-')) argk = {'action':action, 'default':cdefault, 'metavar':metavar, 'help':helptext+sectiontext} parser.add_option(*argl, **argk) options, args = parser.parse_args() return options, args, config
class Config: BLINDS = 0 BLINDX = 1 WEB = 2 SECTIONS = ["blinds", "blind_%d", "webServer"] STRING_KEYS = [ "msgFormat", "logFileName", "endPoint", "webRoot", "default", "name", "tag", "address", "cmdDriveIn", "cmdDriveOut", "cmdStop", "headline" ] INT_KEYS = ["maxFilesize", "logLevel", "count"] BOOLEAN_KEYS = ["enableLogging"] DEFAULTS = { "enableLogging": "yes", "logFileName": "/tmp/pbc.log", "maxFilesize": 1000000, "msgFormat": "%(asctime)s, %(levelname)s, %(module)s {%(process)d}, %(lineno)d, %(message)s", "logLevel": 10 } def __init__(self, cfgFile, section): self.section = section self.cfg = RawConfigParser(Config.DEFAULTS) _ = self.cfg.read(cfgFile) def hasKey(self, dct, key): k = key.upper() for d in dct: if d.upper() == k: return d return None def hasSection(self, section): return self.cfg.has_section(section) def hasOption(self, option): return self.cfg.has_option(self.section, option) def __getattr__(self, name): key = self.hasKey(Config.STRING_KEYS, name) if not key is None: return self.cfg.get(self.section, key) key = self.hasKey(Config.INT_KEYS, name) if not key is None: return self.cfg.getint(self.section, key) key = self.hasKey(Config.BOOLEAN_KEYS, name) if not key is None: return self.cfg.getboolean(self.section, key) return None def setSection(self, newSection): tmp = self.section self.section = newSection return tmp def readValue(self, key): return self.cfg.get(self.section, key)
def parse_conf(conf_fd): """Parse configuration file""" config = RawConfigParser() config.readfp(conf_fd) try: settings = { 'host_ip': config.get('main', 'host_ip'), 'runtime': config.getint('main', 'runtime'), 'timeout': config.getint('main', 'timeout'), 'use_sudo': config.getboolean('main', 'use_sudo'), 'rekall': config.get('main', 'rekall'), 'xml_conf': config.get('main', 'xml_conf'), 'vol_bin': config.get('main', 'vol_bin'), 'vol_prof': config.get('main', 'vol_prof'), } except (NoOptionError, ValueError) as e: log.error('Configuration is missing parameters. See example.conf.') sys.exit(1) errors = False for filepath in ['rekall', 'xml_conf']: if not os.path.isfile(settings[filepath]): log.error('Not a file: ' + str(settings[filepath])) errors = True if errors: log.error('Config file contains errors') sys.exit(1) return settings
def _readConfig(cls, filename): ''' Read the configuration file and return a pythonic configuration dict. ''' confParser = RawConfigParser(defaults={ # these keys can be commented out in the config file, # warning: the values are converted to strings 'user': None, 'pathRegexFilter': '', 'filenameRegexFilter': '', 'subPath': '', 'includes': '', 'macros': '', 'languages': '', 'metrics': '', 'settings': '', 'aggregateIssueLinks': '', 'shortBlockLines': 4} ) parsedFiles = confParser.read(filename) if not parsedFiles: msg = "Configuration file {} could not be read.".format(filename) raise Exception(msg) conf = { 'sina': {}, 'neteasy': {}, 'hanjie': {}, 'matching': {}, } # TODO: The 'configfie' entry is unused conf['consoleLog'] = confParser.getboolean('global', 'consoleLog') conf['debugMode'] = confParser.getboolean('global', 'debugMode') conf['encoding'] = confParser.get('global', 'encoding') conf['http_proxy'] = confParser.get('global', 'http_proxy') conf['configfile'] = os.path.abspath(filename) conf['basePath'] = os.path.abspath(convertOsPath(confParser.get('global', 'basePath'))) if confParser.has_section('sina'): conf['sina']['url'] = confParser.get('sina', 'url') conf['sina']['user'] = confParser.get('sina','user') conf['sina']['password'] = confParser.get('sina','password') if confParser.has_section('netease'): conf['netease']['url'] = confParser.get('netease', 'url') conf['netease']['user'] = confParser.get('netease','user') conf['netease']['password'] = confParser.get('netease','password') _convertDictUnicode(conf) return conf
class SncConfig(object): def __init__(self): self.config = RawConfigParser(allow_no_value=False) try: if ENVB_PATH in os.environ: self.config_file_path = os.environ[ ENVB_PATH] + os.sep + ENVBUILDER_CONF if len(str( self.config_file_path).strip()) > len(ENVBUILDER_CONF): self.config.read(self.config_file_path) else: self.config.read(ENVBUILDER_CONF) else: self.config.read(ENVBUILDER_CONF) os.environ[ENVB_PATH] = os.getcwd() except: ColorPrint.err("Config file {0} not found".format(ENVBUILDER_CONF)) exit(1) def getstring(self, section, param_name): try: return self.config.get(section, param_name) except: ColorPrint.err( "Config file {0} or section not found".format(ENVBUILDER_CONF)) exit(1) def getboolean(self, section, param_name): try: return self.config.getboolean(section, param_name) except: ColorPrint.err( "Config file {0} or section not found".format(ENVBUILDER_CONF)) exit(1) def getint(self, section, param_name): try: return self.config.getint(section, param_name) except: ColorPrint.err( "Config file {0} or section not found".format(ENVBUILDER_CONF)) exit(1) def getlist(self, section, param_name): try: cfg_list = self.config.get(section, param_name) return cfg_list.split(",") except: ColorPrint.err( "Config file {0} or section not found".format(ENVBUILDER_CONF)) exit(1) def getsection(self, section_name): try: return self.config.items(section_name) except: ColorPrint.err( "Config file {0} or section not found".format(ENVBUILDER_CONF)) exit(1)
def getboolean(self, section, option, *args): if len(args) > 0: try: return RawConfigParser.getboolean(self, section, option) except (NoSectionError, NoOptionError): return args[0] else: return RawConfigParser.get(self, section, option)
def __init__(self, config_file, *args, **kwargs): """ Класс настроек ЕСИА на основе конфигурационного файла :param str config_file: путь к конфигурационному ini-файлу :raises ConfigFileError: если указан неверный путь или файл недоступен для чтения :raises ConfigParser.*: при ошибках в формате файла или параметра """ if os.path.isfile(config_file) and os.access(config_file, os.R_OK): conf = RawConfigParser() conf.read(config_file) base_dir = os.path.dirname(config_file) kwargs = { 'esia_client_id': conf.get('esia', 'CLIENT_ID'), 'redirect_uri': conf.get('esia', 'REDIRECT_URI'), 'esia_service_url': conf.get('esia', 'SERVICE_URL'), 'esia_scope': conf.get('esia', 'SCOPE'), 'crypto_backend': conf.get('esia', 'CRYPTO_BACKEND'), 'certificate_file': None, 'private_key_file': None, 'csp_cert_thumbprint': None, 'csp_container_pwd': None, 'ssl_verify': True } # Openssl, M2Crypto params if conf.has_option('esia', 'CERT_FILE') and \ conf.has_option('esia', 'PRIV_KEY_FILE'): cert_f = conf.get('esia', 'CERT_FILE') pkey_f = conf.get('esia', 'PRIV_KEY_FILE') kwargs['certificate_file'] = base_dir + '/' + cert_f kwargs['private_key_file'] = base_dir + '/' + pkey_f # CryptoPro CSP params if conf.has_option('esia', 'CSP_CERT_THUMBPRINT'): kwargs['csp_cert_thumbprint'] = conf.get( 'esia', 'CSP_CERT_THUMBPRINT') kwargs['csp_container_pwd'] = conf.get('esia', 'CSP_CONTAINER_PWD') if conf.has_option('esia', 'JWT_CHECK_KEY'): token_check_key = conf.get('esia', 'JWT_CHECK_KEY') kwargs['esia_token_check_key'] = \ base_dir + '/' + token_check_key if conf.has_option('esia', 'LOGOUT_REDIRECT_URI'): redir = conf.get('esia', 'LOGOUT_REDIRECT_URI') kwargs['logout_redirect_uri'] = redir if conf.has_option('esia', 'SSL_VERIFY'): ssl_verify = conf.getboolean('esia', 'SSL_VERIFY') kwargs['ssl_verify'] = ssl_verify super(EsiaConfig, self).__init__(*args, **kwargs) else: raise ConfigFileError("Config file not exists or not readable!")
def read_config(filename, section='kleenex'): """ This looks for [kleenex] in ``filename`` such as the following: [kleenex] db = sqlite:///coverage.db parent = origin/master discover = true report = true report_output = - record = true skip_missing = true max_distance = 4 test_missing = true max_revisions = 100 """ config = RawConfigParser({ 'db': 'sqlite:///coverage.db', 'parent': 'origin/master', 'discover': 'false', 'report': 'true', 'report_output': '-', 'record': 'false', 'skip_missing': 'true', 'max_distance': '4', 'test_missing': 'true', 'max_revisions': '100', }, dict_type=Config) config.read(filename) if not config.has_section(section): return config.defaults() return Config({ 'db': config.get(section, 'db'), 'parent': config.get(section, 'parent'), 'discover': config.getboolean(section, 'discover'), 'report': config.getboolean(section, 'report'), 'report_output': config.get(section, 'report_output'), 'record': config.getboolean(section, 'record'), 'skip_missing': config.getboolean(section, 'skip_missing'), 'max_distance': config.getint(section, 'max_distance'), 'test_missing': config.getboolean(section, 'test_missing'), 'max_revisions': config.getint(section, 'max_revisions'), })
def getboolean(self, section, option, default): value = default try: if RawConfigParser.has_section(self, section): if RawConfigParser.has_option(self, section, option): value = RawConfigParser.getboolean(self, section, option) except: value = default return value
class Config(object): """ Manage configuration - a simple wrapper around RawConfigParser. Upon initialization, the loaded file is updated with the default values. config.save() will save the current state. """ def __init__(self): self.filename = get_config_fn() try: self.parser = RawConfigParser(dict_type=OrderedDict) except TypeError: # Python versions < 2.6 don't support dict_type self.parser = RawConfigParser() f = StringIO(default_config) self.parser.readfp(f) self.parser.read(self.filename) self.save() def get(self, key, section='DreamPie'): return self.parser.get(section, key) def get_bool(self, key, section='DreamPie'): return self.parser.getboolean(section, key) def get_int(self, key, section='DreamPie'): return self.parser.getint(section, key) def set(self, key, value, section='DreamPie'): self.parser.set(section, key, value) def set_bool(self, key, value, section='DreamPie'): value_str = 'True' if value else 'False' self.set(key, value_str, section) def set_int(self, key, value, section='DreamPie'): if value != int(value): raise ValueError("Expected an int, got %r" % value) self.set(key, '%d' % value, section) def sections(self): return self.parser.sections() def has_section(self, section): return self.parser.has_section(section) def add_section(self, section): return self.parser.add_section(section) def remove_section(self, section): return self.parser.remove_section(section) def save(self): f = open(self.filename, 'w') self.parser.write(f) f.close()
def settingsvar(): testconfig() parser = RawConfigParser() results = parser.read("config.ini") sections = parser.sections() settings = [] if parser.has_option(sections[2], "autoupdate"): settings.append(parser.getboolean(sections[2], "autoupdate")) return settings
def load_config(self, environ): """Load configuration options Options are read from a config file. Backwards compatibility: - if ConfigFile is not set, opts are loaded from http config - if ConfigFile is set, then the http config must not provide Koji options - In a future version we will load the default hub config regardless - all PythonOptions (except koji.web.ConfigFile) are now deprecated and support for them will disappear in a future version of Koji """ modpy_opts = environ.get('modpy.opts', {}) if 'modpy.opts' in environ: cf = modpy_opts.get('koji.web.ConfigFile', None) # to aid in the transition from PythonOptions to web.conf, we do # not check the config file by default, it must be configured else: cf = environ.get('koji.web.ConfigFile', '/etc/kojiweb/web.conf') if cf: if not os.path.isfile(cf): raise koji.GenericError, "Configuration missing: %s" % cf config = RawConfigParser() config.read(cf) else: #can only happen under mod_python self.logger.warn('Warning: configuring Koji via PythonOptions is deprecated. Use web.conf') opts = {} for name, dtype, default in self.cfgmap: if cf: key = ('web', name) if config.has_option(*key): if dtype == 'integer': opts[name] = config.getint(*key) elif dtype == 'boolean': opts[name] = config.getboolean(*key) else: opts[name] = config.get(*key) else: opts[name] = default else: if modpy_opts.get(name, None) is not None: if dtype == 'integer': opts[name] = int(modpy_opts.get(name)) elif dtype == 'boolean': opts[name] = modpy_opts.get(name).lower() in ('yes', 'on', 'true', '1') else: opts[name] = modpy_opts.get(name) else: opts[name] = default if 'modpy.conf' in environ: debug = environ['modpy.conf'].get('PythonDebug', '0').lower() opts['PythonDebug'] = (debug in ['yes', 'on', 'true', '1']) opts['Secret'] = koji.util.HiddenValue(opts['Secret']) self.options = opts return opts
def getboolean(self, section, option): try: return RawConfigParser.getboolean(self, section, option) except AttributeError: # XXX: # For some reason, getboolean likes to die sometimes. # Until I figure it out, this will act as a band-aid # to prevent the error from causing Lookit to not work value = self.get(section, option) return value == "True"
def load_config(path): c = RawConfigParser() c.read(path) d = {} d.update(c.items('servo')) d['pulse_port'] = c.getint('servo', 'pulse_port') d['pulse_ssl'] = c.getboolean('servo', 'pulse_ssl') return d
def getboolean(self, section, option, default=None): # default should be a string. # _boolean_states = { # '1': True, 'yes': True, 'true': True, 'on': True, # '0': False, 'no': False, 'false': False, 'off': False} val = default try: val = RawConfigParser.getboolean(self, section, option) except NoOptionError, e: # NOTE: None cannot be the default. if default is None: raise
class preferences: config = [] parse = None lcdconnection = None def __init__(self): if (DEBUG == True): self.writetolog("Init Prefs") self.loadprefs(None, None, None) if (DEBUG == True): self.writetolog("Done") def loadprefs(self, word, word_eol, userdata): if (self.lcdconnection != None): self.lcdconnection.offlights(None, None, None) prefs = open(module_dir + "config.txt") self.parse = RawConfigParser() self.parse.readfp(prefs) prefs.close() print "Prefrences Loaded" def value(self,option): if (DEBUG == True): self.writetolog("Prefs -> Value") return self.parse.get("config",option) if (DEBUG == True): self.writetolog("Done") def floatvalue(self,option): if (DEBUG == True): self.writetolog("Prefs -> FloatValue") return self.parse.getfloat("config",option) if (DEBUG == True): self.writetolog("Done") def intvalue(self,option): if (DEBUG == True): self.writetolog("Prefs -> IntValue") return self.parse.getint("config",option) if (DEBUG == True): self.writetolog("Done") def boolvalue(self,option): if (DEBUG == True): self.writetolog("Prefs -> IntValue") return self.parse.getboolean("config",option) if (DEBUG == True): self.writetolog("Done") def writetolog(self, message): debuglog = open(module_dir + "log.txt","a") debuglog.write(message + "\n") debuglog.close
class Settings(): _changed = True def __init__(self): self._settings = RawConfigParser() self._funcs = (self._getGeneric, self._getInt, self._getFloat, self._getStruct, self._getBool) def getValue(self, section, option, select): """Returns value from settings file - 0: string/raw value, 1: integer, 2: float, 3: data structure, 4: boolean""" if Settings._changed: self._fileOpen() Settings._changed = False return self._funcs[select](section,option) def changeValue(self, section, option): self._settings.set(section, str(option)) with open('cellular.ini', 'wb') as fp: self._settings.write(fp) Settings._changed = True def _throwError(self, message, title = 'Fatal Error'): Tkinter.Tk().withdraw() tkMessageBox.showerror(str(title),str(message)) exit def _fileOpen(self): try: fp = open(configFile) except IOError: self._throwError('config file not found.\nThe program will now terminate.') self._settings.readfp(fp) def _getGeneric(self, section, option): value = self._settings.get(section, option) return value def _getInt(self, section, option): try: value = self._settings.getint(section,option) except ValueError: self._throwError('Expected integer, recieved something else at ['+section+'],'+option+'.\nThe program will now terminate.') return value def _getFloat(self, section, option): try: value = self._settings.getfloat(section,option) except ValueError: self._throwError('Expected float, recieved something else at ['+section+'],'+option+'.\nThe program will now terminate.') return value def _getStruct(self, section, option): try: value = decode(self._settings.get(section,option)) except ValueError or SyntaxError: self._throwError('Expected data structure, recieved something else at ['+section+'], '+option+'.\nTheProgram will now terminate.') return value def _getBool(self, section, option): try: value = self._settings.getboolean(section,option) except ValueError: self._throwError('Expected boolean, recieved something else at ['+section+'], '+option+'.\nThe program will now terminate.') return value
def get_option_autostart(options, section): """Retrieve auto_start option from a section """ #print self.data['conf_file'] if 'conf_file' in options and options['conf_file'] is not None: config = RawConfigParser() config.read([options['conf_file']]) try: return config.getboolean(section, 'auto_start') except ConfigParser.NoOptionError: return False except ConfigParser.NoSectionError: return False return False
class Config: SECTION = "mail2Shell" STRING_KEYS=["mailServer", "smtpServer", "username", "password", "magicKey", "trustedSender", "msgFormat", "logFileName", \ "workDir", "path2Shell", "keys", "gpgBinary", "hashStore"] INT_KEYS = ["maxFilesize", "keepRunning", "hashBufferSize"] BOOLEAN_KEYS = [ "enableLogging", "enableGPG", "allowOnlyGPG", "verifySignature" ] DEFAULTS = { "enableLogging": "yes", "logFileName": "/tmp/mail2shell.log", "maxFilesize": 1000000, "msgFormat": "%(asctime)s, %(levelname)s, %(module)s, %(lineno)d, %(message)s", "path2Shell": "/bin/sh", "keepRunning": 0, "enableGPG": "False", "keys": "./keys", "allowOnlyGPG": "False", "verifySignature": "False", "gpgBinary": "/usr/local/bin/gpg", "hashBufferSize": 1024, "hashStore": "./hashStore.json" } def __init__(self, cfgFile): self.cfg = RawConfigParser(Config.DEFAULTS) _ = self.cfg.read(cfgFile) def hasKey(self, dct, key): k = key.upper() for d in dct: if d.upper() == k: return d return None def __getattr__(self, name): key = self.hasKey(Config.STRING_KEYS, name) if not key is None: return self.cfg.get(Config.SECTION, key) key = self.hasKey(Config.INT_KEYS, name) if not key is None: return self.cfg.getint(Config.SECTION, key) key = self.hasKey(Config.BOOLEAN_KEYS, name) if not key is None: return self.cfg.getboolean(Config.SECTION, key) return None
def override_from_config(self, filename): config = RawConfigParser() if IS_PY3: config.read_file(open(filename)) else: config.readfp(open(filename)) # Common options if config.has_section('bumpr'): for option in config.options('bumpr'): if option in ('tag', 'commit'): self[option] = config.getboolean('bumpr', option) elif option == 'files': # pylint: disable=W0201 self.files = [name.strip() for name in config.get('bumpr', 'files').split('\n') if name.strip()] # pylint: enable=W0201 else: self[option] = config.get('bumpr', option) # Bump and next section for section in 'bump', 'prepare': for option in 'message', 'suffix': if config.has_option(section, option): self[section][option] = config.get(section, option) if config.has_option(section, 'unsuffix'): self[section]['unsuffix'] = config.getboolean(section, 'unsuffix') if config.has_option(section, 'part'): self[section]['part'] = PARTS[config.get(section, 'part').lower()] for hook in HOOKS: if config.has_section(hook.key): if not self.get(hook.key, False): self[hook.key] = hook.defaults self[hook.key].update(config.items(hook.key)) else: self[hook.key] = False
def get_categories(): categories = {} cat_parser = RawConfigParser() if os.path.isfile(os.path.join("data", "categories.ini")): cat = open(os.path.join("data", "categories.ini")) else: cat = open( os.path.join(control.controller.data_system_path, "categories.ini")) cat_parser.readfp(cat) for section in cat_parser.sections(): name = cat_parser.get(section, "name") icon = cat_parser.get(section, "icon") #tags = cat_parser.get(section, "contains") showboth = cat_parser.getboolean(section, "showboth") categories[section] = [icon, _(name), showboth] return categories
def __init__(self, cfg_file, pwd_file): self._cfg_file = cfg_file self._pwd_file = pwd_file cfg = {} config = RawConfigParser() config.read(cfg_file) for section in config.sections(): cfg[section] = dict(config.items(section)) # Split username and domain since it's used on incoming mail # regex (EMAIL_REGEX) cfg['email']['username'], cfg['email']['domain'] = cfg['email']['address'].split('@') # IMAP/SMTP usernames are optional for section in 'imap', 'smtp': if (not 'username' in cfg[section]) or (cfg[section]['username'] == ''): cfg[section]['username'] = cfg['email']['address'] # Coerce boolean values bln = [('main', 'save_passwords'), ('main', 'debug'), ('imap', 'ssl'), ('smtp', 'ssl'), ('smtp', 'tls')] for section, setting in bln: cfg[section][setting] = config.getboolean(section, setting) # Read passwords config = RawConfigParser() config.read(pwd_file) if config.has_section('passwords'): for section, password in config.items('passwords'): cfg[section]['password'] = password if cfg['main']['debug']: cfg['DEBUG'] = True else: cfg['DEBUG'] = False del(cfg['main']['debug']) self._config = cfg
def load_config(self, environ): """Load configuration options Options are read from a config file. Backwards compatibility: - if ConfigFile is not set, opts are loaded from http config - if ConfigFile is set, then the http config must not provide Koji options - In a future version we will load the default hub config regardless - all PythonOptions (except koji.web.ConfigFile) are now deprecated and support for them will disappear in a future version of Koji """ cf = environ.get('koji.web.ConfigFile', '/etc/kojiweb/web.conf') cfdir = environ.get('koji.web.ConfigDir', '/etc/kojiweb/web.conf.d') if cfdir: configs = koji.config_directory_contents(cfdir) else: configs = [] if cf and os.path.isfile(cf): configs.append(cf) if configs: config = RawConfigParser() config.read(configs) else: raise koji.GenericError("Configuration missing") opts = {} for name, dtype, default in self.cfgmap: key = ('web', name) if config and config.has_option(*key): if dtype == 'integer': opts[name] = config.getint(*key) elif dtype == 'boolean': opts[name] = config.getboolean(*key) elif dtype == 'list': opts[name] = [ x.strip() for x in config.get(*key).split(',') ] else: opts[name] = config.get(*key) else: opts[name] = default opts['Secret'] = koji.util.HiddenValue(opts['Secret']) self.options = opts return opts
def read_ini(self, filename): if not filename or not os.path.isfile(filename): return parser = RawConfigParser() parser.read(filename) for section in parser.sections(): for option in parser.options(section): value = None if section in self.defaults and option in self.defaults[section]: t = type(self.defaults[section][option]) if t is str: value = parser.get(section, option) elif t is int: value = parser.getint(section, option) elif t is float: value = parser.getfloat(section, option) elif t is bool: value = parser.getboolean(section, option) else: value = parser.get(section, option) self.set(section, option, value)
def __init__(self, config_path): config = RawConfigParser() config.read(config_path) protocol = mqtt.MQTTv31 if (config.has_option('mqtt', 'use311') and config.getboolean('mqtt', 'use311')): kLog.debug('311') protocol = mqtt.MQTTv311 self.name = config.get('mqtt', 'client_name') client = mqtt.Client(client_id=self.name, clean_session=True, protocol=protocol) client.username_pw_set(config.get('mqtt', 'username'), config.get('mqtt', 'password')) client.tls_set(config.get('mqtt', 'ca_cert')) if config.get('mqtt','hostname') in ('localhost', '127.0.0.1', '::1'): client.tls_insecure_set(True) self.config = config self.client = client
def _get_autoreload_programs(self, cfg_file): """Get the set of programs to auto-reload when code changes. Such programs will have autoreload=true in their config section. This can be affected by config file sections or command-line arguments, so we need to read it out of the merged config. """ cfg = RawConfigParser() cfg.readfp(cfg_file) reload_progs = [] for section in cfg.sections(): if section.startswith("program:"): try: if cfg.getboolean(section, "autoreload"): reload_progs.append(section.split(":", 1)[1]) except NoOptionError: pass return reload_progs
def _get_autoreload_programs(self,cfg_file): """Get the set of programs to auto-reload when code changes. Such programs will have autoreload=true in their config section. This can be affected by config file sections or command-line arguments, so we need to read it out of the merged config. """ cfg = RawConfigParser() cfg.readfp(cfg_file) reload_progs = [] for section in cfg.sections(): if section.startswith("program:"): try: if cfg.getboolean(section,"autoreload"): reload_progs.append(section.split(":",1)[1]) except NoOptionError: pass return reload_progs
def __init__(self, filepath): config = RawConfigParser() config.read(filepath) self.fp = filepath self.name = config.get('Task', 'name') self.description = config.get('Task', 'description') self.basic_url = config.get('Task', 'Basic_url') self.area = map(float, config.get('Task', 'Area').split(',')) self.max_z = config.getint('Task', 'maxZoom') self.min_z = config.getint('Task', 'minZoom') self.debug = config.getboolean('Debug', 'debugmode') self.debugTryTimes = config.getint('Debug', 'TryTimes') self.MAX_Threads = config.getint('Run', 'MAX_Threads') self.MAX_QUEUE = config.getint('Run', 'MAX_QUEUE') self.image_floder = config.get('File', 'ImageFloder') self.min_x = int(lonToTileX(self.area[0], self.min_z)) self.min_y = int(latToTileY(self.area[3], self.min_z)) self.max_x = int(lonToTileX(self.area[1], self.min_z)) self.max_y = int(latToTileY(self.area[2], self.min_z)) self.x = config.getint('Task-State', 'currentX') self.y = config.getint('Task-State', 'currentY') # Initialize if self.x == 0 and self.y == 0: self.x = self.min_x self.y = self.min_y # Breakpoint Resume elif self.x-self.min_x+(self.y-self.min_y)*(self.max_x-self.min_x)>3*self.MAX_QUEUE: if self.x - self.min_x > 3*self.MAX_QUEUE: self.x = self.x - 3*self.MAX_QUEUE else: self.x = self.max_x - (3*self.MAX_QUEUE - (self.x - self.min_x)) self.y = self.y - 1 else: self.x = self.min_x self.y = self.min_y print self.x, self.max_x print self.y, self.max_y print (self.max_x-self.x)*(self.max_y-self.y)
def get_options(args, opt_parser): config = RawConfigParser() parent = tail = os.path.abspath(os.path.commonprefix(args)) config_found = False while tail and not config_found: log.info(tail) for fn in PROJECT_CONFIG: full_path = os.path.join(parent, fn) if config.read(full_path): log.info('local configuration: in %s.', full_path) config_found = True break parent, tail = os.path.split(parent) new_options = None if config.has_section('pep257'): option_list = dict([(o.dest, o.type or o.action) for o in opt_parser.option_list]) # First, read the default values new_options, _ = opt_parser.parse_args([]) # Second, parse the configuration pep257_section = 'pep257' for opt in config.options(pep257_section): if opt.replace('_', '-') not in opt_parser.config_options: log.warning("Unknown option '{}' ignored".format(opt)) continue normalized_opt = opt.replace('-', '_') opt_type = option_list[normalized_opt] if opt_type in ('int', 'count'): value = config.getint(pep257_section, opt) elif opt_type == 'string': value = config.get(pep257_section, opt) else: assert opt_type in ('store_true', 'store_false') value = config.getboolean(pep257_section, opt) setattr(new_options, normalized_opt, value) # Third, overwrite with the command-line options options, _ = opt_parser.parse_args(values=new_options) log.debug("options: %s", options) return options
def parse_materials(): """Parses the materials.ini file.""" global MATERIALS raws = RawConfigParser() raws.read('materials.ini') for section in raws.sections(): MATERIALS[section] = {} MATERIALS[section]['name'] = section MATERIALS[section]['transparent'] = raws.getboolean(section, 'transparent') MATERIALS[section]['priority'] = raws.getint(section, 'priority') #seperates the color values and converts them into the libtcod standard color_tuple = re.split( r'\D+', raws.get(section, 'color floor') ) color_tuple = map(int, color_tuple) MATERIALS[section]['floor_color'] = libtcod.Color( *color_tuple ) color_tuple = re.split( r'\D+', raws.get(section, 'color wall') ) color_tuple = map(int, color_tuple) MATERIALS[section]['wall_color'] = libtcod.Color( *color_tuple )
def ReadSingleConfigValue(file, section, type, entry, default, bounds=None): try: config = RawConfigParser() # config parser reads from current directory, when running form a cron tab this is # not defined so we specify the full path config.read(file) if not config.has_option(section, entry): return default if type.lower() == "string" or type == "password": return config.get(section, entry) elif type.lower() == "boolean": return config.getboolean(section, entry) elif type.lower() == "int": return config.getint(section, entry) elif type.lower() == 'list': Value = config.get(section, entry) if bounds != None: DefaultList = bounds.split(",") if Value.lower() in (name.lower() for name in DefaultList): return Value else: LogError( "Error Reading Config File (value not in list): %s : %s" % (entry, Value)) return default else: LogError( "Error Reading Config File (bounds not provided): %s : %s" % (entry, Value)) return default else: LogError("Error Reading Config File (unknown type): %s : %s" % (entry, type)) return default except Exception as e1: LogError("Error Reading Config File (ReadSingleConfigValue): " + str(e1)) return default
def __init__(self, conffile_path, conf_sec): super(APIFramework, self).__init__() conf = RawConfigParser(CONF_DEFAULTS) conf.read(conffile_path) self.listen_port = conf.getint(conf_sec, 'listen_port') #mysql self.db_host = conf.get(conf_sec, 'db_host') self.db_port = conf.getint(conf_sec, 'db_port') self.db_name = conf.get(conf_sec, 'db_name') self.db_user = conf.get(conf_sec, 'db_user') self.db_password = conf.get(conf_sec, 'db_password') db_max_connection = conf.getint(conf_sec, 'db_max_connections') db_stale_timeout = conf.getint(conf_sec, 'db_stale_timeout') #redis self.redis_server = conf.get(conf_sec, 'redis_server').split(',') self.redis_port = conf.getint(conf_sec, 'redis_port') self.redis_password = conf.get(conf_sec, 'redis_password') #debug self.debug = conf.getboolean(conf_sec, 'debug') #db/redis init self.db = db.get_MysqlConnection(self.db_host, self.db_port, self.db_user, self.db_password, self.db_name, db_max_connection, db_stale_timeout) self.redis_conn = db.get_RedisConnection(self.redis_server, self.redis_port, self.redis_password) #errors self.error_handler[404] = self.NotFoundError self.add_hook('before_request', self.before_request) self.add_hook('after_request', self.after_request) #install plugins self.install(ParseArgs()) #register handler self.loadHandlers(True) #install self handler if self.debug: Bottle.route(self, '/reloadhandlers', ['GET', 'POST'], self.loadHandlers) else: Bottle.route(self, '/reloadhandlers', 'POST', self.loadHandlers)
def read_config(): # config file should be placed in same directory as the script config_file_path = os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), "locopod.config") parser = RawConfigParser() try: parser.readfp(open(config_file_path)) except IOError: return for name, value in parser.items("config"): name = name.upper() if name in GLOBAL_VARS: default = globals()[name] if type(default) == type(1): value = parser.getint("config", name) elif type(default) == type(1.0): value = parser.getfloat("config", name) elif type(default) == type(True): value = parser.getboolean("config", name) globals()[name] = value
def ReadSingleConfigValue(file, section, type, entry, default): try: config = RawConfigParser() # config parser reads from current directory, when running form a cron tab this is # not defined so we specify the full path config.read(file) if not config.has_option(section, entry): return default if type == "string": return config.get(section, entry) elif type == "boolean": return config.getboolean(section, entry) elif type == "int": return config.getint(section, entry) else: return default except Exception as e1: log.error("Error Reading Config File (ReadSingleConfigValue): " + str(e1)) return default
def init_local_facility(conf): config = RawConfigParser() config.readfp(open(conf['__file__'], 'r')) global ENCRYPTION_UTILITY enabled = False if config.has_option('encryptingstorage:encryption', 'enabled'): enabled = config.getboolean('encryptingstorage:encryption', 'enabled') if enabled: kek_path = config.get('encryptingstorage:encryption', 'kek-path') if config.has_option('encryptingstorage:encryption', 'kmi-server'): kmf = facility.LocalKeyManagementFacility( config.get('encryptingstorage:encryption', 'kmi-server')) else: kmf = facility.KeyManagementFacility( config.get('encryptingstorage:encryption', 'dek-storage-path')) if kek_path.startswith('/'): path = kek_path else: path = os.path.join(conf['here'], kek_path) ENCRYPTION_UTILITY = EncryptionUtility(path, kmf) # encryptingstorage specific: # just don't provide utilities, who knows what will be defined # by the main app # provideUtility(ENCRYPTION_UTILITY, IKeyHolder) # provideUtility(kmf) else: ENCRYPTION_UTILITY = TrivialEncryptionUtility()
class MyConfig(MyLog): #---------------------MyConfig::__init__------------------------------------ def __init__(self, filename=None, section=None, log=None): super(MyLog, self).__init__() self.log = log self.FileName = filename self.Section = section self.CriticalLock = threading.Lock( ) # Critical Lock (writing conf file) self.InitComplete = False self.LogLocation = "/var/log/" self.Latitude = 51.4769 self.Longitude = 0 self.SendRepeat = 1 self.UseHttps = False self.HTTPPort = 80 self.HTTPSPort = 443 self.RTS_Address = "0x279620" self.Shutters = {} self.ShuttersByName = {} self.Schedule = {} self.Password = "" try: self.config = RawConfigParser() self.config.read(self.FileName) if self.Section == None: SectionList = self.GetSections() if len(SectionList): self.Section = SectionList[0] except Exception as e1: self.LogErrorLine("Error in MyConfig:init: " + str(e1)) return self.InitComplete = True # -------------------- MyConfig::LoadConfig----------------------------------- def LoadConfig(self): parameters = { 'LogLocation': str, 'Latitude': float, 'Longitude': float, 'SendRepeat': int, 'UseHttps': bool, 'HTTPPort': int, 'HTTPSPort': int, 'TXGPIO': int, 'RTS_Address': str, "Password": str } self.SetSection("General") for key, type in parameters.items(): try: if self.HasOption(key): setattr(self, key, self.ReadValue(key, return_type=type)) except Exception as e1: self.LogErrorLine( "Missing config file or config file entries in Section General for key " + key + ": " + str(e1)) return False parameters = { 'MQTT_Server': str, 'MQTT_Port': int, 'MQTT_User': str, 'MQTT_Password': str, 'EnableDiscovery': bool } self.SetSection("MQTT") for key, type in parameters.items(): try: if self.HasOption(key): setattr(self, key, self.ReadValue(key, return_type=type)) except Exception as e1: self.LogErrorLine( "Missing config file or config file entries in Section General for key " + key + ": " + str(e1)) return False self.SetSection("Shutters") shutters = self.GetList() for key, value in shutters: try: param1 = value.split(",") if param1[1].strip().lower() == 'true': if (len(param1) < 3): param1.append("10") elif (param1[2].strip() == "") or (int( param1[2]) <= 0) or (int(param1[2]) >= 100): param1[2] = "10" param2 = int( self.ReadValue(key, section="ShutterRollingCodes", return_type=int)) self.Shutters[key] = { 'name': param1[0], 'code': param2, 'duration': int(param1[2]) } self.ShuttersByName[param1[0]] = key except Exception as e1: self.LogErrorLine( "Missing config file or config file entries in Section Shutters for key " + key + ": " + str(e1)) return False self.SetSection("Scheduler") schedules = self.GetList() for key, value in schedules: try: param = value.split(",") if param[0].strip().lower() in ('active', 'paused'): self.Schedule[key] = { 'active': param[0], 'repeatType': param[1], 'repeatValue': param[2], 'timeType': param[3], 'timeValue': param[4], 'shutterAction': param[5], 'shutterIds': param[6] } except Exception as e1: self.LogErrorLine( "Missing config file or config file entries in Section Scheduler for key " + key + ": " + str(e1)) return False return True #---------------------MyConfig::setLocation--------------------------------- def setLocation(self, lat, lng): self.WriteValue("Latitude", lat, section="General") self.WriteValue("Longitude", lng, section="General") self.Latitude = lat self.Longitude = lng #---------------------MyConfig::setCode--------------------------------- def setCode(self, shutterId, code): self.WriteValue(shutterId, str(code), section="ShutterRollingCodes") self.Shutters[shutterId]['code'] = code #---------------------MyConfig::HasOption----------------------------------- def HasOption(self, Entry): return self.config.has_option(self.Section, Entry) #---------------------MyConfig::GetList------------------------------------- def GetList(self): return self.config.items(self.Section) #---------------------MyConfig::GetSections--------------------------------- def GetSections(self): return self.config.sections() #---------------------MyConfig::SetSection---------------------------------- def SetSection(self, section): # if not (isinstance(section, str) or isinstance(section, unicode)) or not len(section): if not len(section): self.LogError("Error in MyConfig:ReadValue: invalid section: " + str(section)) return False self.Section = section return True #---------------------MyConfig::ReadValue----------------------------------- def ReadValue(self, Entry, return_type=str, default=None, section=None, NoLog=False): try: if section != None: self.SetSection(section) if self.config.has_option(self.Section, Entry): if return_type == str: return self.config.get(self.Section, Entry) elif return_type == bool: return self.config.getboolean(self.Section, Entry) elif return_type == float: return self.config.getfloat(self.Section, Entry) elif return_type == int: return self.config.getint(self.Section, Entry) else: self.LogErrorLine( "Error in MyConfig:ReadValue: invalid type:" + str(return_type)) return default else: return default except Exception as e1: if not NoLog: self.LogErrorLine("Error in MyConfig:ReadValue: " + Entry + ": " + str(e1)) return default #---------------------MyConfig::WriteSection-------------------------------- def WriteSection(self, SectionName): SectionList = self.GetSections() if SectionName in SectionList: self.LogError("Error in WriteSection: Section already exist.") return True try: with self.CriticalLock: with open(self.FileName, "a") as ConfigFile: ConfigFile.write("[" + SectionName + "]") ConfigFile.flush() ConfigFile.close() # update the read data that is cached self.config.read(self.FileName) return True except Exception as e1: self.LogErrorLine("Error in WriteSection: " + str(e1)) return False #---------------------MyConfig::WriteValue---------------------------------- def WriteValue(self, Entry, Value, remove=False, section=None): if section != None: self.SetSection(section) SectionFound = False try: with self.CriticalLock: Found = False ConfigFile = open(self.FileName, 'r') FileList = ConfigFile.read().splitlines() ConfigFile.close() mySectionStart = -1 mySectionEnd = -1 myLine = -1 currentLastDataLine = -1 for i, line in enumerate(FileList): if self.LineIsSection(line) and self.Section.lower( ) == self.GetSectionName(line).lower(): mySectionStart = i elif mySectionStart >= 0 and mySectionEnd == -1 and len( line.strip().split('=')) >= 2 and ( line.strip().split('='))[0].strip() == Entry: myLine = i elif mySectionStart >= 0 and mySectionEnd == -1 and self.LineIsSection( line): mySectionEnd = currentLastDataLine if not line.isspace() and not len( line.strip()) == 0 and not line.strip()[0] == "#": currentLastDataLine = i if mySectionStart >= 0 and mySectionEnd == -1: mySectionEnd = currentLastDataLine self.LogDebug("CONFIG FILE WRITE ->> mySectionStart = " + str(mySectionStart) + ", mySectionEnd = " + str(mySectionEnd) + ", myLine = " + str(myLine)) if mySectionStart == -1: raise Exception("NOT ABLE TO FIND SECTION:" + self.Section) ConfigFile = open(self.FileName, 'w') for i, line in enumerate(FileList): if myLine >= 0 and myLine == i and not remove: # I found my line, now write new value ConfigFile.write(Entry + " = " + Value + "\n") elif myLine == -1 and mySectionEnd == i: # Here we have to insert the new record... ConfigFile.write(line + "\n") ConfigFile.write(Entry + " = " + Value + "\n") else: # Nothing special, just copy the previous line.... ConfigFile.write(line + "\n") ConfigFile.flush() ConfigFile.close() # update the read data that is cached self.config.read(self.FileName) return True except Exception as e1: self.LogError("Error in WriteValue: " + str(e1)) return False #---------------------MyConfig::GetSectionName------------------------------ def GetSectionName(self, Line): Line = Line.strip() if Line.startswith("[") and Line.endswith("]") and len(Line) >= 3: Line = Line.replace("[", "") Line = Line.replace("]", "") return Line return "" #---------------------MyConfig::LineIsSection------------------------------- def LineIsSection(self, Line): Line = Line.strip() if Line.startswith("[") and Line.endswith("]") and len(Line) >= 3: return True return False
def __init__(self, log, newinstall=False, simulation=False, simulationfile=None, message=None, feedback=None, ConfigFilePath=None): super(GeneratorController, self).__init__() self.log = log self.NewInstall = newinstall self.Simulation = simulation self.SimulationFile = simulationfile self.FeedbackPipe = feedback self.MessagePipe = message if ConfigFilePath == None: self.ConfigFilePath = "/etc/" else: self.ConfigFilePath = ConfigFilePath self.Address = None self.SerialPort = "/dev/serial0" self.BaudRate = 9600 self.InitComplete = False self.Registers = {} # dict for registers and values self.NotChanged = 0 # stats for registers self.Changed = 0 # stats for registers self.TotalChanged = 0.0 # ratio of changed ragisters self.EnableDebug = False # Used for enabeling debugging self.OutageLog = os.path.dirname( os.path.dirname(os.path.realpath(__file__))) + "/outage.txt" self.PowerLogMaxSize = 15 # 15 MB max size self.PowerLog = os.path.dirname( os.path.dirname(os.path.realpath(__file__))) + "/kwlog.txt" self.TileList = [] # Tile list for GUI if self.Simulation: self.LogLocation = "./" else: self.LogLocation = "/var/log/" self.DisableOutageCheck = False self.bDisplayUnknownSensors = False self.UtilityVoltsMin = 0 # Minimum reported utility voltage above threshold self.UtilityVoltsMax = 0 # Maximum reported utility voltage above pickup self.SystemInOutage = False # Flag to signal utility power is out self.TransferActive = False # Flag to signal transfer switch is allowing gen supply power self.SiteName = "Home" # The values "Unknown" are checked to validate conf file items are found self.FuelType = "Unknown" self.NominalFreq = "Unknown" self.NominalRPM = "Unknown" self.NominalKW = "Unknown" self.Model = "Unknown" self.CommAccessLock = threading.RLock( ) # lock to synchronize access to the protocol comms self.ProgramStartTime = datetime.datetime.now() # used for com metrics self.OutageStartTime = self.ProgramStartTime # if these two are the same, no outage has occured self.LastOutageDuration = self.OutageStartTime - self.OutageStartTime # Read conf entries common to all controllers ConfigSection = "GenMon" try: # read config file config = RawConfigParser() # config parser reads from current directory, when running form a cron tab this is # not defined so we specify the full path config.read(self.ConfigFilePath + 'genmon.conf') # getfloat() raises an exception if the value is not a float # getint() and getboolean() also do this for their respective types if config.has_option(ConfigSection, 'sitename'): self.SiteName = config.get(ConfigSection, 'sitename') if config.has_option(ConfigSection, 'port'): self.SerialPort = config.get(ConfigSection, 'port') if config.has_option(ConfigSection, 'loglocation'): self.LogLocation = config.get(ConfigSection, 'loglocation') # optional config parameters, by default the software will attempt to auto-detect the controller # this setting will override the auto detect if config.has_option(ConfigSection, 'disableoutagecheck'): self.DisableOutageCheck = config.getboolean( ConfigSection, 'disableoutagecheck') if config.has_option(ConfigSection, 'enabledebug'): self.EnableDebug = config.getboolean(ConfigSection, 'enabledebug') if config.has_option(ConfigSection, 'displayunknown'): self.bDisplayUnknownSensors = config.getboolean( ConfigSection, 'displayunknown') if config.has_option(ConfigSection, 'outagelog'): self.OutageLog = config.get(ConfigSection, 'outagelog') if config.has_option(ConfigSection, 'kwlog'): self.PowerLog = config.get(ConfigSection, 'kwlog') if config.has_option(ConfigSection, 'kwlogmax'): self.PowerLogMaxSize = config.getint(ConfigSection, 'kwlogmax') if config.has_option(ConfigSection, 'nominalfrequency'): self.NominalFreq = config.get(ConfigSection, 'nominalfrequency') if config.has_option(ConfigSection, 'nominalRPM'): self.NominalRPM = config.get(ConfigSection, 'nominalRPM') if config.has_option(ConfigSection, 'nominalKW'): self.NominalKW = config.get(ConfigSection, 'nominalKW') if config.has_option(ConfigSection, 'model'): self.Model = config.get(ConfigSection, 'model') if config.has_option(ConfigSection, 'fueltype'): self.FuelType = config.get(ConfigSection, 'fueltype') except Exception as e1: if not reload: self.FatalError( "Missing config file or config file entries: " + str(e1)) else: self.LogErrorLine("Error reloading config file" + str(e1))
"--emevoucher_chain", dest="emevoucher_chain", help="Certificate chain to include in EME voucher signatures") parser.add_option("-v", action="store_const", dest="loglevel", const=logging.DEBUG) options, args = parser.parse_args() if options.configfile: config = RawConfigParser() config.read(options.configfile) for option, value in config.items('signscript'): if option == "signcode_timestamp": value = config.getboolean('signscript', option) options.ensure_value(option, value) # Reset to default if this wasn't set in the config file if options.signcode_timestamp is None: options.signcode_timestamp = True logging.basicConfig(level=options.loglevel, format="%(asctime)s - %(message)s") if len(args) != 4: parser.error("Incorrect number of arguments") format_, inputfile, destfile, filename = args tmpfile = destfile + ".tmp"
BASE_DIR = os.path.dirname(os.path.dirname(__file__)) config = RawConfigParser() config.read(os.path.join(BASE_DIR, 'settings.ini')) ########## Версия сайта ##### CONF = 'dev' if os.environ.get('DEVELOP_MODE') else 'prod' # Доступные варианты: # prod # dev ############################# # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = '3*ht_i78=^ydrz-3hv75ub30i3ip^*v+iu4vjo%bd=cicw)egs' DEBUG = config.getboolean(CONF, 'DEBUG') TEMPLATE_DEBUG = DEBUG ALLOWED_HOSTS = ['*'] INTERNAL_IPS = ('127.0.0.1', ) # email setting EMAIL_USE_TLS = True EMAIL_HOST = 'smtp.gmail.com' EMAIL_PORT = 587 EMAIL_HOST_USER = '******' EMAIL_HOST_PASSWORD = '******' DEFAULT_FROM_EMAIL = '*****@*****.**'