def reset(): global bin_paths global config global configs_found bin_paths = {} config = ConfigParser.ConfigParser() configs_found = config.read(config_files) if not configs_found: print ('WARNING: pyTivo.conf does not exist.\n' + 'Assuming default values.') configs_found = config_files[-1:] for section in config.sections(): if section.startswith('_tivo_'): tsn = section[6:] if tsn.upper() not in ['SD', 'HD']: if config.has_option(section, 'name'): tivo_names[tsn] = config.get(section, 'name') else: tivo_names[tsn] = tsn if config.has_option(section, 'address'): tivos[tsn] = config.get(section, 'address') for section in ['Server', '_tivo_SD', '_tivo_HD']: if not config.has_section(section): config.add_section(section)
def parse_config(self, arguments=None): finalconfig = {} args = self.parser.parse_args(arguments) config = configparser.SafeConfigParser() try: with open(args.config) as fdconfig: config.readfp(fdconfig) except Exception as e: msg = "Ignoring configuration file '%s'" self.logger.warn(msg % (args.config)) for section in self.PARAMETERS.keys(): config.add_section(section) else: self.logger.info("Read configuration file '%s'" % args.config) for section in self.PARAMETERS.keys(): cfgsection = dict(config.items(section)) for var, required in self.PARAMETERS[section].iteritems(): try: # build env variables like IRONIC_URL envparameter = section.upper() + '_' + var.upper() cfgsection[var] = os.environ[envparameter] msg = "Reading env variable '%s'" % envparameter self.logger.debug(msg) except: pass if required and not var in cfgsection: msg = "Variable '%s.%s' not defined and it is required!" msg = msg % (section, var) self.logger.error(msg) raise ValueError(msg) finalconfig[section] = cfgsection self.args = args return finalconfig
def dict2config(jdict, section): config = ConfigParser() if not config.has_section(section): config.add_section(section) for (k, v) in viewitems(jdict): config.set(section, k, str(v)) return config
def reset(): global bin_paths global config global configs_found global tivos_found bin_paths = {} config = ConfigParser.ConfigParser() configs_found = config.read(config_files) if not configs_found: print ('WARNING: pyTivo.conf does not exist.\n' + 'Assuming default values.') configs_found = config_files[-1:] for section in config.sections(): if section.startswith('_tivo_'): tsn = section[6:] if tsn.upper() not in ['SD', 'HD', '4K']: tivos_found = True tivos[tsn] = Bdict(config.items(section)) for section in ['Server', '_tivo_SD', '_tivo_HD', '_tivo_4K']: if not config.has_section(section): config.add_section(section)
def main(): # process configuration file (if exists) and setup logging config = SafeConfigParser(cfg_defaults) config.add_section('common') for key, value in cfg_defaults.items(): config.set('common', key, str(value)) if config.read(cfg_filename): logging.config.fileConfig(cfg_filename) else: logging.basicConfig(stream=sys.stdout, level=cfg_defaults['logLevel'], format=cfg_defaults['logFormat']) # process command line arguments parser = OptionParser(version='{0} {1}'.format(__description__, __version__), description=__description__) parser.add_option('-b', '--brokerUrl', dest='brokerUrl', metavar='URL', type='string', default=config.get('common', 'brokerUrl'), help='context broker URL [default=%default]'), parser.add_option('-l', '--logLevel', dest='logLevel', metavar='LEVEL', choices=[level for level in logging._levelNames.keys() if isinstance(level, str)], default=config.get('common', 'logLevel'), help='logging level [default=%default]') (opts, args) = parser.parse_args() # @UnusedVariable config.set('common', 'brokerUrl', opts.brokerUrl) config.set('common', 'logLevel', opts.logLevel) logging.root.setLevel(opts.logLevel) # rpc connection connection = rpc.create_connection() try: logging.info('Context Broker URL: %s', config.get('common', 'brokerUrl')) listen(connection, config) finally: connection.close() return 0
def dict2config(jdict, section): config = ConfigParser.ConfigParser() if not config.has_section(section): config.add_section(section) for k,v in jdict.iteritems(): config.set(section, k, str(v)) return config
def reset(): global bin_paths global config global configs_found bin_paths = {} config = ConfigParser.ConfigParser() configs_found = config.read(config_files) if not configs_found: print ("WARNING: pyTivo.conf does not exist.\n" + "Assuming default values.") configs_found = config_files[-1:] for section in config.sections(): if section.startswith("_tivo_"): tsn = section[6:] if tsn.upper() not in ["SD", "HD"]: if config.has_option(section, "name"): tivo_names[tsn] = config.get(section, "name") else: tivo_names[tsn] = tsn if config.has_option(section, "address"): tivos[tsn] = config.get(section, "address") for section in ["Server", "_tivo_SD", "_tivo_HD"]: if not config.has_section(section): config.add_section(section)
def reset(): global bin_paths global config global configs_found global tivos_found bin_paths = {} config = ConfigParser.ConfigParser() configs_found = config.read(config_files) if not configs_found: print('WARNING: pyTivo.conf does not exist.\n' + 'Assuming default values.') configs_found = config_files[-1:] for section in config.sections(): if section.startswith('_tivo_'): tsn = section[6:] if tsn.upper() not in ['SD', 'HD', '4K']: tivos_found = True tivos[tsn] = Bdict(config.items(section)) for section in ['Server', '_tivo_SD', '_tivo_HD', '_tivo_4K']: if not config.has_section(section): config.add_section(section)
def dict2config(jdict, section): config = ConfigParser.ConfigParser() if not config.has_section(section): config.add_section(section) for k, v in jdict.iteritems(): config.set(section, k, str(v)) return config
def get_service_configuration(configfile_handler=None): """I set rdfrest Service default configuration options and possibly override them with the values extracted from a configuration file. :param configfile_handler: optional handler of a configuration file :return: Configuration object. """ # When allow_no_value=True is passed, options without values return None # The value must be used as flags i.e # [rdf_database] # repository # and not : # repository = # which will return an empty string whatever 'allow_no_value' value is set config = SafeConfigParser(allow_no_value=True) # Setting default values config.add_section("server") config.set("server", "host-name", "localhost") config.set("server", "port", "8001") config.set("server", "base-path", "") config.set("server", "force-ipv4", "false") config.set("server", "max-bytes", "-1") config.set("server", "no-cache", "false") config.set("server", "flash-allow", "false") config.set("server", "max-triples", "-1") config.set("server", "cors-allow-origin", "") config.set("server", "resource-cache", "false") config.add_section("ns_prefix") # A future specification section "httpd" or "wsgi" # may be needed for HttpFrontend # config.add_section('httpd') config.add_section("plugins") config.set("plugins", "post_via_get", "false") # TODO : optional plugin specific configuration # config.add_section('post_via_get') config.add_section("rdf_database") config.set("rdf_database", "repository", "") config.set("rdf_database", "force-init", "false") config.add_section("logging") config.set("logging", "loggers", "") config.set("logging", "console-level", "INFO") # No filename implies no logging to file config.set("logging", "filename", "") config.set("logging", "file-level", "INFO") config.set("logging", "json-configuration-filename", "logging.json") # Loading from config file if configfile_handler is not None: config.readfp(configfile_handler) return config
def get_service_configuration(configfile_handler=None): """I set rdfrest Service default configuration options and possibly override them with the values extracted from a configuration file. :param configfile_handler: optional handler of a configuration file :return: Configuration object. """ # When allow_no_value=True is passed, options without values return None # The value must be used as flags i.e # [rdf_database] # repository # and not : # repository = # which will return an empty string whatever 'allow_no_value' value is set config = SafeConfigParser(allow_no_value=True) # Setting default values config.add_section('server') config.set('server', 'host-name', 'localhost') config.set('server', 'port', '8001') config.set('server', 'base-path', '') config.set('server', 'force-ipv4', 'false') config.set('server', 'max-bytes', '-1') config.set('server', 'no-cache', 'false') config.set('server', 'flash-allow', 'false') config.set('server', 'max-triples', '-1') config.set('server', 'cors-allow-origin', '') config.set('server', 'resource-cache', 'false') config.add_section('ns_prefix') # A future specification section "httpd" or "wsgi" # may be needed for HttpFrontend #config.add_section('httpd') config.add_section('plugins') config.set('plugins', 'post_via_get', 'false') # TODO : optional plugin specific configuration #config.add_section('post_via_get') config.add_section('rdf_database') config.set('rdf_database', 'repository', '') config.set('rdf_database', 'force-init', 'false') config.add_section('logging') config.set('logging', 'loggers', '') config.set('logging', 'console-level', 'INFO') # No filename implies no logging to file config.set('logging', 'filename', '') config.set('logging', 'file-level', 'INFO') config.set('logging', 'json-configuration-filename', 'logging.json') # Loading from config file if configfile_handler is not None: config.readfp(configfile_handler) return config
def get_url(config, target): try: return config.get('gist-sync', 'url') except six.moves.configparser.NoSectionError: logger.debug('no section: create gist: %s', target) config.add_section('gist-sync') except six.moves.configparser.NoOptionError: logger.debug('no option: create gist: %s', target)
def set(config, section, option, value): if value is not None: if section not in config: config.add_section(section) config[section][option] = value elif section in config and option in config[section]: del config[section][option] if not config[section]: del config[section]
def get_commit_hash(config, target): try: return config.get('gist-sync', 'commit').strip() except six.moves.configparser.NoSectionError: logger.debug('no section: commit: %s', target) config.add_section('gist-sync') except six.moves.configparser.NoOptionError: logger.debug('no option: commit: %s', target) return None
def getConfiguration(cfgfile=None, config_required={'Main': {'key1': 'value1', 'key2': 'value2'}}): ''' read an ini configuration file and return a dictionary of key/value pairs update configuration file if missing any sections accepts: cfgfile - path to configuration file config_required - nested dictionary in the following format: {'Section1': {'key1': 'value1', 'key2': 'value2'}, 'Section 2': {'key1': 'value1'} } ''' if not cfgfile: raise ValueError('no configuration file specified') # required configuraiton options # Section: {'option': 'default value'} logger = logging.getLogger(__name__) logger.debug('getting configuration from file: {}'.format(cfgfile)) cfgpath = os.path.dirname(cfgfile) # config_required = { # 'Main': {'credentials': os.path.join(cfgpath, 'credentials/'), # }, # } config = configuration.get_config(cfgfile) update_config = False logger.debug('checking sections') for section, values in list(config_required.items()): if not config.has_section(section): logger.warning('section: {} not found in {}'.format(section, cfgfile)) logger.debug('adding section {}'.format(section)) config.add_section(section) update_config = True for option, value in list(values.items()): if not config.has_option(section, option): logger.warning('option: {} not found in {}'.format(option, cfgfile)) logger.debug('adding option {}: {}'.format(option, value)) config.set(section, option, value) update_config = True # for section, options in config_required.items(): if update_config: try: logger.debug('updating configuration file at: {}'.format(cfgfile)) configuration.create_config(cfgfile, config) except Exception as e: logger.error(e) return(config)
def get_title(config, target, files): title = None try: title = config.get('gist-sync', 'title').strip() except six.moves.configparser.NoSectionError: logger.debug('no section: title: %s', target) config.add_section('gist-sync') except six.moves.configparser.NoOptionError: logger.debug('no option: title: %s', target) return title or get_title_from_files(files)
def create_default_configuration(cls, default_profile_url): """ensure a default profile is configured.""" config_directory = cls._ensure_configuration_directory() config = ConfigParser() config.add_section('default') config.set('default', 'repository', default_profile_url) with open(os.path.join(config_directory, 'profiles'), 'w') as profiles_file: config.write(profiles_file) return cls()
def test_invalid_config_file(self): config = ConfigParser() config.add_section("telegram-bot") config.add_section("allowed-users") app = self.application_module.Application(self.config, self.opts) app.config = config self.assertRaises(self.application_module.InvalidConfigurationException, app.load_configuration, self.opts.to)
def get_service_configuration(configfile_handler=None): """I set rdfrest Service default configuration options and possibly override them with the values extracted from a configuration file. :param configfile_handler: optional handler of a configuration file :return: Configuration object. """ # When allow_no_value=True is passed, options without values return None # The value must be used as flags i.e # [rdf_database] # repository # and not : # repository = # which will return an empty string whatever 'allow_no_value' value is set config = SafeConfigParser(allow_no_value=True) # Setting default values config.add_section('server') config.set('server', 'host-name', 'localhost') config.set('server', 'port', '8001') config.set('server', 'threads', '2') config.set('server', 'base-path', '') config.set('server', 'force-ipv4', 'false') config.set('server', 'max-bytes', '-1') config.set('server', 'flash-allow', 'false') config.set('server', 'max-triples', '-1') config.set('server', 'cors-allow-origin', '') config.set('server', 'reset-connection', 'false') config.set('server', 'send-traceback', 'false') config.add_section('ns_prefix') # A future specification section "httpd" or "wsgi" # may be needed for HttpFrontend #config.add_section('httpd') config.add_section('plugins') config.set('plugins', 'post_via_get', 'false') # TODO : optional plugin specific configuration #config.add_section('post_via_get') config.add_section('rdf_database') config.set('rdf_database', 'repository', '') config.set('rdf_database', 'force-init', 'false') config.add_section('logging') config.set('logging', 'loggers', '') # Loading from config file if configfile_handler is not None: config.readfp(configfile_handler) return config
def test_invalid_config_file(self): config = ConfigParser() config.add_section("telegram-bot") config.add_section("allowed-users") app = self.application_module.Application(self.config, self.opts) app.config = config self.assertRaises( self.application_module.InvalidConfigurationException, app.load_configuration, self.opts.to)
def _setup_system(self): config_dir = utils.Utils().get_app_dir() config_path = os.path.join(config_dir, '.guardiancl.ini') if not os.path.exists(config_path): config = configparser2.ConfigParser() config.add_section('ROUTES') config.set('ROUTES', 'auth', 'http://guardiaocloud.com.br/service/v1/authenticate') config.set('ROUTES', 'devices', 'http://guardiaocloud.com.br/service/v1/devices') config.set('ROUTES', 'collect', 'http://guardiaocloud.com.br/collect') with open(config_path, 'w') as configfile: config.write(configfile)
def write_config(albumNum, trackNum): # Add content to the file config = ConfigParser.ConfigParser() config.add_section('cdc') config.set('cdc', 'album', albumNum) config.set('cdc', 'track', trackNum) # Create the configuration file as it doesn't exist yet with open(CONFIG, 'w') as file: config.write(file) logger.info('write config album: {}, track: {}'.format(albumNum, trackNum)) return
def write_config_to_filename(config_dictionary, config_filename): config = SafeConfigParser() for section in config_dictionary: config.add_section(section) variables = config_dictionary[section] for v in variables: config.set(section, v, variables[v]) mode = stat.S_IRUSR | stat.S_IWUSR flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL fd = os.open(config_filename, flags, mode) f = os.fdopen(fd, 'wb') config.write(f) f.close()
def get_cache_dir(config, target): cache_dir = None try: cache_dir = config.get('gist-sync', 'cache_dir').strip() except six.moves.configparser.NoSectionError: logger.debug('no section: title: %s', target) config.add_section('gist-sync') except six.moves.configparser.NoOptionError: logger.debug('no option: title: %s', target) if not cache_dir: cache_dir = '.gist-sync' config.set('gist-sync', 'cache_dir', cache_dir) return cache_dir
def create_default_config(): config = ConfigParser.ConfigParser() # set some defaults, which may be overwritten config.add_section('network') config.set('network', 'listen_host', '0.0.0.0') config.set('network', 'listen_port', '30303') config.set('network', 'num_peers', '5') config.set('network', 'remote_port', '30303') config.set('network', 'remote_host', '') config.set('network', 'client_id', Packeter.CLIENT_ID) config.set('network', 'node_id', sha3(str(uuid.uuid1())).encode('hex')) config.add_section('api') config.set('api', 'listen_host', '127.0.0.1') config.set('api', 'listen_port', '30203') config.add_section('misc') config.set('misc', 'verbosity', '1') config.set('misc', 'config_file', None) config.set('misc', 'logging', None) config.set('misc', 'data_dir', data_dir.path) config.set('misc', 'mining', '10') config.add_section('wallet') config.set('wallet', 'coinbase', '0' * 40) return config
def writeDefaultConfig(config): config.add_section('STORAGE') storageConfig = config['STORAGE'] storageConfig['data_path'] = 'data/storage/' config.add_section('TASK_MANAGER') config.add_section('SERVER') config.add_section('SCHEDULER') config.add_section('LOGGING') loggingConfig = config['LOGGING'] loggingConfig['file'] = CONFIG_PATH + '/logging.conf' if not os.path.exists(CONFIG_PATH): os.makedirs(CONFIG_PATH) with open(CONFIG_FILE,'w') as configFile: config.write(configFile)
def setup(self): """ Call super(TESTNAME, self).setup() """ self.kernel = MockKernel() self.kernel.services = {} try: config.add_section('Database') except: pass config.set('Database','connectionstring','sqlite://') if self.kernel.session == None: raise Exception("The test framework is broken")
def updateLogConfig(fileName, loggerName): try: config = openLogConfig(fileName) config.set('loggers', 'keys', config.get('loggers', 'keys')+','+loggerName) print 'new logger names:',config.get('loggers', 'keys') config.add_section('logger_'+loggerName) config.set('logger_'+loggerName, 'handlers', 'consoleHandler') config.set('logger_'+loggerName, 'propagate', '0') config.set('logger_'+loggerName, 'level', 'ERROR') config.set('logger_'+loggerName, 'qualname', loggerName) configfile = open(fileName, 'wb') config.write(configfile) except: pass
def user_update(username): if not config: raise ValueError('Configuration not loaded') if not config.has_section('users'): config.add_section('users') if config.has_option('users', username): print 'Changing password for %s' % username else: print 'Adding new user %s' % username password = getpass.getpass('Password: '******' * Updating OFTG-Ninja config ...' return True else: print ' * Failed to update user' return False
def write_config(self, filename): # Ecrit les config de toutes les sections dans un autre fichier """ :param filename: """ LOG.info("Writing .ini file (%s)" % filename) config = SafeConfigParser(allow_no_value=True) iniout = open(filename, mode="w") for section in self._sections: config.add_section(section) if hasattr(self, section): for opt in getattr(self, section).config: config.set(section, str(opt), str(getattr(self, section).config.get(opt))) config.write(iniout)
def load_config(config, path): """Loads the config from file or creates a new one if that file is missing.""" if not path.is_file(): config.add_section("window") config.set("window", "xsize", "1200") config.set("window", "ysize", "700") config.set("window", "xpos", "200") config.set("window", "ypos", "200") config.add_section("io") config.set("io", "xydir", str(CONFDIR / "xy_temp/")) config.set("io", "project_file", "None") config.set("io", "project_dir", os.environ["HOME"]) config.set("io", "data_dir", os.environ["HOME"]) config.set("io", "export_dir", os.environ["HOME"]) with open(str(path), "w") as cfg_file: config.write(cfg_file) else: config.read(str(path))
def getConfiguration(cfgfile): # required configuraiton options # Section: {'option': 'default value'} logger = logging.getLogger(__name__) logger.debug('getting configuration from file: {}'.format(cfgfile)) cfgpath = os.path.dirname(cfgfile) config_required = { 'Main': { 'credentials': os.path.join(cfgpath, 'credentials/'), }, } config = configuration.get_config(cfgfile) update_config = False logger.debug('checking sections') for section, values in list(config_required.items()): if not config.has_section(section): logger.warning('section: {} not found in {}'.format( section, cfgfile)) logger.debug('adding section {}'.format(section)) config.add_section(section) update_config = True for option, value in list(values.items()): if not config.has_option(section, option): logger.warning('option: {} not found in {}'.format( option, cfgfile)) logger.debug('adding option {}: {}'.format(option, value)) config.set(section, option, value) update_config = True # for section, options in config_required.items(): if update_config: try: logger.debug('updating configuration file at: {}'.format(cfgfile)) configuration.create_config(cfgfile, config) except Exception as e: logger.error(e) return (config)
def updateLogConfig(fileName, loggerName): config = openLogConfig(fileName) try: config.set('loggers', 'keys', config.get('loggers', 'keys') + ',' + loggerName) #print 'new logger names:',config.get('loggers', 'keys') config.add_section('logger_' + loggerName) config.set('logger_' + loggerName, 'handlers', 'consoleHandler') config.set('logger_' + loggerName, 'propagate', '0') config.set('logger_' + loggerName, 'level', 'ERROR') config.set('logger_' + loggerName, 'qualname', loggerName) configfile = open(fileName, 'wb') config.write(configfile) except: configfile = open(fileName, 'wb') try: config.add_section('loggers') except: pass config.set('loggers', 'keys', '') config.write(configfile)
def write_report_details(self): phy_topology = self._get_phy_topology_detail() details_h = open(self.report_details_file, 'w') config = ConfigParser.ConfigParser() config.add_section('Test') config.set('Test', 'Build', self.build_id) config.set('Test', 'timestamp', self.ts) config.set('Test', 'Report', self.html_log_link) config.set('Test', 'LogsLocation', self.log_link) config.set('Test', 'Topology', phy_topology) config.write(details_h) log_location = '' if self.jenkins_trigger: log_location = "nodeb10.englab.juniper.net:/cs-shared/test_runs" \ "/%s/%s" % (self.host_data[self.cfgm_ips[0]]['name'], self.ts) config.set('Test', 'CoreLocation', log_location) details_h.close()
def __parse_config_file(file = None): """ Parse the configuration file :param file: Configuration file to parse :type file: String """ config = ConfigParser.ConfigParser() if file is not None: # If config file, load Logger config Config._log = logging logging.config.fileConfig(file) config.readfp(open(file)) else: # Set defaults config.add_section("app:main") config.set("app:main","db_uri","mongodb://localhost") config.set("app:main","db_name","mobyle") Config._config = config
def setting(self): """Setting up config file :return: config object """ home_path = os.path.dirname( os.path.dirname(os.path.realpath('__file__'))) s3_path = 's3://' + self.project_name user = '******' password = '******' redshift_path = 'postgresql://' + user + ':' + password + \ '@automl-instance.cbfploinlvqm.us-east-1.redshift.amazonaws.com:5439/' + self.database_name config = configparser.ConfigParser() config.add_section('PATH') config.set('PATH', 'home_path', home_path) config.set('PATH', 'model_path', os.path.join(home_path, 'model')) config.set('PATH', 'preprocess_path', os.path.join(home_path, 'preprocess')) config.set('PATH', 'log_path', os.path.join(home_path, 'log-database')) config.set('PATH', 's3_path', s3_path) config.set('PATH', 'redshift_path', redshift_path) return config
def main(): locale.setlocale(locale.LC_ALL, '') args = command_args() config = ConfigParser(interpolation=ExtendedInterpolation(), default_section="defaults") config.add_section("paths") config["paths"] = { "pkgdir": PKG_DIR } config.read("badumtss.conf") probe_input_drivers(config) loop = asyncio.get_event_loop() try: loop.add_signal_handler(signal.SIGINT, loop.stop) loop.add_signal_handler(signal.SIGTERM, loop.stop) player = player_factory(config, loop, section=args.player) if not player: logger.error("No MIDI player available.") if not args.keymap_wizard: return input_devices = list(input_devices_generator(config, loop, section=args.input_device)) player.start() try: if args.keymap_wizard: keymap_wizard(args, loop, input_devices, player) else: play_input(args, loop, input_devices, player) finally: for input_device in input_devices: input_device.stop() player.stop() finally: loop.close()
def reset(): global bin_paths global config global configs_found global tivos_found bin_paths = {} config = ConfigParser.ConfigParser() configs_found = config.read(config_files) if not configs_found: print ("WARNING: pyTivo.conf does not exist.\n" + "Assuming default values.") configs_found = config_files[-1:] for section in config.sections(): if section.startswith("_tivo_"): tsn = section[6:] if tsn.upper() not in ["SD", "HD", "4K"]: tivos_found = True tivos[tsn] = Bdict(config.items(section)) for section in ["Server", "_tivo_SD", "_tivo_HD", "_tivo_4K"]: if not config.has_section(section): config.add_section(section)
def create_config(path): """ Create a config file :param path: path to file :return: None """ config = configparser.ConfigParser() config.add_section("CSV_file") config.set("CSV_file", "Working", "True") config.set("CSV_file", "file name", "output.log") config.add_section("sieve_interval") config.set("sieve_interval", "sieve_interval", "100000") config.add_section("over_smooth") config.set("over_smooth", "over_smooth", "20") config.add_section("numbers") config.set("numbers", "numbers", "") with open(path, "w") as config_file: config.write(config_file)
def writeConfig(self): ''' This function creates / saves log settings to a file. ''' config = ConfigParser.ConfigParser() config.add_section('loggers') config.set('loggers', 'keys', 'root') config.add_section('formatters') config.set('formatters', 'keys', 'basic,nix') config.add_section('handlers') config.set('handlers', 'keys', 'consoleHandler,syslogHandler') config.add_section('logger_root') config.set('logger_root', 'level', 'DEBUG') config.set('logger_root', 'handlers', 'consoleHandler,syslogHandler') config.add_section('handler_consoleHandler') config.set('handler_consoleHandler', 'class', 'StreamHandler') config.set('handler_consoleHandler', 'level', 'NOTSET') config.set('handler_consoleHandler', 'formatter', 'basic') config.set('handler_consoleHandler', 'args', '(sys.stdout,)') config.add_section('handler_syslogHandler') config.set('handler_syslogHandler', 'class', 'handlers.SysLogHandler') config.set('handler_syslogHandler', 'level', 'NOTSET') config.set('handler_syslogHandler', 'formatter', 'nix') config.set('handler_syslogHandler', 'args', "(('/dev/log'), handlers.SysLogHandler.LOG_USER)") config.add_section('formatter_basic') config.set('formatter_basic', 'format', '%(asctime)s freeseer: <%(levelname)s> %(message)s') config.set('formatter_basic', 'datefmt', '%Y-%m-%d %H:%M:%S') config.add_section('formatter_nix') config.set('formatter_nix', 'format', 'freeseer: <%(levelname)s> %(message)s') # Save default settings to new config file with open(self.logconf, 'w') as configfile: config.write(configfile)
def create_config(): config = ConfigParser.ConfigParser() # set some defaults, which may be overwritten config.add_section('network') config.set('network', 'listen_host', 'localhost') config.set('network', 'listen_port', '30303') config.set('network', 'num_peers', '5') config.set('network', 'remote_port', '30303') config.set('network', 'remote_host', '') config.set('network', 'client_id', 'Ethereum(py)/0.0.1') config.add_section('misc') config.set('misc', 'verbosity', '1') config.set('misc', 'config_file', None) config.set('misc', 'logging', None) config.add_section('wallet') # NODE_ID == pubkey, needed in order to work with Ethereum(++) config.set( 'wallet', 'pub_key', 'J\x02U\xfaFs\xfa\xa3\x0f\xc5\xab\xfd<U\x0b\xfd\xbc\r<\x97=5' '\xf7&F:\xf8\x1cT\xa02\x81\xcf\xff"\xc5\xf5\x96[8\xacc\x01R' '\x98wW\xa3\x17\x82G\x85I\xc3o|\x84\xcbD6\xbay\xd6\xd9') usage = "usage: %prog [options]" parser = OptionParser(usage=usage, version="%prog 0.1a") parser.add_option("-l", "--listen", dest="listen_port", default=config.get('network', 'listen_port'), help="<port> Listen on the given port for incoming" " connected (default: 30303).") parser.add_option("-r", "--remote", dest="remote_host", help="<host> Connect to remote host" " (try: 54.201.28.117 or 54.204.10.41)") parser.add_option("-p", "--port", dest="remote_port", default=config.get('network', 'remote_port'), help="<port> Connect to remote port (default: 30303)") parser.add_option( "-v", "--verbose", dest="verbosity", default=config.get('misc', 'verbosity'), help="<0 - 3> Set the log verbosity from 0 to 3 (default: 1)") parser.add_option( "-L", "--logging", dest="logging", default=config.get('misc', 'logging'), help="<logger1:LEVEL,logger2:LEVEL> set the console log level for" " logger1, logger2, etc. Empty loggername means root-logger," " e.g. 'pyethereum.wire:DEBUG,:INFO'. Overrides '-v'") parser.add_option( "-x", "--peers", dest="num_peers", default=config.get('network', 'num_peers'), help="<number> Attempt to connect to given number of peers" "(default: 5)") parser.add_option("-C", "--config", dest="config_file", help="read coniguration") (options, args) = parser.parse_args() # set network options for attr in ('listen_port', 'remote_host', 'remote_port', 'num_peers'): config.set('network', attr, getattr(options, attr) or config.get('network', attr)) # set misc options for attr in ('verbosity', 'config_file'): config.set('misc', attr, getattr(options, attr) or config.get('misc', attr)) if len(args) != 0: parser.error("wrong number of arguments") sys.exit(1) if config.get('misc', 'config_file'): config.read(config.get('misc', 'config_file')) # configure logging loggerlevels = getattr(options, 'logging') or '' configure_logging(loggerlevels, verbosity=config.getint('misc', 'verbosity')) return config
def writeDefaultConfig(config): config.add_section('STORAGE') storageConfig = config['STORAGE'] storageConfig['data_path'] = 'data/storage/' config.add_section('SCHEDULER') config.add_section('TASK_MANAGER') config.add_section('INTERFACE') config.add_section('CONTRACTOR') config.add_section('ENTITY_MANAGER') interfaceConfig = config['INTERFACE'] interfaceConfig['xmlrpc_server_addr'] = 'localhost' interfaceConfig['xmlrpc_server_port'] = '8000' config.add_section('LOGGING') loggingConfig = config['LOGGING'] loggingConfig['file'] = CONFIG_PATH + '/logging.conf' if not os.path.exists(CONFIG_PATH): os.makedirs(CONFIG_PATH) with open(CONFIG_FILE,'w') as configFile: config.write(configFile)
def main(): formatterStr = '%(asctime)s %(module)s:%(lineno)d [%(levelname)s]:%(message)s' logging.basicConfig(level=logging.DEBUG, format=formatterStr) logger = logging.getLogger() config = configparser.RawConfigParser() config.add_section('Section1') config.set('Section1', 'an_int', '15') config.set('Section1', 'a_bool', 'true') config.set('Section1', 'a_float', '3.1415') config.set('Section1', 'baz', 'fun') config.set('Section1', 'bar', 'Python') config.set('Section1', 'foo', '%(bar)s is %(baz)s!') with io.open('example.cfg', 'w') as configfile: config.write(configfile) config1 = configparser.RawConfigParser() config1.read('example.cfg') logger.info("config1{") a_float = config1.getfloat('Section1', 'a_float') an_int = config1.getint('Section1', 'an_int') logger.info(a_float + an_int) if config1.getboolean('Section1', 'a_bool'): logger.info(config1.get('Section1', 'foo')) logger.info("}") logger.info("config2{") config2 = configparser.ConfigParser() config2.read('example.cfg') logger.info(config2.get('Section1', 'foo', 0)) logger.info(config2.get('Section1', 'foo', 1)) logger.info(config2.get('Section1', 'foo', 0, {'bar': 'Documentation', 'baz': 'evil'})) logger.info("}") logger.info("config3{") config3 = configparser.SafeConfigParser({'bar': 'Life', 'baz': 'hard'}) config3.read('example.cfg') logger.info(config3.get('Section1', 'foo')) config3.remove_option('Section1', 'bar') config3.remove_option('Section1', 'baz') logger.info(config3.get('Section1', 'foo')) logger.info("}") logger.info("config4{") sample_config = """ [mysqld] user = mysql pid-file = /var/run/mysqld/mysqld.pid skip-external-locking old_passwords = 1 skip-bdb skip-innodb """ config4 = configparser.RawConfigParser(allow_no_value=True) config4.readfp(io.BytesIO(sample_config)) # Settings with values are treated as before: config4.get("mysqld", "user") # Settings without values provide None: config4.get("mysqld", "skip-bdb") # Settings which aren't specified still raise an error: config4.get("mysqld", "does-not-exist") logger.info("}")
def main(): """Entry point.""" # 1. Configure logconfig = None options, overrides, srcpkg_path = parse_cmdline() config = ConfigParser() if os.path.exists(options.config): config.read(options.config) if not config.has_section(DERBUILD_SECTION): config.add_section(DERBUILD_SECTION) try: logconfig = config.get(DERBUILD_SECTION, LOGCONFIG_OPT, vars=overrides) except NoOptionError: if config.has_section("loggers"): logconfig = options.config else: config.add_section(DERBUILD_SECTION) # Initialize logging: # 1. try to find settings for logging # * in the command line option '--log-config' first, # * then in option 'logconfig' in the section [derbuild] of # derbuild's config file, # * then in derbuild's config file itself # 2. if logging settings have been found then load them # 3. otherwise initialize logging with standard basic settings. if logconfig: logging.config.fileConfig(logconfig, disable_existing_loggers=False) if options.debug: rootlogger = logging.getLogger() rootlogger.setLevel(logging.DEBUG) else: if options.debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.WARNING) LOG.debug("logging initialized") options = get_effective_options(options, overrides, config) # 2. Set up # prepare working directory if os.path.exists(options.workdir): LOG.error("working directory '%s' exists already. Exiting..." % options.workdir) sys.exit(1) os.makedirs(options.workdir) # prepare output directory if not os.path.isdir(options.outdir): os.makedirs(options.outdir) env = BuildEnvironment(options.arch, options.rootdir, options.envvars, options.binds) env.setup(options.rootstrap, options.overdir) pkg = get_package(options.type, srcpkg_path, options.workdir, env) # 3. Build pkg.unpack() pkg.build() pkg.get_artifacts(options.outdir) # 4. Clean up env.destroy() LOG.debug("removing the working directory '%s'" % options.workdir) shutil.rmtree(options.workdir)
def main(argv=None): # IGNORE:C0111 '''Command line options.''' if argv is None: argv = sys.argv else: sys.argv.extend(argv) program_name = os.path.basename(sys.argv[0]) program_version = "v%s" % __version__ program_build_date = str(__updated__) program_version_message = '%%(prog)s %s (%s)' % (program_version, program_build_date) program_shortdesc = __import__('__main__').__doc__.split("\n")[1] program_license = '''%s Copyright 2017 Neul Ltd. All rights reserved. Distributed on an "AS IS" basis without warranties or conditions of any kind, either express or implied. USAGE ''' % program_shortdesc print("%s %s (%s)" % (__programname__, program_version, program_build_date)) default_config_files = [ os.path.join(os.path.dirname(os.path.realpath(__file__)), __programname__ + ".cfg"), os.path.join(os.path.expanduser("~"), "." + __programname__ + ".cfg") ] CONFIG_SECTION = __programname__ try: # Setup argument parser argparser = ArgumentParser(description=program_license, formatter_class=RawDescriptionHelpFormatter) # generic commands argparser.add_argument("-V", "--version", action='version', version=program_version_message) # generic options argparser.add_argument("-c", "--config", dest="config", metavar="FILE", default=None, help="Configuration file.") argparser.add_argument( "-v", "--verbose", dest="verbose", action="count", help="set verbosity level [default: %(default)s]") # specific options argparser.add_argument("-ksid", "--keystoreid", dest="keystoreid", default=None, action="append", help="keystore 0 (SiVendor) or 1 (Customer)") argparser.add_argument("-cert1", "--certificate1", dest="certificate1", default=None, action="append", help="X509 Public Key Certificate (DER)") argparser.add_argument("-cert2", "--certificate2", dest="certificate2", default=None, action="append", help="X509 Public Key Certificate (DER)") argparser.add_argument("-cert3", "--certificate3", dest="certificate3", default=None, action="append", help="X509 Public Key Certificate (DER)") argparser.add_argument("-cert4", "--certificate4", dest="certificate4", default=None, action="append", help="X509 Public Key Certificate (DER)") argparser.add_argument("-use1", "--use1", dest="use1", default=None, help="Keystore Key use") argparser.add_argument("-use2", "--use2", dest="use2", default=None, help="Keystore Key use") argparser.add_argument("-use3", "--use3", dest="use3", default=None, help="Keystore Key use") argparser.add_argument("-use4", "--use4", dest="use4", default=None, help="Keystore Key use") argparser.add_argument("-iks", "--inputkeystore", dest="input_keystore", default=None, help="Keystore File") # Actions argparser.add_argument("-createkeystore", "--createkeystore", dest="createkeystore", action="store_true", default=False, help="Create a Keystore") argparser.add_argument("-printkeystore", "--printkeystore", dest="printkeystore", action="store_true", default=False, help="Print Keystore (takes no arguements)") # Process arguments commandline_options = vars(argparser.parse_args()) logging_configured = False cfg_defaults = { # Command line options defaults 'verbose': 0, 'certificate1': None, 'certificate2': None, 'certificate3': None, 'certificate4': None, 'use1': None, 'use2': None, 'use3': None, 'use4': None, } # Make sure all our options are strings. config_defaults = {} for k, v in cfg_defaults.items(): if v != None: config_defaults[k] = str(v) else: config_defaults[k] = None config = ConfigParser.SafeConfigParser(config_defaults) if commandline_options['config']: configfile = os.path.abspath(commandline_options['config']) if configfile in config.read(configfile): try: logging.config.fileConfig(configfile) logging_configured = True except NoSectionError: pass if not config.has_section(CONFIG_SECTION): config.add_section(CONFIG_SECTION) else: # Try loading defaults if no command line options given. for configfile in default_config_files: if configfile in config.read(configfile): try: logging.config.fileConfig(configfile) logging_configured = True except NoSectionError: pass break # Add section if we don't have one if not config.has_section(CONFIG_SECTION): config.add_section(CONFIG_SECTION) # Override settings with settings from command line. for k, v in commandline_options.items(): if v != None: if isinstance(v, list): config.set(CONFIG_SECTION, k, "|".join(v)) else: config.set(CONFIG_SECTION, k, str(v)) # We should now have a config option parser with everything set... # If we are verbose when add logging to std verbose = config.get(CONFIG_SECTION, 'verbose') if verbose and verbose != "0": console_handler = logging.StreamHandler(sys.stdout) console_handler.setLevel( logging.CRITICAL ) # set later by set_log_level_from_verbose() in interactive sessions console_handler.setFormatter( logging.Formatter('%(asctime)s: %(levelname)s: %(message)s')) loglevel = logging.DEBUG if verbose == '1': loglevel = logging.ERROR if verbose == '2': loglevel = logging.WARNING elif verbose == '3': loglevel = logging.INFO console_handler.setLevel(loglevel) logging.root.addHandler(console_handler) if not logging_configured: logging.root.setLevel(loglevel) logging_configured = True if not logging_configured: logging.basicConfig( level=logging.CRITICAL, format="%(asctime)s: %(levelname)s: %(message)s", stream=sys.stderr) logging.debug("Logging configured") logging.info("%s %s (%s)" % (__programname__, program_version, program_build_date)) foundAction = False # ----------------------------------------------------------------------- # Sign an image if commandline_options.get('createkeystore', None): foundAction = True logging.info("Create Keystore") # keystore id keystoreID = int(config.get(CONFIG_SECTION, 'keystoreid')) # load assets signerCertificateFilename = [ config.get(CONFIG_SECTION, 'certificate1'), config.get(CONFIG_SECTION, 'certificate2'), config.get(CONFIG_SECTION, 'certificate3'), config.get(CONFIG_SECTION, 'certificate4') ] for cert in signerCertificateFilename: if cert is not None: if os.path.isfile(cert) is not True: logging.error("Certificate file does not exist.", cert) print("Certificate file does not exist.", cert) return -1 signerCertificateUse = [ config.get(CONFIG_SECTION, 'use1'), config.get(CONFIG_SECTION, 'use2'), config.get(CONFIG_SECTION, 'use3'), config.get(CONFIG_SECTION, 'use4') ] paramAdded = False for cert, use in zip(signerCertificateFilename, signerCertificateUse): if cert is not None and use is not None: paramAdded = True if not paramAdded: logging.error("No certificate/use specified.") print("No certificate/use specified.") return -1 # generate keystore keystore = [] for certFile, certUse in zip(signerCertificateFilename, signerCertificateUse): if certFile is not None: keystore.extend( [createKeystoreKey(certFile, int(certUse))]) # write to a fixed name for now cwd = os.getcwd() dir_path = os.path.dirname(os.path.realpath(__file__)) keystore_name = 'keystore_' + str(keystoreID) outfile = os.path.join(cwd, keystore_name) + '.keystore' hashfile = os.path.join(cwd, keystore_name) + '.sha256' # logging.info("Writing file '%s'" % outfile) print("Writing file '%s'" % outfile) writeKeystore(outfile, keystoreID, keystore) # logging.info("Writing keystore hash file '%s'" % hashfile) print("Writing keystore hash file '%s'" % hashfile) generateKeystoreHashFile(outfile, hashfile) # ----------------------------------------------------------------------- # Print Keystore if commandline_options.get('printkeystore', None): foundAction = True logging.info("Print Keystore") keystoreFilename = config.get(CONFIG_SECTION, 'input_keystore') if keystoreFilename is None: logging.error("Could not load keystore %s" % keystoreFilename) print("Could not load keystore %s" % keystoreFilename) return -1 logging.info("Keystore: %s" % keystoreFilename) print("Keystore: %s" % keystoreFilename) keystore_id, loadedKeystore = readKeystore(keystoreFilename) printKeystore(keystore_id, loadedKeystore) # ----------------------------------------------------------------------- if not foundAction: logging.error("No action specified.") print("No action specified.") return -1 return 0 except KeyboardInterrupt: ### handle keyboard interrupt ### return 0 except Exception, e: indent = len(program_name) * " " sys.stderr.write(program_name + ": " + repr(e) + "\n") sys.stderr.write(indent + " for help use --help") return 2
def create_config(): config = ConfigParser.ConfigParser() # set some defaults, which may be overwritten config.add_section('network') config.set('network', 'listen_host', 'localhost') config.set('network', 'listen_port', '30303') config.set('network', 'num_peers', '5') config.set('network', 'remote_port', '30303') config.set('network', 'remote_host', '') config.set('network', 'client_id', 'Ethereum(py)/0.0.1') config.add_section('misc') config.set('misc', 'verbosity', '1') config.set('misc', 'config_file', None) config.set('misc', 'logging', None) config.add_section('wallet') # NODE_ID == pubkey, needed in order to work with Ethereum(++) config.set('wallet', 'pub_key', 'J\x02U\xfaFs\xfa\xa3\x0f\xc5\xab\xfd<U\x0b\xfd\xbc\r<\x97=5\xf7&F:\xf8\x1cT\xa02\x81\xcf\xff"\xc5\xf5\x96[8\xacc\x01R\x98wW\xa3\x17\x82G\x85I\xc3o|\x84\xcbD6\xbay\xd6\xd9') usage = "usage: %prog [options]" parser = OptionParser(usage=usage, version="%prog 0.1a") parser.add_option("-l", "--listen", dest="listen_port", default=config.get('network', 'listen_port'), help="<port> Listen on the given port for incoming connected (default: 30303)." ) parser.add_option("-r", "--remote", dest="remote_host", help="<host> Connect to remote host (try: 54.201.28.117 or 54.204.10.41)" ) parser.add_option("-p", "--port", dest="remote_port", default=config.get('network', 'remote_port'), help="<port> Connect to remote port (default: 30303)" ) parser.add_option("-v", "--verbose", dest="verbosity", default=config.get('misc', 'verbosity'), help="<0 - 3> Set the log verbosity from 0 to 3 (default: 1)") parser.add_option("-L", "--logging", dest="logging", default=config.get('misc', 'logging'), help="<logger1:LEVEL,logger2:LEVEL> set the console log level for logger1, logger2, etc.\ Empty loggername means root-logger, e.g. 'pyethereum.wire:DEBUG,:INFO'. Overrides '-v'") parser.add_option("-x", "--peers", dest="num_peers", default=config.get('network', 'num_peers'), help="<number> Attempt to connect to given number of peers (default: 5)") parser.add_option("-C", "--config", dest="config_file", help="read coniguration") (options, args) = parser.parse_args() # set network options for attr in ('listen_port', 'remote_host', 'remote_port', 'num_peers'): config.set('network', attr, getattr( options, attr) or config.get('network', attr)) # set misc options for attr in ('verbosity', 'config_file'): config.set( 'misc', attr, getattr(options, attr) or config.get('misc', attr)) if len(args) != 0: parser.error("wrong number of arguments") sys.exit(1) if config.get('misc', 'config_file'): config.read(config.get('misc', 'config_file')) #configure logging loggerlevels = getattr(options, 'logging') or '' configure_logging(loggerlevels, verbosity=config.getint('misc', 'verbosity')) return config
def updateStatusIniFile(): config = ConfigParser.RawConfigParser() config.add_section(STATUS_DATES_SECTION) config.set(STATUS_DATES_SECTION, START_DATE, eventDatetime) with open(STATUS_INI, 'wb') as configfile: config.write(configfile)
def configureProxy(args, proxyConfigPath): ''' Configure proxy configuration file from command line :param args: argparse arguments :param proxyConfigPath: Path to proxy.ini file :return: None ''' config = ConfigParser.RawConfigParser() config.read(os.path.join(path, "proxy.ini")) # Configure UNITx sections unit = 'UNIT' + str(args.unit) if args.unit is not 0: try: config.add_section(unit) except ConfigParser.DuplicateSectionError: pass if args.callsign is not None: config.set(unit, 'CALLSIGN', args.callsign) if args.nodeid is not None: config.set(unit, 'NODEID', args.nodeid) if args.port is not None: config.set(unit, 'COM', args.port) if args.baudrate: config.set(unit, 'BAUDRATE', args.baudrate) if args.timeout: config.set(unit, 'TIMEOUT', args.timeout) # Configure Proxy section items if args.number is not 0: config.set('PROXY', 'units', args.number) if args.log: config.set('PROXY', 'log', 1) else: config.set('PROXY', 'log', 0) if args.testmode: config.set('PROXY', 'testmode', 1) else: config.set('PROXY', 'testmode', 0) if args.testcallsign is not None: config.set('PROXY', 'testcallsign', args.testcallsign) if args.testnodeid is not None: config.set('PROXY', 'testnodeid', args.testnodeid) if args.testrate: config.set('PROXY', 'testrate', args.testrate) #Configure Proxy databases if args.database is not None: config.set('DATABASE', 'filename', args.database) if args.schema is not None: config.set('DATABASE', 'schemaname', args.schema) if args.testdatabase is not None: config.set('TESTDATABASE', 'filename', args.testdatabase) # Configure Proxy flask server if args.flaskhost is not None: config.set('FLASK', 'host', args.flaskhost) if args.flaskport is not None: config.set('FLASK', 'port', args.flaskport) with open(proxyConfigPath, 'wb') as configfile: config.write(configfile)
STATIC_DIR = os.path.join(PROJECT_DIR, 'static') CONFIG_FILE = os.path.join(PROJECT_DIR, 'config', 'config.ini') config = Config() config.read(CONFIG_FILE) DEBUG = config.get_boolean(APPLICATION_NAME, 'debug', False) LOGIN_URL = config.get_option(APPLICATION_NAME, 'login_url', '/login/') PORT = config.get_int(APPLICATION_NAME, 'port', 8000) if config.has_option(APPLICATION_NAME, 'cookie_secret'): COOKIE_SECRET = config.get(APPLICATION_NAME, 'cookie_secret') else: COOKIE_SECRET = base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes) if not config.has_section(APPLICATION_NAME): config.add_section(APPLICATION_NAME) config.set(APPLICATION_NAME, 'cookie_secret', COOKIE_SECRET) with open(CONFIG_FILE, 'wt') as cf: config.write(cf) LOGGING_CONFIG = { 'version': 1, 'disable_existing_loggers': True, 'formatters': { 'verbose': { 'format': '%(asctime)s - %(name)s - %(levelname)s - %(module)s - %(process)d - %(thread)d - %(message)s', 'datefmt': '%d/%m/%Y %Hh%Mm%Ss' }, 'simple': { 'format': '%(asctime)s - %(name)-12s - %(levelname)-8s - %(message)s', 'datefmt': '%d/%m/%Y %Hh%Mm%Ss'
def main(): InitConfig() config = GetConfig() config.add_section('DB') logging.config.fileConfig('logging.conf') for dbStem in DBs: config.set('DB','dbStem',dbStem) InitDB() db = GetDB() dbFile = db.GetDBFile() print '*** START : DB = %s ***' % (dbFile) print 'Records = %d' % (db.rowCount) tests = [ { 'desc' : 'Get count of all listings with a particular first name', 'N' : 1, 'spec' : { 'bus' : None, 'origin' : 0, 'destination' : 0, 'time' : 0, }, }, { 'desc' : 'Get count of all listings with a particular first name and last name', 'N' : 1, 'spec' : { 'bus' : None, 'origin' : None, 'destination' : 0, 'time' : 0, }, }, { 'desc' : 'Get count of all listings with a particular first name, last name, city, and state', 'N' : 1, 'spec' : { 'bus' : None, 'origin' : None, 'destination' : None, 'time' : None, }, }, { 'desc' : 'Get count of all listings with a particular first name and excluding 50 last names', 'N' : 1, 'spec' : { 'bus' : None, 'origin' : 1, 'destination' : 0, 'time' : 0, }, }, { 'desc' : 'Get count of all listings with a particular first name and excluding 50 last names, 50 cities, and 40 states', 'N' : 1, 'spec' : { 'bus' : None, 'origin' : 1, 'destination' : 1, 'time' : 1, }, }, { 'desc' : 'Get count of all listings with a particular first name and excluding 1 last name, 1 city, and 1 state', 'N' : 1, 'spec' : { 'bus' : None, 'origin' : 1, 'destination' : 1, 'time' : 1, }, }, ] for (i,test) in enumerate(tests): print '*** TEST %d : DB = %s ***' % (i,dbFile) print 'Description: %s' % (test['desc']) print 'Spec: %s' % (test['spec']) print 'N: %d' % (test['N']) (avRandTime,avQueryTime,longestQueryTime,avReturnedCallees) = db.RunTest(test['spec'],test['N']) print 'average randomTime = %f' % (avRandTime) print 'average queryTime = %f' % (avQueryTime) print 'longest queryTime = %f' % (longestQueryTime) print 'average returned callees = %f' % (avReturnedCallees) print '' KillDB()
def main(args=None): """Entry point for the Numina CLI.""" # Configuration args from a text file config = configparser.SafeConfigParser() # Building programatically config.add_section('numina') config.set('numina', 'format', 'yaml') # Custom values, site wide and local config.read(['.numina/numina.cfg', os.path.join(xdg_config_home, 'numina/numina.cfg')]) parser = argparse.ArgumentParser( description='Command line interface of Numina', prog='numina', epilog="For detailed help pass --help to a target" ) parser.add_argument( '-l', action="store", dest="logging", metavar="FILE", help="FILE with logging configuration" ) parser.add_argument( '-d', '--debug', action="store_true", dest="debug", default=False, help="make lots of noise" ) subparsers = parser.add_subparsers( title='Targets', description='These are valid commands you can ask numina to do.' ) # Init subcommands cmds = ['clishowins', 'clishowom', 'clishowrecip', 'clirun', 'clirunrec'] for cmd in cmds: cmd_mod = import_module('.'+cmd, 'numina.user') register = getattr(cmd_mod, 'register', None) if register is not None: register(subparsers) # Load plugin commands for entry in pkg_resources.iter_entry_points(group='numina_plugins'): reg_fun = entry.load() try: reg_fun(subparsers) except StandardError: # Error loading plugin pass args = parser.parse_args(args) # logger file if args.logging is not None: logging.config.fileConfig(args.logging) else: # This should be a default path in defaults.cfg try: args.logging = config.get('numina', 'logging') logging.config.fileConfig(args.logging) except configparser.Error: logging.config.dictConfig(numina_cli_logconf) _logger.info('Numina simple recipe runner version %s', __version__) args.command(args)
def read_or_create_config_file( path_to_configfile: Path) -> configparser.ConfigParser: """ Creates config file with default values or reads the current config file "config.ini". """ config = configparser.ConfigParser(allow_no_value=True) config.optionxform = str if not path_to_configfile.is_file(): config.add_section("Basics") config.set("Basics", "# Settings related to the playfield window") config.set("Basics", "columns", "10") config.set("Basics", "rows", "24") config.set("Basics", "fraction_of_vres", "30") config.set("Basics", "x_position", "26") config.set("Basics", "y_position", "3") config.set("Basics", "spawn_row", "3") config.set("Basics", "spawn_column", "4") config.add_section("Fonts") config.set("Fonts", "# Path to the fontfile") config.set("Fonts", "file", "fonts/codeman38_deluxefont/dlxfont.ttf") config.set("Fonts", "# Default font size") config.set("Fonts", "size_fraction_of_vres", "67.5") config.add_section("Game_window") config.set("Game_window", "# Game Window Title") config.set("Game_window", "title", "Pygtris") config.set("Game_window", "# Initial Game Window Position") config.set("Game_window", "horizontal", "0") config.set("Game_window", "vertical", "0") config.set("Game_window", "# Game Window Size") config.set("Game_window", "width", "1920") config.set("Game_window", "height", "1080") config.add_section("Technical") config.set("Technical", "# Framerate Limit") config.set("Technical", "framerate", "100") config.add_section("Graphics") config.set("Graphics", "folder", "img") config.set("Graphics", "empty_playfield_tile", "opaque_playfield_tile.png") config.add_section("Colors") config.set( "Colors", "# Color values need to be separated by comma and space \", \"") config.set("Colors", "game_window_background_color", "18, 18, 18, 255") config.set("Colors", "game_window_foreground_color", "245, 245, 245, 255") config.set("Colors", "font_color", "70, 70, 70, 255") with open(path_to_configfile, mode="w", encoding="utf-8") as configfh: config.write(configfh) config.read(path_to_configfile) return config
def create_config(): config = ConfigParser.ConfigParser() # set some defaults, which may be overwritten config.add_section('network') config.set('network', 'listen_host', '0.0.0.0') config.set('network', 'listen_port', '30303') config.set('network', 'num_peers', '5') config.set('network', 'remote_port', '30303') config.set('network', 'remote_host', '') config.set('network', 'client_id', Packeter.CLIENT_ID) config.set('network', 'node_id', sha3(str(uuid.uuid1())).encode('hex')) config.add_section('api') config.set('api', 'listen_host', '127.0.0.1') config.set('api', 'listen_port', '30203') config.add_section('misc') config.set('misc', 'verbosity', '1') config.set('misc', 'config_file', None) config.set('misc', 'logging', None) config.set('misc', 'data_dir', data_dir.path) config.set('misc', 'mining', '10') config.add_section('wallet') config.set('wallet', 'coinbase', '0' * 40) usage = "usage: %prog [options]" parser = OptionParser(usage=usage, version=Packeter.CLIENT_ID) parser.add_option( "-l", "--listen", dest="listen_port", default=config.get('network', 'listen_port'), help="<port> Listen on the given port for incoming" " connected (default: 30303).") parser.add_option( "-a", "--address", dest="coinbase", help="Set the coinbase (mining payout) address", default=config.get('wallet', 'coinbase')) parser.add_option( "-d", "--data_dir", dest="data_dir", help="<path> Load database from path (default: %s)" % config.get( 'misc', 'data_dir'), default=config.get('misc', 'data_dir')) parser.add_option( "-r", "--remote", dest="remote_host", help="<host> Connect to remote host" " (try: 54.201.28.117 or 54.204.10.41)") parser.add_option( "-p", "--port", dest="remote_port", default=config.get('network', 'remote_port'), help="<port> Connect to remote port (default: 30303)" ) parser.add_option( "-v", "--verbose", dest="verbosity", default=config.get('misc', 'verbosity'), help="<0 - 3> Set the log verbosity from 0 to 3 (default: 1)") parser.add_option( "-m", "--mining", dest="mining", default=config.get('misc', 'mining'), help="<0 - 100> Percent CPU used for mining 0==off (default: 10)") parser.add_option( "-L", "--logging", dest="logging", default=config.get('misc', 'logging'), help="<logger1:LEVEL,logger2:LEVEL> set the console log level for" " logger1, logger2, etc. Empty loggername means root-logger," " e.g. 'pyethereum.wire:DEBUG,:INFO'. Overrides '-v'") parser.add_option( "-x", "--peers", dest="num_peers", default=config.get('network', 'num_peers'), help="<number> Attempt to connect to given number of peers" "(default: 5)") parser.add_option("-C", "--config", dest="config_file", help="read coniguration") (options, args) = parser.parse_args() # set network options for attr in ('listen_port', 'remote_host', 'remote_port', 'num_peers'): config.set('network', attr, getattr( options, attr) or config.get('network', attr)) # set misc options for attr in ('verbosity', 'config_file', 'logging', 'data_dir', 'mining'): config.set( 'misc', attr, getattr(options, attr) or config.get('misc', attr)) # set wallet options for attr in ('coinbase',): config.set( 'wallet', attr, getattr(options, attr) or config.get('wallet', attr)) if len(args) != 0: parser.error("wrong number of arguments") sys.exit(1) if config.get('misc', 'config_file'): config.read(config.get('misc', 'config_file')) # set datadir if config.get('misc', 'data_dir'): data_dir.set(config.get('misc', 'data_dir')) # configure logging configure_logging( config.get('misc', 'logging') or '', verbosity=config.getint('misc', 'verbosity')) return config
configfilename = os.path.abspath(args.config) else: configfilename = 'oftg.cfg' config.read(configfilename) except ConfigParser.Error as e: logger.error('Error reading configuration file: %s' % (e.message)) quit() # Handle user account changes if args.user: user_update(args.user) quit() # Assure there are users configured if not config.has_section('users'): config.add_section('users') if len(config.items('users')) == 0: print 'To access OFTG-Ninja, you must first create a user...' username = str(raw_input('Username: '******'users')) == 0: quit(' ! No users defined in configuration') sys.path.append('classes/') # Process manager global manager