def load_rcfile(self): if os.path.exists(self.RCFILE): config = RawConfigParser() config.optionxform = lambda x: x.upper() config.read(self.RCFILE) items = [] if config.has_section('global'): items.extend(config.items('global')) if self.NAME is not None and config.has_section(self.NAME): items.extend(config.items(self.NAME)) for k,v in items: if k in CONFIG_TYPES and getattr(self,k) == DEFAULT_SETTINGS[k]: if CONFIG_TYPES[k] == 'str': setattr(self, k, v) elif CONFIG_TYPES[k] == 'int': setattr(self, k, int(v)) elif CONFIG_TYPES[k] == 'float': setattr(self, k, float(v)) elif CONFIG_TYPES[k] == 'list': setattr(self, k, [i.strip() for i in v.split(",")]) elif CONFIG_TYPES[k] == 'bool': if v.lower() in ('1', 'yes', 'true', 'on'): setattr(self, k, True) elif v.lower() in ('0', 'no', 'false', 'off'): setattr(self, k, False) else: raise ValueError("Not a boolean: %s" % v)
def settingsFromFile(infile, defaults): """Given a path string :attr:`infile`, load settings and return them as dictionary. Args: infile (str): a path to a file defaults (dict): a dictionary containing fallback values """ config = RawConfigParser() config.optionxform = lambda option: option try: with open(infile) as f: try: config.read_file(f) except MissingSectionHeaderError: config['General'] = defaults except OSError: config['General'] = defaults for key in defaults: if key not in config['General']: config['General'][key] = defaults[key] try: if int(config['General']['UpdateEvery']) <= 0: config['General']['UpdateEvery'] = defaults['UpdateEvery'] except ValueError: # can't convert to integer config['General']['UpdateEvery'] = defaults['UpdateEvery'] for value in ('SyncNewCourses', ): try: booleanvalue = config.getboolean('General', value) config['General'][value] = str(booleanvalue) except ValueError: # can't convert to boolean config['General'][value] = defaults[value] return dict(config['General'])
def run_generator(self, expect_error=False): '''Run sysv-generator. Fail if stderr contains any "Fail", unless expect_error is True. Return (stderr, filename -> ConfigParser) pair with ouput to stderr and parsed generated units. ''' env = os.environ.copy() env['SYSTEMD_LOG_LEVEL'] = 'debug' env['SYSTEMD_SYSVINIT_PATH'] = self.init_d_dir env['SYSTEMD_SYSVRCND_PATH'] = self.rcnd_dir env['SYSTEMD_UNIT_PATH'] = self.unit_dir gen = subprocess.Popen( [sysv_generator, 'ignored', 'ignored', self.out_dir], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, env=env) (out, err) = gen.communicate() if not expect_error: self.assertFalse('Fail' in err, err) self.assertEqual(gen.returncode, 0, err) results = {} for service in glob(self.out_dir + '/*.service'): if os.path.islink(service): continue cp = RawConfigParser() cp.optionxform = lambda o: o # don't lower-case option names with open(service) as f: cp.readfp(f) results[os.path.basename(service)] = cp return (err, results)
def read_config(self, config): result = [] stack = [config] while 1: config = stack.pop() src = None if isinstance(config, (str, unicode)): src = os.path.relpath(config) _config = RawConfigParser() _config.optionxform = lambda s: s if getattr(config, 'read', None) is not None: _config.readfp(config) path = self.path else: if not os.path.exists(config): log.error("Config file '%s' doesn't exist.", config) sys.exit(1) _config.read(config) path = os.path.dirname(config) for section in reversed(_config.sections()): for key, value in reversed(_config.items(section)): result.append((src, path, section, key, value)) result.append((src, path, section, None, None)) if _config.has_option('global', 'extends'): extends = _config.get('global', 'extends').split() elif _config.has_option('global:global', 'extends'): extends = _config.get('global:global', 'extends').split() else: break stack[0:0] = [ os.path.abspath(os.path.join(path, x)) for x in reversed(extends)] return reversed(result)
def load_rcfile(self): self.process_args() if self.RCFILE == parser.get_default('RCFILE') and \ not os.path.exists(self.RCFILE) and os.path.exists(OLD_RCFILE): logger.warning("Using old rcfile found at %s, " "please rename to %s.", OLD_RCFILE, self.RCFILE) self.RCFILE = OLD_RCFILE if os.path.exists(self.RCFILE): config = RawConfigParser() config.optionxform = lambda x: x.upper() config.read(self.RCFILE) items = [] if config.has_section('global'): items.extend(config.items('global')) if self.NAME is not None and config.has_section(self.NAME): items.extend(config.items(self.NAME)) try: return self.parse_rcvalues(items) except (ValueError, argparse.ArgumentTypeError) as e: raise RuntimeError("Unable to parse RC values: %s" % e) return {}
def populate_config_dict(config_path): """Load the configuration file into the config_file dictionary A ConfigParser-style configuration file can have multiple sections, but we ignore the section distinction and load the key/value pairs from all sections into a single key/value list. """ try: config_dict = {} parser = RawConfigParser() parser.optionxform = lambda x: x parser.read(config_path) sections = parser.sections() for section in sections: options = parser.options(section) for option in options: config_dict[option] = str(parser.get(section, option)) except Exception as e: logger.warning("Could not load configuration file due to exception. " "Only environment variable equivalents will be used.") return None for key in config_dict.keys(): if config_dict[key] == '': config_dict[key] = None elif isinstance(config_dict[key], str): config_dict[key] = os.path.expanduser(config_dict[key]) return config_dict
def save(self): """Save configuration to file.""" parser = RawConfigParser() parser.optionxform = str parser.read_dict({'Options': self._configs}) with open(os.path.join(app_config_dir, 'config'), 'w', encoding='utf-8') as f: parser.write(f)
def create_spawn_config(self, subsystem_config): """Create config instance """ section_name = self.defaults['pki_subsystem'] cfgtpl, immutable_keys = self._get_default_config() # overwrite CA/KRA config with subsystem settings subsystem_config = self._mangle_values(subsystem_config) for key, value in subsystem_config.items(): cfgtpl.set(section_name, key, value) # get a mapping of settings that cannot be modified by users immutable_settings = { k: v for k, v in cfgtpl.items(section_name) if k in immutable_keys } # add ipaca_customize overlay, # These are settings that can be modified by a user, too. We use # ipaca_customize.ini to set sensible defaults. with open(self.ipaca_customize) as f: cfgtpl.read_file(f) # load external overlay from command line if self.pki_config_override is not None: with open(self.pki_config_override) as f: cfgtpl.read_file(f) # verify again self._verify_immutable( cfgtpl, immutable_settings, self.pki_config_override ) # key backup is not compatible with HSM support if (cfgtpl.has_option(section_name, 'pki_hsm_enable') and cfgtpl.getboolean(section_name, 'pki_hsm_enable')): cfgtpl.set(section_name, 'pki_backup_keys', 'False') cfgtpl.set(section_name, 'pki_backup_password', '') pki_token_name = cfgtpl.get(section_name, 'pki_token_name') for stanza in self.token_stanzas: if cfgtpl.has_option(section_name, stanza): cfgtpl.set(section_name, stanza, pki_token_name) # Next up, get rid of interpolation variables, DEFAULT, # irrelevant sections and unused variables. Only the subsystem # section is copied into a new raw config parser. A raw config # parser is necessary, because ConfigParser.write() write passwords # with '%' in a way, that is not accepted by Dogtag. config = RawConfigParser() config.optionxform = str config.add_section(section_name) for key, value in sorted(cfgtpl.items(section=section_name)): if key.startswith('pki_'): config.set(section_name, key, value) return config
def get_setting(section, key): settings_config_file_path_rel = Path('diff1c.ini') if not settings_config_file_path_rel.exists(): settings_config_file_path_rel = Path.home() / settings_config_file_path_rel if not settings_config_file_path_rel.exists(): raise Exception('Файл настроек не существует!') config = RawConfigParser() config.optionxform = lambda option: option config.read(str(settings_config_file_path_rel), 'utf-8') return config[section][key] # fixme
def read_ini(ini): """Load an ini file or string into a dictionary.""" if isinstance(ini,dict): return ini if isinstance(ini,str): if os.path.exists(ini): ini = open(ini).read() config = RawConfigParser() config.optionxform=str config.readfp(StringIO(u'[root]\n'+ini)) return dict(config.items('root')) else: raise ValueError('Unexpected type for ini file %s'%type(ini))
def default_settings_file(tmpdir): conf = RawConfigParser() conf.optionxform = lambda option: option conf['General'] = { 'UpdateEvery': '60', 'RootFolder': 'root', 'SyncNewCourses': 'False' } f = tmpdir.mkdir('fold').join('sets.ini') with open(str(f), 'w') as setsfile: conf.write(setsfile) return str(f)
def settingsToFile(insettings, filepath): """Given a dict, save to file in the format specified by configparser""" config = RawConfigParser() config.optionxform = lambda option: option config['General'] = insettings try: dirpath = os.path.dirname(filepath) os.makedirs(dirpath, exist_ok=True) with open(filepath, 'w') as f: config.write(f) except OSError: if not os.path.isdir(dirpath): raise
def load_rcfile(self): if os.path.exists(self.RCFILE): config = RawConfigParser() config.optionxform = lambda x: x.upper() config.read(self.RCFILE) items = [] if config.has_section('global'): items.extend(config.items('global')) if self.NAME is not None and config.has_section(self.NAME): items.extend(config.items(self.NAME)) self.load_rcvalues(items) self.update_implications()
def __init__(self, monolithe_config, api_info): """ Initializes a _JavaSDKAPIVersionFileWriter """ super(APIVersionWriter, self).__init__(package="monolithe.generators.lang.java") self.api_version = api_info["version"] self._api_version_string = SDKUtils.get_string_version(self.api_version) self.api_root = api_info["root"] self.api_prefix = api_info["prefix"] self.monolithe_config = monolithe_config self._output = self.monolithe_config.get_option("output", "transformer") self._name = self.monolithe_config.get_option("name", "transformer") self._class_prefix = "" self._product_accronym = self.monolithe_config.get_option("product_accronym") self._product_name = self.monolithe_config.get_option("product_name") self._url = self.monolithe_config.get_option("url", "transformer") self._package_prefix = self._get_package_prefix(self._url) self._package_name = self._package_prefix + '.' + self._name + '.' + SDKUtils.get_string_version(self.api_version) self._package_subdir = self._package_name.replace('.', '/') self._base_output_directory = "%s/java" % (self._output) self.output_directory = "%s/src/main/java/%s" % (self._base_output_directory, self._package_subdir) self.override_folder = os.path.normpath("%s/__overrides" % self._base_output_directory) self.fetchers_path = "/fetchers/" self.attrs_defaults = RawConfigParser() path = "%s/java/__attributes_defaults/attrs_defaults.ini" % self._output self.attrs_defaults.optionxform = str self.attrs_defaults.read(path) self.attrs_types = RawConfigParser() path = "%s/java/__attributes_defaults/attrs_types.ini" % self._output self.attrs_types.optionxform = str self.attrs_types.read(path) library_info = RawConfigParser() path = "%s/java/__attributes_defaults/library.ini" % self._output library_info.optionxform = str library_info.read(path) self.library_version = library_info.get(self.api_version, "libraryVersion") with open("%s/java/__code_header" % self._output, "r") as f: self.header_content = f.read()
def load_config(configuration_id, seen=None, **overrides): # flake8: noqa if seen is None: seen = [] if configuration_id in seen: raise ValueError( 'Recursive configuration extends: %s (%r)' % (configuration_id, seen)) seen.append(configuration_id) if ':' in configuration_id: configuration_file = resolvePackageReference(configuration_id) else: config_info = configuration_registry.getConfiguration(configuration_id) configuration_file = config_info['configuration'] parser = RawConfigParser() parser.optionxform = str # case sensitive parser.readfp(open(configuration_file)) result = {} includes = None for section in parser.sections(): result[section] = dict(parser.items(section)) if section == 'transmogrifier': includes = result[section].pop('include', includes) if includes: for configuration_id in includes.split()[::-1]: include = load_config(configuration_id, seen) sections = set(include.keys()) | set(result.keys()) for section in sections: result[section] = update_section( result.get(section, {}), include.get(section, {})) seen.pop() for section, options in iteritems(overrides): assert section in result, \ 'Overrides include non-existing section {0:s}'.format(section) for key, value in iteritems(options): assert key in result[section], \ 'Overrides include non-existing key {0:s}:{1:s}'.format( section, key) result[section][key] = value return result
def test_savefileexists(tmpdir, default_settings_dict): f = tmpdir.mkdir('fold').join('sets.ini') conf = RawConfigParser() conf.optionxform = lambda option: option conf['General'] = { 'UpdateEvery': '30', 'RootFolder': 'anotherroot', 'SyncNewCourses': 'False' } with open(str(f), 'w') as setsfile: conf.write(setsfile) newsettings = { 'UpdateEvery': '20', 'RootFolder': 'finalroot', 'SyncNewCourses': 'True' } settingsToFile(newsettings, str(f)) assert settingsFromFile(str(f), default_settings_dict) == newsettings
def test_somepresent_allinvalid(tmpdir, default_settings_dict): """Not all values present, all are invalid, file accessible""" conf = RawConfigParser() conf.optionxform = lambda option: option conf['General'] = { 'UpdateEvery': 'noatanumer', 'SyncNewCourses': 'False' } f = tmpdir.mkdir('fold').join('sets.ini') with open(str(f), 'w') as setsfile: conf.write(setsfile) sets = settingsFromFile(str(f), default_settings_dict) nice = { 'UpdateEvery': '60', 'RootFolder': 'root', 'SyncNewCourses': 'False' } assert sets == nice
def test_notallvaluesarepresent(tmpdir, default_settings_dict): """Not all values are present; all are valid, file is accessible""" conf = RawConfigParser() conf.optionxform = lambda option: option conf['General'] = { 'UpdateEvery': '50', 'RootFolder': 'custom', } f = tmpdir.mkdir('fold').join('sets.ini') with open(str(f), 'w') as setsfile: conf.write(setsfile) sets = settingsFromFile(str(f), default_settings_dict) merge = { 'UpdateEvery': '50', 'RootFolder': 'custom', 'SyncNewCourses': 'False' } assert sets == merge
def save_entries(fp, entries): parser = RawConfigParser() parser.optionxform = str parser.add_section(PERSISTENT_SECTION) for name, value in entries: if not value: continue t = value.type v = value.value if t == NT_BOOLEAN: name = 'boolean "%s"' % _escape_string(name) vrepr = "true" if v else "false" elif t == NT_DOUBLE: name = 'double "%s"' % _escape_string(name) vrepr = str(v) elif t == NT_STRING: name = 'string "%s"' % _escape_string(name) vrepr = '"%s"' % _escape_string(v) elif t == NT_RAW: name = 'raw "%s"' % _escape_string(name) vrepr = base64.b64encode(v).decode("ascii") elif t == NT_BOOLEAN_ARRAY: name = 'array boolean "%s"' % _escape_string(name) vrepr = ",".join(["true" if vv else "false" for vv in v]) elif t == NT_DOUBLE_ARRAY: name = 'array double "%s"' % _escape_string(name) vrepr = ",".join([str(vv) for vv in v]) elif t == NT_STRING_ARRAY: name = 'array string "%s"' % _escape_string(name) vrepr = '","'.join([_escape_string(vv) for vv in v]) if vrepr: vrepr = '"%s"' % vrepr else: continue parser.set(PERSISTENT_SECTION, name, vrepr) parser.write(fp, space_around_delimiters=False)
def load_rcfile(self): if self.RCFILE == DEFAULT_SETTINGS['RCFILE'] and \ not os.path.exists(self.RCFILE) and os.path.exists(OLD_RCFILE): sys.stderr.write("Warning: Old rcfile found at %s, please rename to %s.\n" \ % (OLD_RCFILE, self.RCFILE)) self.RCFILE = OLD_RCFILE if os.path.exists(self.RCFILE): config = RawConfigParser() config.optionxform = lambda x: x.upper() config.read(self.RCFILE) items = [] if config.has_section('global'): items.extend(config.items('global')) if self.NAME is not None and config.has_section(self.NAME): items.extend(config.items(self.NAME)) self.load_rcvalues(items) self.update_implications()
def read(self, filenames, impl=FITS, implementation=DATAIMPL, encoding=None): """ Read filename or a list of filenames and parse configuration entries. Files that cannot be opened are silently ignored; this is designed so that you can specify a list of potential configuration file locations (e.g. current directory, user's home directory, system wide directory), and all existing configuration files in the list will be read. A single filename may also be given. Parameters: ----------- filename: str Full path name or list of full path name containing configuration entries to parse impl: str , optional FITS -> use Fits format INI -> use windows style ini format implementation: str , optional DATAIMPL -> Use Fits data table HEADERIMP -> Use fits header Returns ------- list of successfully read files. """ if impl == self.INI: config_parser = RawConfigParser() config_parser.optionxform = lambda option: option success_list = config_parser.read(filenames, encoding) self._addOptionFromParser(config_parser) return success_list elif impl == self.FITS: return self._read_fits(filenames, implementation, encoding) else: print("Format:", impl, 'not allowed', file=sys.stderr) return list()
def run_generator(self, expect_error=False): '''Run sysv-generator. Fail if stderr contains any "Fail", unless expect_error is True. Return (stderr, filename -> ConfigParser) pair with ouput to stderr and parsed generated units. ''' env = os.environ.copy() env['SYSTEMD_LOG_LEVEL'] = 'debug' env['SYSTEMD_LOG_TARGET'] = 'console' env['SYSTEMD_SYSVINIT_PATH'] = self.init_d_dir env['SYSTEMD_SYSVRCND_PATH'] = self.rcnd_dir env['SYSTEMD_UNIT_PATH'] = self.unit_dir gen = subprocess.Popen( [sysv_generator, 'ignored', 'ignored', self.out_dir], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, env=env) (out, err) = gen.communicate() if not expect_error: self.assertFalse('Fail' in err, err) self.assertEqual(gen.returncode, 0, err) results = {} for service in glob(self.out_dir + '/*.service'): if os.path.islink(service): continue try: # for python3 we need here strict=False to parse multiple # lines with the same key cp = RawConfigParser(dict_type=MultiDict, strict=False) except TypeError: # RawConfigParser in python2 does not have the strict option # but it allows multiple lines with the same key by default cp = RawConfigParser(dict_type=MultiDict) cp.optionxform = lambda o: o # don't lower-case option names with open(service) as f: cp.readfp(f) results[os.path.basename(service)] = cp return (err, results)
def load_rcfile(self): self.process_args() if self.RCFILE == parser.get_default('RCFILE') and \ not os.path.exists(self.RCFILE) and os.path.exists(OLD_RCFILE): sys.stderr.write("Warning: Using old rcfile found at %s, " "please rename to %s.\n" % (OLD_RCFILE, self.RCFILE)) self.RCFILE = OLD_RCFILE if os.path.exists(self.RCFILE): config = RawConfigParser() config.optionxform = lambda x: x.upper() config.read(self.RCFILE) items = [] if config.has_section('global'): items.extend(config.items('global')) if self.NAME is not None and config.has_section(self.NAME): items.extend(config.items(self.NAME)) return self.parse_rcvalues(items) return {}
def get_overrides(arguments): overrides = {} overrides_path = arguments.get('--overrides') if overrides_path and not os.path.isabs(overrides_path): overrides_path = os.path.join(os.getcwd(), overrides_path) if overrides_path: parser = RawConfigParser() parser.optionxform = str # case sensitive with open(overrides_path) as fp: parser.readfp(fp) overrides.update(dict(((section, dict(parser.items(section))) for section in parser.sections()))) for candidate in arguments.get('<pipelines_and_overrides>'): try: section, name, value = parse_override(candidate) except ValueError: continue overrides.setdefault(section, {}) overrides[section][name] = value return overrides
def load(self): """Load configurations from file.""" parser = RawConfigParser() parser.optionxform = str parser.read(os.path.join(app_config_dir, 'config')) if parser.has_option('Options', 'autostart'): self.autostart = parser.getboolean('Options', 'autostart') if parser.has_option('Options', 'refreshtime'): self.refreshtime = parser.getint('Options', 'refreshtime') if parser.has_option('Options', 'stoptimer'): self.stoptimer = parser.getboolean('Options', 'stoptimer') if parser.has_option('Options', 'items_per_feed'): self.items_per_feed = parser.getint('Options', 'items_per_feed') if parser.has_option('Options', 'show_notifications'): self.show_notifications = parser.getboolean('Options', 'show_notifications') if parser.has_option('Options', 'show_update_notifications'): self.show_update_notifications = parser. \ getboolean('Options', 'show_update_notifications') if parser.has_option('Options', 'feeds_at_top'): self.feeds_at_top = parser.getboolean('Options', 'feeds_at_top') if parser.has_option('Options', 'show_unread_feeds'): self.show_unread_feeds = parser.getboolean('Options', 'show_unread_feeds')
def main(original_args=None): positionals, args = split_args_in_optional_and_positional( sys.argv[1:] if original_args is None else original_args) if len(positionals[1:]) > 2: warnings.warn( "Giving multiple files on the command line will be deprecated, please use [bumpversion:file:...] in a config file.", PendingDeprecationWarning) parser1 = argparse.ArgumentParser(add_help=False) parser1.add_argument('--verbose', action='count', default=0, help='Print verbose logging to stderr', required=False) parser1.add_argument('--list', action='store_true', default=False, help='List machine readable information', required=False) known_args, remaining_argv = parser1.parse_known_args(args) logformatter = logging.Formatter('%(message)s') if len(logger.handlers) == 0: ch = logging.StreamHandler(sys.stderr) ch.setFormatter(logformatter) logger.addHandler(ch) if len(logger_list.handlers) == 0: ch2 = logging.StreamHandler(sys.stdout) ch2.setFormatter(logformatter) logger_list.addHandler(ch2) if known_args.list: logger_list.setLevel(1) log_level = { 0: logging.WARNING, 1: logging.INFO, 2: logging.DEBUG, }.get(known_args.verbose, logging.DEBUG) logger.setLevel(log_level) logger.debug("Starting {}".format(DESCRIPTION)) defaults = {} vcs_info = {} config = RawConfigParser('') # don't transform keys to lowercase (which would be the default) config.optionxform = lambda option: option config.add_section('bumpversion') # We need setup.py to get the major, minor versions ver_sources = ['setup.py', 'plugin.json', 'VERSION'] ver_source = ver_file_check(ver_sources) if ver_source is None: message = "Could not read any of {} file".format(str(ver_sources)) logger.error(message) sys.exit(2) # We don't work with other configuration files except .bumpversion.cfg config_file = '.bumpversion.cfg' if not os.path.exists(config_file): message = "Could not read {} file".format(config_file) logger.error(message) sys.exit(2) part_configs = {} files = [] logger.info("Reading config file {}:".format(config_file)) logger.info(io.open(config_file, 'rt', encoding='utf-8').read()) config.readfp(io.open(config_file, 'rt', encoding='utf-8')) log_config = StringIO() config.write(log_config) if 'files' in dict(config.items("bumpversion")): warnings.warn( "'files =' configuration is will be deprecated, please use [bumpversion:file:...]", PendingDeprecationWarning) defaults.update(dict(config.items("bumpversion"))) for listvaluename in ("serialize", ): try: value = config.get("bumpversion", listvaluename) defaults[listvaluename] = list( filter(None, (x.strip() for x in value.splitlines()))) except NoOptionError: pass # no default value then ;) for boolvaluename in "dry_run": try: defaults[boolvaluename] = config.getboolean( "bumpversion", boolvaluename) except NoOptionError: pass # no default value then ;) for section_name in config.sections(): section_name_match = re.compile("^bumpversion:(file|part):(.+)").match( section_name) if not section_name_match: continue section_prefix, section_value = section_name_match.groups() section_config = dict(config.items(section_name)) if section_prefix == "part": ThisVersionPartConfiguration = NumericVersionPartConfiguration if 'values' in section_config: section_config['values'] = list( filter(None, (x.strip() for x in section_config['values'].splitlines()))) ThisVersionPartConfiguration = ConfiguredVersionPartConfiguration part_configs[section_value] = ThisVersionPartConfiguration( **section_config) elif section_prefix == "file": filename = section_value if 'serialize' in section_config: section_config['serialize'] = list( filter( None, (x.strip() for x in section_config['serialize'].splitlines()))) section_config['part_configs'] = part_configs if not 'parse' in section_config: section_config['parse'] = defaults.get( "parse", '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)') if not 'serialize' in section_config: section_config['serialize'] = defaults.get( 'serialize', [str('{major}.{minor}.{patch}')]) if not 'search' in section_config: section_config['search'] = defaults.get( "search", '{current_version}') if not 'replace' in section_config: section_config['replace'] = defaults.get( "replace", '{new_version}') files.append( ConfiguredFile(filename, VersionConfig(**section_config))) parser2 = argparse.ArgumentParser(prog='bumpversion', add_help=False, parents=[parser1]) parser2.set_defaults(**defaults) parser2.add_argument('--parse', metavar='REGEX', help='Regex parsing the version string', default=defaults.get( "parse", '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)')) parser2.add_argument('--serialize', metavar='FORMAT', action=DiscardDefaultIfSpecifiedAppendAction, help='How to format what is parsed back to a version', default=defaults.get( "serialize", [str('{major}.{minor}.{patch}')])) parser2.add_argument('--search', metavar='SEARCH', help='Template for complete string to search', default=defaults.get("search", '{current_version}')) parser2.add_argument('--replace', metavar='REPLACE', help='Template for complete string to replace', default=defaults.get("replace", '{new_version}')) known_args, remaining_argv = parser2.parse_known_args(args) defaults.update(vars(known_args)) assert type(known_args.serialize) == list context = dict( list(time_context.items()) + list(prefixed_environ().items()) + list(vcs_info.items())) try: vc = VersionConfig( parse=known_args.parse, serialize=known_args.serialize, search=known_args.search, replace=known_args.replace, part_configs=part_configs, ) except sre_constants.error as e: sys.exit(1) current_version = vc.parse( known_args.current_version) if known_args.current_version else None leave_config_ver = True new_version = None if len(positionals) > 0: setup_version, zero_patch_setup_version = ConfiguredFile( ver_source, vc).find(positionals[0]) compare = setup_version.compare(vc.order(), current_version) for part in compare: if part == positionals[0]: continue else: leave_config_ver = leave_config_ver and compare[part] try: if leave_config_ver and current_version: logger.info("Attempting to increment part '{}'".format( positionals[0])) new_version = current_version.bump(positionals[0], vc.order()) logger.info("Values are now: " + keyvaluestring(new_version._values)) defaults['new_version'] = vc.serialize(new_version, context) elif not leave_config_ver: logger.info("Using Version from {}".format(ver_source)) defaults['new_version'] = vc.serialize( zero_patch_setup_version, context) new_version = zero_patch_setup_version logger.info("Values are now: " + keyvaluestring(setup_version._values)) except MissingValueForSerializationException as e: logger.info("Opportunistic finding of new_version failed: " + e.message) except IncompleteVersionRepresenationException as e: logger.info("Opportunistic finding of new_version failed: " + e.message) except KeyError as e: logger.info("Opportunistic finding of new_version failed") parser3 = argparse.ArgumentParser( prog='bumpversion', description=DESCRIPTION, formatter_class=argparse.ArgumentDefaultsHelpFormatter, conflict_handler='resolve', parents=[parser2], ) parser3.set_defaults(**defaults) parser3.add_argument('--dry-run', '-n', action='store_true', default=False, help="Don't write any files, just pretend.") file_names = [] if 'files' in defaults: assert defaults['files'] != None file_names = defaults['files'].split(' ') parser3.add_argument('part', help='Part of the version to be bumped.') parser3.add_argument('files', metavar='file', nargs='*', help='Files to change', default=file_names) args = parser3.parse_args(remaining_argv + positionals) if args.dry_run: logger.info("Dry run active, won't touch any files.") # make sure files exist and contain version string # if leave_config_ver and new_version: logger.info("Update info in {}".format(ver_source)) ConfiguredFile(ver_source, vc).replace(setup_version, new_version, context, args.dry_run) config.set('bumpversion', 'new_version', args.new_version) for key, value in config.items('bumpversion'): logger_list.info("{}={}".format(key, value)) config.remove_option('bumpversion', 'new_version') config.set('bumpversion', 'current_version', args.new_version) new_config = StringIO() try: write_to_config_file = not args.dry_run logger.info("{} to config file {}:".format( "Would write" if not write_to_config_file else "Writing", config_file, )) config.write(new_config) logger.info(new_config.getvalue()) if write_to_config_file: with io.open(config_file, 'wb') as f: f.write(new_config.getvalue().encode('utf-8')) except UnicodeEncodeError: warnings.warn( "Unable to write UTF-8 to config file, because of an old configparser version. " "Update with `pip install --upgrade configparser`.")
def load_config(file="setup.cfg"): config = RawConfigParser() config.optionxform = lambda x: x.lower().replace("_", "-") config.read(file) return config
def main(original_args=None): positionals, args = split_args_in_optional_and_positional( sys.argv[1:] if original_args is None else original_args) if len(positionals[1:]) > 2: warnings.warn( "Giving multiple files on the command line will be deprecated, please use [bumpversion:file:...] in a config file.", PendingDeprecationWarning) parser1 = argparse.ArgumentParser(add_help=False) parser1.add_argument( '--config-file', metavar='FILE', default=argparse.SUPPRESS, required=False, help= 'Config file to read most of the variables from (default: .bumpversion.cfg)' ) parser1.add_argument('--verbose', action='count', default=0, help='Print verbose logging to stderr', required=False) parser1.add_argument('--list', action='store_true', default=False, help='List machine readable information', required=False) parser1.add_argument('--allow-dirty', action='store_true', default=False, help="Don't abort if working directory is dirty", required=False) known_args, remaining_argv = parser1.parse_known_args(args) logformatter = logging.Formatter('%(message)s') if len(logger.handlers) == 0: ch = logging.StreamHandler(sys.stderr) ch.setFormatter(logformatter) logger.addHandler(ch) if len(logger_list.handlers) == 0: ch2 = logging.StreamHandler(sys.stdout) ch2.setFormatter(logformatter) logger_list.addHandler(ch2) if known_args.list: logger_list.setLevel(1) log_level = { 0: logging.WARNING, 1: logging.INFO, 2: logging.DEBUG, }.get(known_args.verbose, logging.DEBUG) logger.setLevel(log_level) logger.debug("Starting {}".format(DESCRIPTION)) defaults = {} vcs_info = {} for vcs in VCS: if vcs.is_usable(): vcs_info.update(vcs.latest_tag_info()) if 'current_version' in vcs_info: defaults['current_version'] = vcs_info['current_version'] config = RawConfigParser('') # don't transform keys to lowercase (which would be the default) config.optionxform = lambda option: option config.add_section('bumpversion') explicit_config = hasattr(known_args, 'config_file') if explicit_config: config_file = known_args.config_file elif not os.path.exists('.bumpversion.cfg') and \ os.path.exists('setup.cfg'): config_file = 'setup.cfg' else: config_file = '.bumpversion.cfg' config_file_exists = os.path.exists(config_file) part_configs = {} files = [] if config_file_exists: logger.info("Reading config file {}:".format(config_file)) logger.info(io.open(config_file, 'rt', encoding='utf-8').read()) config.readfp(io.open(config_file, 'rt', encoding='utf-8')) log_config = StringIO() config.write(log_config) if 'files' in dict(config.items("bumpversion")): warnings.warn( "'files =' configuration is will be deprecated, please use [bumpversion:file:...]", PendingDeprecationWarning) defaults.update(dict(config.items("bumpversion"))) for listvaluename in ("serialize", ): try: value = config.get("bumpversion", listvaluename) defaults[listvaluename] = list( filter(None, (x.strip() for x in value.splitlines()))) except NoOptionError: pass # no default value then ;) for boolvaluename in ("commit", "tag", "dry_run"): try: defaults[boolvaluename] = config.getboolean( "bumpversion", boolvaluename) except NoOptionError: pass # no default value then ;) for section_name in config.sections(): section_name_match = re.compile( "^bumpversion:(file|part):(.+)").match(section_name) if not section_name_match: continue section_prefix, section_value = section_name_match.groups() section_config = dict(config.items(section_name)) if section_prefix == "part": ThisVersionPartConfiguration = NumericVersionPartConfiguration if 'values' in section_config: section_config['values'] = list( filter( None, (x.strip() for x in section_config['values'].splitlines()))) ThisVersionPartConfiguration = ConfiguredVersionPartConfiguration part_configs[section_value] = ThisVersionPartConfiguration( **section_config) elif section_prefix == "file": filename = section_value if 'serialize' in section_config: section_config['serialize'] = list( filter( None, (x.strip() for x in section_config['serialize'].splitlines() ))) section_config['part_configs'] = part_configs if not 'parse' in section_config: section_config['parse'] = defaults.get( "parse", '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)') if not 'serialize' in section_config: section_config['serialize'] = defaults.get( 'serialize', [str('{major}.{minor}.{patch}')]) if not 'search' in section_config: section_config['search'] = defaults.get( "search", '{current_version}') if not 'replace' in section_config: section_config['replace'] = defaults.get( "replace", '{new_version}') files.append( ConfiguredFile(filename, VersionConfig(**section_config))) else: message = "Could not read config file at {}".format(config_file) if explicit_config: raise argparse.ArgumentTypeError(message) else: logger.info(message) parser2 = argparse.ArgumentParser(prog='bumpversion', add_help=False, parents=[parser1]) parser2.set_defaults(**defaults) parser2.add_argument('--current-version', metavar='VERSION', help='Version that needs to be updated', required=False) parser2.add_argument('--parse', metavar='REGEX', help='Regex parsing the version string', default=defaults.get( "parse", '(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)')) parser2.add_argument('--serialize', metavar='FORMAT', action=DiscardDefaultIfSpecifiedAppendAction, help='How to format what is parsed back to a version', default=defaults.get( "serialize", [str('{major}.{minor}.{patch}')])) parser2.add_argument('--search', metavar='SEARCH', help='Template for complete string to search', default=defaults.get("search", '{current_version}')) parser2.add_argument('--replace', metavar='REPLACE', help='Template for complete string to replace', default=defaults.get("replace", '{new_version}')) known_args, remaining_argv = parser2.parse_known_args(args) defaults.update(vars(known_args)) assert type(known_args.serialize) == list context = dict( list(time_context.items()) + list(prefixed_environ().items()) + list(vcs_info.items())) try: vc = VersionConfig( parse=known_args.parse, serialize=known_args.serialize, search=known_args.search, replace=known_args.replace, part_configs=part_configs, ) except sre_constants.error as e: sys.exit(1) current_version = vc.parse( known_args.current_version) if known_args.current_version else None new_version = None if not 'new_version' in defaults and known_args.current_version: try: if current_version and len(positionals) > 0: logger.info("Attempting to increment part '{}'".format( positionals[0])) new_version = current_version.bump(positionals[0], vc.order()) logger.info("Values are now: " + keyvaluestring(new_version._values)) defaults['new_version'] = vc.serialize(new_version, context) except MissingValueForSerializationException as e: logger.info("Opportunistic finding of new_version failed: " + e.message) except IncompleteVersionRepresenationException as e: logger.info("Opportunistic finding of new_version failed: " + e.message) except KeyError as e: logger.info("Opportunistic finding of new_version failed") parser3 = argparse.ArgumentParser( prog='bumpversion', description=DESCRIPTION, formatter_class=argparse.ArgumentDefaultsHelpFormatter, conflict_handler='resolve', parents=[parser2], ) parser3.set_defaults(**defaults) parser3.add_argument('--current-version', metavar='VERSION', help='Version that needs to be updated', required=not 'current_version' in defaults) parser3.add_argument('--dry-run', '-n', action='store_true', default=False, help="Don't write any files, just pretend.") parser3.add_argument('--new-version', metavar='VERSION', help='New version that should be in the files', required=not 'new_version' in defaults) commitgroup = parser3.add_mutually_exclusive_group() commitgroup.add_argument('--commit', action='store_true', dest="commit", help='Commit to version control', default=defaults.get("commit", False)) commitgroup.add_argument('--no-commit', action='store_false', dest="commit", help='Do not commit to version control', default=argparse.SUPPRESS) taggroup = parser3.add_mutually_exclusive_group() taggroup.add_argument('--tag', action='store_true', dest="tag", default=defaults.get("tag", False), help='Create a tag in version control') taggroup.add_argument('--no-tag', action='store_false', dest="tag", help='Do not create a tag in version control', default=argparse.SUPPRESS) signtagsgroup = parser3.add_mutually_exclusive_group() signtagsgroup.add_argument('--sign-tags', action='store_true', dest="sign_tags", help='Sign tags if created', default=defaults.get("sign_tags", False)) signtagsgroup.add_argument('--no-sign-tags', action='store_false', dest="sign_tags", help='Do not sign tags if created', default=argparse.SUPPRESS) parser3.add_argument('--tag-name', metavar='TAG_NAME', help='Tag name (only works with --tag)', default=defaults.get('tag_name', 'v{new_version}')) parser3.add_argument( '--tag-message', metavar='TAG_MESSAGE', dest='tag_message', help='Tag message', default=defaults.get( 'tag_message', 'Bump version: {current_version} → {new_version}')) parser3.add_argument( '--message', '-m', metavar='COMMIT_MSG', help='Commit message', default=defaults.get( 'message', 'Bump version: {current_version} → {new_version}')) file_names = [] if 'files' in defaults: assert defaults['files'] != None file_names = defaults['files'].split(' ') parser3.add_argument('part', help='Part of the version to be bumped.') parser3.add_argument('files', metavar='file', nargs='*', help='Files to change', default=file_names) args = parser3.parse_args(remaining_argv + positionals) if args.dry_run: logger.info("Dry run active, won't touch any files.") if args.new_version: new_version = vc.parse(args.new_version) logger.info("New version will be '{}'".format(args.new_version)) file_names = file_names or positionals[1:] for file_name in file_names: files.append(ConfiguredFile(file_name, vc)) for vcs in VCS: if vcs.is_usable(): try: vcs.assert_nondirty() except WorkingDirectoryIsDirtyException as e: if not defaults['allow_dirty']: logger.warn( "{}\n\nUse --allow-dirty to override this if you know what you're doing." .format(e.message)) raise break else: vcs = None # make sure files exist and contain version string logger.info("Asserting files {} contain the version string:".format( ", ".join([str(f) for f in files]))) for f in files: f.should_contain_version(current_version, context) # change version string in files for f in files: f.replace(current_version, new_version, context, args.dry_run) commit_files = [f.path for f in files] config.set('bumpversion', 'new_version', args.new_version) for key, value in config.items('bumpversion'): logger_list.info("{}={}".format(key, value)) config.remove_option('bumpversion', 'new_version') config.set('bumpversion', 'current_version', args.new_version) new_config = StringIO() try: write_to_config_file = (not args.dry_run) and config_file_exists logger.info("{} to config file {}:".format( "Would write" if not write_to_config_file else "Writing", config_file, )) config.write(new_config) logger.info(new_config.getvalue()) if write_to_config_file: with io.open(config_file, 'wb') as f: f.write(new_config.getvalue().encode('utf-8')) except UnicodeEncodeError: warnings.warn( "Unable to write UTF-8 to config file, because of an old configparser version. " "Update with `pip install --upgrade configparser`.") if config_file_exists: commit_files.append(config_file) if not vcs: return assert vcs.is_usable(), "Did find '{}' unusable, unable to commit.".format( vcs.__name__) do_commit = (not args.dry_run) and args.commit do_tag = (not args.dry_run) and args.tag logger.info("{} {} commit".format( "Would prepare" if not do_commit else "Preparing", vcs.__name__, )) for path in commit_files: logger.info("{} changes in file '{}' to {}".format( "Would add" if not do_commit else "Adding", path, vcs.__name__, )) if do_commit: vcs.add_path(path) vcs_context = { "current_version": args.current_version, "new_version": args.new_version, } vcs_context.update(time_context) vcs_context.update(prefixed_environ()) commit_message = args.message.format(**vcs_context) logger.info("{} to {} with message '{}'".format( "Would commit" if not do_commit else "Committing", vcs.__name__, commit_message, )) if do_commit: vcs.commit(message=commit_message) sign_tags = args.sign_tags tag_name = args.tag_name.format(**vcs_context) tag_message = args.tag_message.format(**vcs_context) logger.info("{} '{}' {} in {} and {}".format( "Would tag" if not do_tag else "Tagging", tag_name, "with message '{}'".format(tag_message) if tag_message else "without message", vcs.__name__, "signing" if sign_tags else "not signing")) if do_tag: vcs.tag(sign_tags, tag_name, tag_message)
def import_eds(source, node_id): eds = RawConfigParser() eds.optionxform = str if hasattr(source, "read"): fp = source else: fp = open(source) try: # Python 3 eds.read_file(fp) except AttributeError: # Python 2 eds.readfp(fp) fp.close() od = objectdictionary.ObjectDictionary() if eds.has_section("FileInfo"): od.__edsFileInfo = { opt: eds.get("FileInfo", opt) for opt in eds.options("FileInfo") } if eds.has_section("Comments"): linecount = int(eds.get("Comments", "Lines"), 0) od.comments = '\n'.join([ eds.get("Comments", "Line%i" % line) for line in range(1, linecount + 1) ]) if not eds.has_section("DeviceInfo"): logger.warn( "eds file does not have a DeviceInfo section. This section is mandatory" ) else: for rate in [10, 20, 50, 125, 250, 500, 800, 1000]: baudPossible = int( eds.get("DeviceInfo", "BaudRate_%i" % rate, fallback='0'), 0) if baudPossible != 0: od.device_information.allowed_baudrates.add(rate * 1000) for t, eprop, odprop in [ (str, "VendorName", "vendor_name"), (int, "VendorNumber", "vendor_number"), (str, "ProductName", "product_name"), (int, "ProductNumber", "product_number"), (int, "RevisionNumber", "revision_number"), (str, "OrderCode", "order_code"), (bool, "SimpleBootUpMaster", "simple_boot_up_master"), (bool, "SimpleBootUpSlave", "simple_boot_up_slave"), (bool, "Granularity", "granularity"), (bool, "DynamicChannelsSupported", "dynamic_channels_supported"), (bool, "GroupMessaging", "group_messaging"), (int, "NrOfRXPDO", "nr_of_RXPDO"), (int, "NrOfTXPDO", "nr_of_TXPDO"), (bool, "LSS_Supported", "LSS_supported"), ]: try: if t in (int, bool): setattr(od.device_information, odprop, t(int(eds.get("DeviceInfo", eprop), 0))) elif t is str: setattr(od.device_information, odprop, eds.get("DeviceInfo", eprop)) except NoOptionError: pass if eds.has_section("DeviceComissioning"): od.bitrate = int(eds.get("DeviceComissioning", "BaudRate")) * 1000 od.node_id = int(eds.get("DeviceComissioning", "NodeID"), 0) for section in eds.sections(): # Match dummy definitions match = re.match(r"^[Dd]ummy[Uu]sage$", section) if match is not None: for i in range(1, 8): key = "Dummy%04d" % i if eds.getint(section, key) == 1: var = objectdictionary.Variable(key, i, 0) var.data_type = i var.access_type = "const" od.add_object(var) # Match indexes match = re.match(r"^[0-9A-Fa-f]{4}$", section) if match is not None: index = int(section, 16) name = eds.get(section, "ParameterName") try: object_type = int(eds.get(section, "ObjectType"), 0) except NoOptionError: # DS306 4.6.3.2 object description # If the keyword ObjectType is missing, this is regarded as # "ObjectType=0x7" (=VAR). object_type = VAR try: storage_location = eds.get(section, "StorageLocation") except NoOptionError: storage_location = None if object_type in (VAR, DOMAIN): var = build_variable(eds, section, node_id, index) od.add_object(var) elif object_type == ARR and eds.has_option(section, "CompactSubObj"): arr = objectdictionary.Array(name, index) last_subindex = objectdictionary.Variable( "Number of entries", index, 0) last_subindex.data_type = objectdictionary.UNSIGNED8 arr.add_member(last_subindex) arr.add_member(build_variable(eds, section, node_id, index, 1)) arr.storage_location = storage_location od.add_object(arr) elif object_type == ARR: arr = objectdictionary.Array(name, index) arr.storage_location = storage_location od.add_object(arr) elif object_type == RECORD: record = objectdictionary.Record(name, index) record.storage_location = storage_location od.add_object(record) continue # Match subindexes match = re.match(r"^([0-9A-Fa-f]{4})[S|s]ub([0-9A-Fa-f]+)$", section) if match is not None: index = int(match.group(1), 16) subindex = int(match.group(2), 16) entry = od[index] if isinstance(entry, (objectdictionary.Record, objectdictionary.Array)): var = build_variable(eds, section, node_id, index, subindex) entry.add_member(var) # Match [index]Name match = re.match(r"^([0-9A-Fa-f]{4})Name", section) if match is not None: index = int(match.group(1), 16) num_of_entries = int(eds.get(section, "NrOfEntries")) entry = od[index] # For CompactSubObj index 1 is were we find the variable src_var = od[index][1] for subindex in range(1, num_of_entries + 1): var = copy_variable(eds, section, subindex, src_var) if var is not None: entry.add_member(var) return od
does nothing, resulting in a case-sensitive parser. Parameters ---------- string : str The string to be transformed for the ConfigParser Returns ------- str The same string that was given as a parameter. """ return string _UNIT_LIB.optionxform = _do_nothing def import_library(libfilepointer): """ Import a units library, replacing any existing definitions. Parameters ---------- libfilepointer : file new library file to work with Returns ------- ConfigParser newly updated units library for the module
"calexp": ["instrument", "detector", "visit"], "raw": ["instrument", "detector", "exposure"], "deepCoadd": ["band", "skymap", "tract", "patch"] }, "hsc_rc2": { "IMG_REPO_ROOT": "/project/hsc/gen3repo/rc2w38_ssw42", "IMG_DEFAULT_COLLECTION": "RC2/w_2020_38", "IMG_OBSCORE_DB": "lsstdb1", "IMG_SCHEMA_TABLE": "imgserv.obscore", "IMG_DEFAULT_FILTER": "r", "calexp": ["instrument", "detector", "visit"], "raw": ["instrument", "detector", "exposure"], "deepCoadd": ["band", "skymap", "tract", "patch"] }, "default": "hsc_rc2" } # load webserv.ini configuration tasks_parser = RawConfigParser() tasks_parser.optionxform = str defaults_file = os.environ.get("WEBSERV_CONFIG", "~/.lsst/webserv.ini") try: with open(os.path.expanduser(defaults_file)) as cfg: tasks_parser.read_file(cfg, source=defaults_file) # provide access to webserv settings webserv_config = dict(tasks_parser.items("webserv")) except FileNotFoundError: # webserv settings not provided webserv_config = dict({})
def load_entries(fp, filename, prefix): entries = [] parser = RawConfigParser() parser.optionxform = str try: if hasattr(parser, "read_file"): parser.read_file(fp, filename) else: parser.readfp(fp, filename) except IOError: raise except Exception as e: raise IOError("Error reading persistent file: %s" % e) try: items = parser.items(PERSISTENT_SECTION) except NoSectionError: raise IOError("Persistent section not found") value = None m = None for k, v in items: # Reduces code duplication if value: key = _unescape_string(m.group(1)) if key.startswith(prefix): entries.append((key, value)) value = None m = _key_bool.match(k) if m: if v == "true": value = Value.makeBoolean(True) elif v == "false": value = Value.makeBoolean(False) else: logger.warning("Unrecognized boolean value %r for %s", v, m.group(1)) continue m = _key_double.match(k) if m: try: value = Value.makeDouble(float(v)) except ValueError as e: logger.warning("Unrecognized double value %r for %s", v, m.group(1)) continue m = _key_string.match(k) if m: mm = _value_string.match(v) if mm: value = Value.makeString(_unescape_string(mm.group(1))) else: logger.warning("Unrecognized string value %r for %s", v, m.group(1)) continue m = _key_raw.match(k) if m: try: v = base64.b64decode(v, validate=True) value = Value.makeRaw(v) except binascii.Error: logger.warning("Unrecognized raw value %r for %s", v, m.group(1)) continue m = _key_bool_array.match(k) if m: bools = [] arr = v.strip().split(",") if arr != [""]: for vv in arr: vv = vv.strip() if vv == "true": bools.append(True) elif vv == "false": bools.append(False) else: logger.warning( "Unrecognized bool '%s' in bool array %s'", vv, m.group(1) ) bools = None break if bools is not None: value = Value.makeBooleanArray(bools) continue m = _key_double_array.match(k) if m: doubles = [] arr = v.strip().split(",") if arr != [""]: for vv in arr: try: doubles.append(float(vv)) except ValueError: logger.warning( "Unrecognized double '%s' in double array %s", vv, m.group(1), ) doubles = None break value = Value.makeDoubleArray(doubles) continue m = _key_string_array.match(k) if m: # Technically, this will let invalid inputs in... but, # I don't really care. Feel free to fix it if you do. strings = [_unescape_string(vv) for vv in _value_string.findall(v)] value = Value.makeStringArray(strings) continue logger.warning("Unrecognized type '%s'", k) if value: key = _unescape_string(m.group(1)) if key.startswith(prefix): entries.append((key, value)) return entries
def write_acserver_config(self, preset): config = RawConfigParser() config.optionxform = str cfg_file = open( os.path.join(self.acserver_config_dir, 'server_cfg.ini'), 'w') config.add_section('SERVER') # build a distinct list of car names car_list = [] for driver in preset.entry_set.all(): if driver.car.dirname not in car_list: car_list.append(driver.car.dirname) # set max_clients value to the track's pitbox value if null if not preset.max_clients: preset.max_clients = preset.track.pitboxes config.set('SERVER', 'NAME', preset.server_setting.name) config.set('SERVER', 'CARS', ';'.join(car_list)) config.set('SERVER', 'CONFIG_TRACK', xstr(preset.track.subversion)) config.set('SERVER', 'TRACK', preset.track.dirname) config.set('SERVER', 'SUN_ANGLE', time_to_sun_angle(preset.time_of_day)) config.set('SERVER', 'PASSWORD', str(preset.session_password)) config.set('SERVER', 'ADMIN_PASSWORD', str(preset.server_setting.admin_password)) config.set('SERVER', 'UDP_PORT', str(preset.server_setting.udp_port)) config.set('SERVER', 'TCP_PORT', str(preset.server_setting.tcp_port)) config.set('SERVER', 'HTTP_PORT', str(preset.server_setting.http_port)) config.set('SERVER', 'PICKUP_MODE_ENABLED', str(int(preset.pickup_mode_enabled))) config.set('SERVER', 'LOOP_MODE', str(int(preset.loop_mode))) config.set('SERVER', 'SLEEP_TIME', '1') config.set('SERVER', 'CLIENT_SEND_INTERVAL', str(preset.server_setting.client_send_interval)) config.set('SERVER', 'SEND_BUFFER_SIZE', str(preset.server_setting.send_buffer_size)) config.set('SERVER', 'RECV_BUFFER_SIZE', str(preset.server_setting.recv_buffer_size)) config.set('SERVER', 'RACE_OVER_TIME', str(preset.race_over_time)) config.set('SERVER', 'KICK_QUORUM', str(preset.kick_quorum)) config.set('SERVER', 'VOTING_QUORUM', str(preset.voting_quorum)) config.set('SERVER', 'VOTE_DURATION', str(preset.vote_duration)) config.set('SERVER', 'BLACKLIST_MODE', str(preset.blacklist_mode)) config.set('SERVER', 'FUEL_RATE', str(preset.fuel_rate)) config.set('SERVER', 'DAMAGE_MULTIPLIER', str(preset.damage_multiplier)) config.set('SERVER', 'TYRE_WEAR_RATE', str(preset.tyre_wear_rate)) config.set('SERVER', 'ALLOWED_TYRES_OUT', str(preset.allowed_tyres_out)) config.set('SERVER', 'ABS_ALLOWED', str(preset.abs_allowed)) config.set('SERVER', 'TC_ALLOWED', str(preset.tc_allowed)) config.set('SERVER', 'STABILITY_ALLOWED', str(int(preset.stability_allowed))) config.set('SERVER', 'AUTOCLUTCH_ALLOWED', str(int(preset.autoclutch_allowed))) config.set('SERVER', 'TYRE_BLANKETS_ALLOWED', str(int(preset.tyre_blankets_allowed))) config.set('SERVER', 'FORCE_VIRTUAL_MIRROR', str(int(preset.force_virtual_mirror))) config.set('SERVER', 'REGISTER_TO_LOBBY', '1') config.set('SERVER', 'MAX_CLIENTS', str(preset.max_clients)) config.set('SERVER', 'UDP_PLUGIN_LOCAL_PORT', '11000') config.set('SERVER', 'UDP_PLUGIN_ADDRESS', '127.0.0.1:12000') config.set( 'SERVER', 'AUTH_PLUGIN_ADDRESS', '127.0.0.1:50041/acauth?timeout=300&andurl1=www.minorating.com%3A805/minodata/auth/' + preset.server_setting.minorating_grade + '/') config.set('SERVER', 'LEGAL_TYRES', 'V;E;HR;ST') config.set('SERVER', 'START_RULE', str(preset.start_rule)) config.set('SERVER', 'QUALIFY_MAX_WAIT_PERC', str(preset.qualify_max_wait_perc)) if preset.server_setting.welcome_message: config.set( 'SERVER', 'WELCOME_MESSAGE', str( os.path.join(self.acserver_config_dir, 'welcome_message.txt'))) if preset.practice_time != 0: config.add_section('PRACTICE') config.set('PRACTICE', 'NAME', 'Free Practice') config.set('PRACTICE', 'TIME', str(preset.practice_time)) config.set('PRACTICE', 'IS_OPEN', str(int(preset.practice_is_open))) if preset.qualify_time != 0: config.add_section('QUALIFY') config.set('QUALIFY', 'NAME', 'Qualify') config.set('QUALIFY', 'TIME', str(preset.qualify_time)) config.set('QUALIFY', 'IS_OPEN', str(int(preset.qualify_is_open))) if preset.race_laps != 0: config.add_section('RACE') config.set('RACE', 'NAME', 'Race') config.set('RACE', 'LAPS', str(preset.race_laps)) config.set('RACE', 'WAIT_TIME', str(preset.race_wait_time)) config.set('RACE', 'IS_OPEN', str(preset.race_is_open)) if preset.track_dynamism: config.add_section('DYNAMIC_TRACK') config.set('DYNAMIC_TRACK', 'SESSION_START', str(preset.track_dynamism.session_start)) config.set('DYNAMIC_TRACK', 'RANDOMNESS', str(preset.track_dynamism.randomness)) config.set('DYNAMIC_TRACK', 'SESSION_TRANSFER', str(preset.track_dynamism.session_transfer)) config.set('DYNAMIC_TRACK', 'LAP_GAIN', str(preset.track_dynamism.lap_gain)) weather_count = 0 for weather in preset.weathers.all(): weather_section = 'WEATHER_' + str(weather_count) config.add_section(weather_section) config.set(weather_section, 'GRAPHICS', weather.graphics) config.set(weather_section, 'BASE_TEMPERATURE_AMBIENT', str(weather.base_temperature_ambient)) config.set(weather_section, 'VARIATION_AMBIENT', str(weather.variation_ambient)) config.set(weather_section, 'BASE_TEMPERATURE_ROAD', str(weather.base_temperature_road)) config.set(weather_section, 'VARIATION_ROAD', str(weather.variation_road)) weather_count += 1 config.write(cfg_file, space_around_delimiters=False) cfg_file.close()
def get_info_from_ini(ini_path): parser = RawConfigParser() parser.optionxform = str # keep leading uppercases parser.read(ini_path) attributes_section = parser[InfoInstruction.ini_section_name] return dict(attributes_section)
For more information on this file, see https://docs.djangoproject.com/en/1.8/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/1.8/ref/settings/ """ # Build paths inside the project like this: os.path.join(BASE_DIR, ...) import os from configparser import RawConfigParser BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) config = RawConfigParser() config.optionxform = str config.read(BASE_DIR + '/TIMA/settings.ini') # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = config.get('secrets','SECRET_KEY') SESSION_COOKIE_SECURE = config.getboolean('secrets','SESSION_COOKIE_SECURE') CSRF_COOKIE_SECURE = config.getboolean('secrets','CSRF_COOKIE_SECURE') SESSION_EXPIRE_AT_BROWSER_CLOSE = config.getboolean('secrets','SESSION_EXPIRE_AT_BROWSER_CLOSE') # SECURITY WARNING: don't run with debug turned on in production! DEBUG = config.getboolean('debug','DEBUG') TEMPLATE_DEBUG = config.getboolean('debug','TEMPLATE_DEBUG')
class UsefulConfigParser(object): """A config parser that sucks less than those in module `ConfigParser`.""" def __init__(self, filenames_to_try=[]): # FUN FACT: In Python 3.2, they spontaneously changed the behaviour of # RawConfigParser so that it no longer considers ';' a comment delimiter # for inline comments. # # Compare: # "Configuration files may include comments, prefixed by specific # characters (# and ;). Comments may appear on their own in an otherwise # empty line, or may be entered in lines holding values or section names. # In the latter case, they need to be preceded by a whitespace character # to be recognized as a comment. (For backwards compatibility, only ; # starts an inline comment, while # does not.)" # -- https://docs.python.org/2/library/configparser.html # vs: # "Comment prefixes are strings that indicate the start of a valid comment # within a config file. comment_prefixes are used only on otherwise empty # lines (optionally indented) whereas inline_comment_prefixes can be used # after every valid value (e.g. section names, options and empty lines as # well). By default inline comments are disabled and '#' and ';' are used # as prefixes for whole line comments. # Changed in version 3.2: In previous versions of configparser behaviour # matched comment_prefixes=('#',';') and inline_comment_prefixes=(';',)." # -- https://docs.python.org/3/library/configparser.html#customizing-parser-behaviour # # Grrr... if sys.version_info.major >= 3: self._cp = RawConfigParser(dict_type=OrderedMultiDict, inline_comment_prefixes=(';', )) else: self._cp = RawConfigParser(dict_type=OrderedMultiDict) if isinstance(filenames_to_try, str): filenames_to_try = [filenames_to_try] self._filenames_to_try = filenames_to_try[:] def read(self, filenames_to_try=[]): if isinstance(filenames_to_try, str): filenames_to_try = [filenames_to_try] self._filenames_to_try.extend(filenames_to_try) return self._cp.read(self._filenames_to_try) def sections(self): return self._cp.sections() def options(self, section_name): ## The client code doesn't need to check in advance that the requested ## section name is present in the config; this function will check ## this automatically, so no exception is raised by RawConfigParser. ## Check that `section_name` is present in the config. ## Otherwise, RawConfigParser will raise ConfigParser.NoSectionError. if not self._cp.has_section(section_name): return [] return self._cp.options(section_name) def get(self, section_name, option_name, do_optionxform=True): if do_optionxform: # https://docs.python.org/2/library/configparser.html#ConfigParser.RawConfigParser.optionxform option_name = self._cp.optionxform(option_name) if section_name is None: return self._get_optval_in_sections(self.sections(), option_name) elif isinstance(section_name, str): return self._get_optval_in_sections([section_name], option_name) else: return self._get_optval_in_sections(section_name, option_name) def _get_optval_in_sections(self, section_names, option_name): ## The client code doesn't need to check in advance that the requested ## section name(s) are present in the config; this function will check ## this automatically, so no exception is raised by RawConfigParser. optvals = [] for section_name in section_names: ## Check that `section_name` is present in the config. ## Otherwise, RawConfigParser will raise ConfigParser.NoSectionError. if not self._cp.has_section(section_name): continue optvals.extend([ optval for optname, optval in self._cp.items(section_name) if optname == option_name ]) return optvals def getboolean(self, section_name, option_name, do_optionxform=True): # https://docs.python.org/2/library/configparser.html#ConfigParser.RawConfigParser.getboolean return [ self._coerce_to_boolean(optval) for optval in self.get(section_name, option_name, do_optionxform) ] _boolean_states = { '1': True, 'yes': True, 'true': True, 'on': True, '0': False, 'no': False, 'false': False, 'off': False } def _coerce_to_boolean(self, optval_str): # 'The accepted values for the option are "1", "yes", "true", and "on", # which cause this method to return True, and "0", "no", "false", and # "off", which cause it to return False. These string values are checked # in a case-insensitive manner. Any other value will cause it to raise # ValueError.' # https://docs.python.org/2/library/configparser.html#ConfigParser.RawConfigParser.getboolean ovs_lower = optval_str.lower() if ovs_lower not in self._boolean_states: raise ValueError("Not a boolean: %s" % optval_str) return self._boolean_states[ovs_lower]
ACCEPT_TYPES = ["application/json", "text/html"] log.basicConfig(format='%(asctime)s %(name)s %(levelname)s: %(message)s', datefmt='%m/%d/%Y %I:%M:%S', level=log.DEBUG) defaults_file = os.environ.get("WEBSERV_CONFIG", "~/.lsst/webserv.ini") WERKZEUG_PREFIX = "dax.webserv.werkzeug." # instance folder not under version control i_path = os.path.join(os.path.expanduser("~"), ".lsst/instance") app = Flask(__name__, instance_path=i_path) # Initialize configuration webserv_parser = RawConfigParser() webserv_parser.optionxform = str with open(os.path.expanduser(defaults_file)) as cfg: webserv_parser.readfp(cfg, defaults_file) webserv_config = dict(webserv_parser.items("webserv")) default_db_url = webserv_config.get("dax.webserv.db.url") default_imgserv_meta_url = webserv_config.get("dax.imgserv.meta.url") # Initialize configuration for ImageServ imgserv_config_path = os.path.join(app.instance_path, "imgserv") with app.app_context(): # imgserv_config_path only prep for use of instance folder later is_api_v1.load_imgserv_config(None, default_imgserv_meta_url) # Execute this last, we can overwrite anything we don't like
# NOTE: this overwrites existing desktop.ini # from PIL import Image import sys from configparser import RawConfigParser import ctypes import os #-- Vars f = sys.argv[1] # this will get the dragged file, (if it is not an image, it just closes) i = Image.open(f) # go ahead and load it as an image (otherwise just close like said above) name = f.split('.')[0]+'.ico' # wanna split get the filename and get index 0, so like 001.jpg => [001],[jpg] ico = i.save(name) # convert and save the file to the same folder the the dragged image came from dir = os.path.dirname(f) #-- Desktop.ini generator config = RawConfigParser() config.optionxform=str cfFile = open(dir+'\\desktop.ini','w') # Create the ini sections we want [.ShellClassInfo], [ViewState] config.add_section('.ShellClassInfo') config.add_section('ViewState') # Icon Path, autogenerated from the source of the dragged object config.set('.ShellClassInfo','IconResource',name+',0') # Folder type, should be Video, Generic, Pictures config.set('ViewState','FolderType','Generic') # write the file to disk (save) config.write(cfFile) # close the stream cfFile.close() # get the dir, not the file
with open(sys_cfg_file, 'w') as f: json.dump(cfg, f, indent=4) ################################################################# # Project Configuration ################################################################# proj_path = None proj_cfg = RawConfigParser(allow_no_value=True) proj_cfg['ROI_DEFS'] = {} proj_cfg['STIM_DEFS'] = {} proj_cfg.optionxform = str special = {} df_refs = {} def save_proj_config(): set_proj_special() with open(proj_path + '/config.cfg', 'w') as configfile: proj_cfg.write(configfile) def create_new_proj_config(): defaultInclude = ['SampleID', 'date', 'comments'] proj_cfg['INCLUDE'] = dict.fromkeys(defaultInclude) defaultExclude = ['ImgInfoPath', 'ImgPath', 'ImgUUID', 'ROI_State', 'uuid_curve', 'misc', 'AnimalID']
from configparser import RawConfigParser import os from multiprocessing import Process from time import sleep """ Settings application """ # Reset mode to finish line 178 sense = SenseHat() wireless = Wireless() config = RawConfigParser(allow_no_value = True) password_config = RawConfigParser(allow_no_value = True) config.optionxform = str config.optionxform = lambda option: option config.read('config.ini') password_config.read('password_config.ini') def main(color1, color2, speed): """ Args : color1 (list or tuple) : rgb color code of titles color2 (list or tuple) : rgb color code of subtitles speed (float) : speed of the scrolling of message
def find(self, dimension): """Return the display unit for a particular dimension. **Parameters:** - *dimension*: Dictionary of base dimensions and exponents **Returns:** The display unit as a string """ return '.'.join([ self[base][1] if exp == 1 else self[base][1] + str(exp) for base, exp in dimension.items() ]) # Load the default display units. try: config = RawConfigParser(interpolation=None, inline_comment_prefixes=[';']) except TypeError: config = RawConfigParser() config.optionxform = str # Dimensions are case sensitive. config.read(path.join(dname, 'display.ini')) default_display_units = DisplayUnits(config.items('Default display units')) if __name__ == '__main__': # Test the contents of this file. import doctest doctest.testmod()
# working with xfce4-terminal-0.6.2-1 if __name__ == "__main__": import sys PM = ["+", "-"] if len(sys.argv) != 2 or sys.argv[1] not in PM: sys.exit("Usage {0} {1}".format(sys.argv[0], "/".join(PM))) delta = int("{0}1".format(sys.argv[1])) import os import re from configparser import RawConfigParser # read input file f = os.path.join(os.environ["XDG_CONFIG_HOME"], "xfce4", "terminal", "terminalrc") c = RawConfigParser() c.optionxform = str # make keys case-sensitive c.read(f) font, size = re.search(r'^(.*) (\d+)$', c['Configuration']['FontName']).group(1, 2) size = int(size) + delta c['Configuration']['FontName'] = "{0} {1}".format(font, size) with open(f, 'w') as c_new: c.write(c_new)
def load(cls, hostsConf): """ Load several hosts from a configuration file. Return an dictionary with hostName -> hostConfig pairs. """ # Read from users' config file. Raw to avoid interpolation of %: we expect %_ cp = RawConfigParser(comment_prefixes=";") cp.optionxform = str # keep case (stackoverflow.com/questions/1611799) hosts = OrderedDict() try: assert cp.read(hostsConf) != [], 'Missing file %s' % hostsConf for hostName in cp.sections(): host = HostConfig(label=hostName, hostName=hostName) host.setHostPath(pw.Config.SCIPION_USER_DATA) # Helper functions (to write less) def get(var, default=None): if cp.has_option(hostName, var): value = cp.get(hostName, var) # Rescue python2.7 behaviour: ## at the beginning of a line, means a single #. # https://github.com/scipion-em/scipion-pyworkflow/issues/70 value = value.replace("\n##", "\n#") # Keep compatibility: %_ --> %% value = value.replace('%_(', '%(') return value else: return default def getDict(var): od = OrderedDict() if cp.has_option(hostName, var): for key, value in json.loads(get(var)).items(): od[key] = value return od host.setScipionHome( get(pw.SCIPION_HOME_VAR, pw.Config.SCIPION_HOME)) host.setScipionConfig(pw.Config.SCIPION_CONFIG) # Read the address of the remote hosts, # using 'localhost' as default for backward compatibility host.setAddress(get('ADDRESS', 'localhost')) host.mpiCommand.set(get('PARALLEL_COMMAND')) host.queueSystem = QueueSystemConfig() hostQueue = host.queueSystem # shortcut hostQueue.name.set(get('NAME')) # If the NAME is not provided or empty # do no try to parse the rest of Queue parameters if hostQueue.hasName(): hostQueue.setMandatory(get('MANDATORY', 0)) hostQueue.submitPrefix.set(get('SUBMIT_PREFIX', '')) hostQueue.submitCommand.set(get('SUBMIT_COMMAND')) hostQueue.submitTemplate.set(get('SUBMIT_TEMPLATE')) hostQueue.cancelCommand.set(get('CANCEL_COMMAND')) hostQueue.checkCommand.set(get('CHECK_COMMAND')) hostQueue.jobDoneRegex.set(get('JOB_DONE_REGEX')) hostQueue.queues = getDict('QUEUES') hostQueue.queuesDefault = getDict('QUEUES_DEFAULT') hosts[hostName] = host return hosts except Exception as e: sys.exit('Failed to read settings. The reported error was:\n %s\n' 'To solve it, delete %s and run again.' % (e, os.path.abspath(hostsConf)))
def import_library(libfilepointer): """ Import a units library, replacing any existing definitions. Parameters ---------- libfilepointer : file new library file to work with Returns ------- ConfigParser newly updated units library for the module """ global _UNIT_LIB global _UNIT_CACHE _UNIT_CACHE = {} _UNIT_LIB = ConfigParser() _UNIT_LIB.optionxform = _do_nothing # New in Python 3.2: read_file() replaces readfp(). if sys.version_info >= (3, 2): _UNIT_LIB.read_file(libfilepointer) else: _UNIT_LIB.readfp(libfilepointer) required_base_types = ['length', 'mass', 'time', 'temperature', 'angle'] _UNIT_LIB.base_names = list() # used to is_angle() and other base type checking _UNIT_LIB.base_types = dict() _UNIT_LIB.unit_table = dict() _UNIT_LIB.prefixes = dict() _UNIT_LIB.help = list() for prefix, factor in _UNIT_LIB.items('prefixes'): factor, comma, comment = factor.partition(',') _UNIT_LIB.prefixes[prefix] = float(factor) base_list = [0] * len(_UNIT_LIB.items('base_units')) for i, (unit_type, name) in enumerate(_UNIT_LIB.items('base_units')): _UNIT_LIB.base_types[unit_type] = i powers = list(base_list) powers[i] = 1 # print '%20s'%unit_type, powers # cant use add_unit because no base units exist yet _new_unit(name, 1, powers) _UNIT_LIB.base_names.append(name) # test for required base types missing = [ utype for utype in required_base_types if utype not in _UNIT_LIB.base_types ] if missing: raise ValueError('Not all required base type were present in the' ' config file. missing: %s, at least %s required' % (missing, required_base_types)) _update_library(_UNIT_LIB) return _UNIT_LIB
def __init__(self, path): config = RawConfigParser() config.optionxform = lambda s: s if path: # Test support config.read(path) self.config = config
url = "http://xlr:5516/api/v1/config/byTypeAndTitle?configurationType=%s&title=%s" % (server_type, url_encoded_title) request = urllib.request.Request(url) request.add_header("Authorization", "Basic %s" % base64string) result = urllib.request.urlopen(request) return json.loads(result.read())[0] def save_configuration_object(config_object): headers = {'Content-Type': 'application/json'} request = urllib.request.Request("http://xlr:5516/api/v1/config/%s" % (config_object["id"]), json.dumps(config_object).encode("utf-8"), headers) request.add_header("Authorization", "Basic %s" % base64string) request.get_method = lambda: 'PUT' result2 = urllib.request.urlopen(request) def update_ci(server_title, server_type, username, properties): print("Processing credential [%s] for server type [%s] with title [%s]" % (username, server_type, server_title)) config_object = get_configuration_object(section, server_type) for item in properties: config_object[item[0]] = item[1] save_configuration_object(config_object) cp = RawConfigParser() #To avoid parser to convert all keys to lowercase by default cp.optionxform = str cp.read(sys.argv[1]) for section in cp.sections(): update_ci(section, cp.get(section, "type"), cp.get(section, "username"), cp.items(section)) print("Updated credentials")
def load_config(file='setup.cfg'): config = RawConfigParser() config.optionxform = lambda x: x.lower().replace('_', '-') config.read(file) return config
def export_eds(od, dest=None, file_info={}, device_commisioning=False): def export_object(obj, eds): if type(obj) is objectdictionary.Variable: return export_variable(obj, eds) if type(obj) is objectdictionary.Record: return export_record(obj, eds) if type(obj) is objectdictionary.Array: return export_array(obj, eds) def export_common(var, eds, section): eds.add_section(section) eds.set(section, "ParameterName", var.name) if var.storage_location: eds.set(section, "StorageLocation", var.storage_location) def export_variable(var, eds): if type(var.parent) is objectdictionary.ObjectDictionary: # top level variable section = "%04X" % var.index else: # nested variable section = "%04Xsub%X" % (var.index, var.subindex) export_common(var, eds, section) eds.set(section, "ObjectType", "0x%X" % VAR) if var.data_type: eds.set(section, "DataType", "0x%04X" % var.data_type) if var.access_type: eds.set(section, "AccessType", var.access_type) if getattr(var, 'default_raw', None) is not None: eds.set(section, "DefaultValue", var.default_raw) elif getattr(var, 'default', None) is not None: eds.set(section, "DefaultValue", _revert_variable(var.data_type, var.default)) if device_commisioning: if getattr(var, 'value_raw', None) is not None: eds.set(section, "ParameterValue", var.value_raw) elif getattr(var, 'value', None) is not None: eds.set(section, "ParameterValue", _revert_variable(var.data_type, var.default)) eds.set(section, "DataType", "0x%04X" % var.data_type) eds.set(section, "PDOMapping", hex(var.pdo_mappable)) if getattr(var, 'min', None) is not None: eds.set(section, "LowLimit", var.min) if getattr(var, 'max', None) is not None: eds.set(section, "HighLimit", var.max) def export_record(var, eds): section = "%04X" % var.index export_common(var, eds, section) eds.set(section, "SubNumber", "0x%X" % len(var.subindices)) ot = RECORD if type(var) is objectdictionary.Record else ARR eds.set(section, "ObjectType", "0x%X" % ot) for i in var: export_variable(var[i], eds) export_array = export_record eds = RawConfigParser() # both disables lowercasing, and allows int keys eds.optionxform = str from datetime import datetime as dt defmtime = dt.utcnow() try: # only if eds was loaded by us origFileInfo = od.__edsFileInfo except AttributeError: origFileInfo = { # just set some defaults "CreationDate": defmtime.strftime("%m-%d-%Y"), "CreationTime": defmtime.strftime("%I:%m%p"), "EdsVersion": 4.2, } file_info.setdefault("ModificationDate", defmtime.strftime("%m-%d-%Y")) file_info.setdefault("ModificationTime", defmtime.strftime("%I:%m%p")) for k, v in origFileInfo.items(): file_info.setdefault(k, v) eds.add_section("FileInfo") for k, v in file_info.items(): eds.set("FileInfo", k, v) eds.add_section("DeviceInfo") for eprop, odprop in [ ("VendorName", "vendor_name"), ("VendorNumber", "vendor_number"), ("ProductName", "product_name"), ("ProductNumber", "product_number"), ("RevisionNumber", "revision_number"), ("OrderCode", "order_code"), ("SimpleBootUpMaster", "simple_boot_up_master"), ("SimpleBootUpSlave", "simple_boot_up_slave"), ("Granularity", "granularity"), ("DynamicChannelsSupported", "dynamic_channels_supported"), ("GroupMessaging", "group_messaging"), ("NrOfRXPDO", "nr_of_RXPDO"), ("NrOfTXPDO", "nr_of_TXPDO"), ("LSS_Supported", "LSS_supported"), ]: val = getattr(od.device_information, odprop, None) if type(val) is None: continue elif type(val) is str: eds.set("DeviceInfo", eprop, val) elif type(val) in (int, bool): eds.set("DeviceInfo", eprop, int(val)) # we are also adding out of spec baudrates here. for rate in od.device_information.allowed_baudrates.union( {10e3, 20e3, 50e3, 125e3, 250e3, 500e3, 800e3, 1000e3}): eds.set("DeviceInfo", "BaudRate_%i" % (rate / 1000), int(rate in od.device_information.allowed_baudrates)) if device_commisioning and (od.bitrate or od.node_id): eds.add_section("DeviceComissioning") if od.bitrate: eds.set("DeviceComissioning", "BaudRate", int(od.bitrate / 1000)) if od.node_id: eds.set("DeviceComissioning", "NodeID", int(od.node_id)) eds.add_section("Comments") i = 0 for line in od.comments.splitlines(): i += 1 eds.set("Comments", "Line%i" % i, line) eds.set("Comments", "Lines", i) eds.add_section("DummyUsage") for i in range(1, 8): key = "Dummy%04d" % i eds.set("DummyUsage", key, 1 if (key in od) else 0) def mandatory_indices(x): return x in {0x1000, 0x1001, 0x1018} def manufacturer_idices(x): return x in range(0x2000, 0x6000) def optional_indices(x): return all(( x > 0x1001, not mandatory_indices(x), not manufacturer_idices(x), )) supported_mantatory_indices = list(filter(mandatory_indices, od)) supported_optional_indices = list(filter(optional_indices, od)) supported_manufacturer_indices = list(filter(manufacturer_idices, od)) def add_list(section, list): eds.add_section(section) eds.set(section, "SupportedObjects", len(list)) for i in range(0, len(list)): eds.set(section, (i + 1), "0x%04X" % list[i]) for index in list: export_object(od[index], eds) add_list("MandatoryObjects", supported_mantatory_indices) add_list("OptionalObjects", supported_optional_indices) add_list("ManufacturerObjects", supported_manufacturer_indices) if not dest: import sys dest = sys.stdout eds.write(dest, False)
"FuncSanity": "Runs gene callers and annotation programs on MAGs", }, { "PhyloSanity": ("directory", "config_file", "cancel_autocommit", "output_directory", "biometadb_project"), "FuncSanity": ("directory", "config_file", "cancel_autocommit", "output_directory", "biometadb_project", "type_file", "prokka", "reevaluate_quality"), })) if ap.args.version: print("MetaSanity version %s" % VERSION) exit(0) # Config file read in cfg = RawConfigParser() cfg.optionxform = str cfg.read(ap.args.config_file) met_list = {"PhyloSanity": "evaluation.list", "FuncSanity": "annotation.list"} prokka_add = [] if ap.args.prokka: prokka_add = ["--prokka"] cid_file_name = 'docker.pid' # Run docker version if not os.path.exists(PIPEDM_PATH): try: subprocess.run( [
def parse_library(handle): """Parse an FDSTools library file as made with the library tool.""" markers = {} ini = RawConfigParser() ini.optionxform = str ini.readfp(handle) for section in ini.sections(): for marker in ini.options(section): value = ini.get(section, marker).split(";", 1)[0].strip() section_low = section.lower() if section_low == "flanks": value = PAT_SPLIT.split(value) if len(value) != 2: raise ValueError( "For marker %s, %i flanking sequences were given, " "need exactly 2" % (marker, len(value))) for i, val in enumerate(value): if PAT_SEQ_IUPAC.match(val) is None: try: value[i] = int(val) if value[i] < 1: raise ValueError except: raise ValueError( "Flanking sequence '%s' of marker %s is invalid" % (val, marker)) elif section_low in ("prefix", "suffix"): if not PAT_SEQ_RAW.match(value): raise ValueError( "The %s sequence '%s' of marker %s is invalid (note: only one sequence " "needs to be specified for reference)" % (section_low, value, marker)) elif section_low == "genome_position": value = PAT_SPLIT.split(value) chromosome = PAT_CHROMOSOME.match(value[0]) if chromosome is None: raise ValueError("Invalid chromosome '%s' for marker %s" % (value[0], marker)) pos = [chromosome.group(1)] for i in range(1, len(value)): try: pos.append(int(value[i])) except: raise ValueError( "Position '%s' of marker %s is not a valid integer" % (value[i], marker)) if not i % 2 and pos[-2] >= pos[-1]: raise ValueError( "End position %i of marker %s must be higher than " "corresponding start position %i" % (pos[-1], marker, pos[-2])) if len(value) == 1: pos.append(1) value = tuple(pos) elif section_low == "length_adjust": try: value = int(value) except: raise ValueError( "Length adjustment '%s' of marker %s is not a valid " "integer" % (value, marker)) elif section_low == "block_length": try: value = int(value) except: raise ValueError( "Block length '%s' of marker %s is not a valid integer" % (value, marker)) elif section_low == "max_expected_copies": try: value = int(value) except: raise ValueError( "Maximum number of expected copies '%s' of marker %s " "is not a valid integer" % (value, marker)) elif section_low == "repeat": if PAT_STR_DEF.match(value) is None: raise ValueError( "STR definition '%s' of marker %s is invalid" % (value, marker)) elif section_low == "no_repeat": if PAT_SEQ_RAW.match(value) is None: raise ValueError( "Reference sequence '%s' of marker %s is invalid" % (value, marker)) elif section_low == "microhaplotype_positions": value = PAT_SPLIT.split(value) for i in range(len(value)): try: value[i] = int(value[i]) except: raise ValueError( "Invalid position number '%s' for microhaplotype marker %s" % (value[i], marker)) elif section_low == "expected_allele_length": value = PAT_SPLIT.split(value) try: min_length = int(value[0]) except: raise ValueError( "Minimum expected allele length '%s' of marker %s " "is not a valid integer" % (value[0], marker)) if len(value) == 2: try: max_length = int(value[1]) except: raise ValueError( "Maximum expected allele length '%s' of marker %s " "is not a valid integer" % (value[1], marker)) elif len(value) > 2: raise ValueError( "%i values specified for expected_allele_length of marker %s; specify " "only a minimum and optionally a maximum length" % (len(value), marker)) else: max_length = sys.maxsize value = (min_length, max_length) # Store the validated value. if marker not in markers: markers[marker] = {} markers[marker][section_low] = value # Create a ReportedRangeStore to store data about each marker. reported_range_store = classes.ReportedRangeStore() MUTEX_GROUPS = { "explicit STR": ("prefix", "suffix", "repeat", "length_adjust", "block_length"), "explicit non-STR": ("no_repeat", ), "STRNaming-specific": tuple() } # NOTE: No STRNaming-specific settings now... for marker, settings in markers.items(): groups = [ mutex_group for mutex_group, sections in MUTEX_GROUPS.items() if any(section in settings for section in sections) ] if len(groups) > 1: raise ValueError( "The definition of marker %s is ambiguous, because it appears in %s" % (marker, " and ".join("%s sections (%s)" % (group, ", ".join( section for section in MUTEX_GROUPS[group] if section in settings)) for group in groups))) options = { option: settings[option] for option in { "flanks", "max_expected_copies", "expected_allele_length", "microhaplotype_positions" } & settings.keys() } if "explicit STR" in groups: # Legacy FDSTools-style definition of an STR marker. # TODO: Alias of STR markers was defined as excluding the prefix/suffix! if "flanks" not in options: options["flanks"] = ("", "") elif any(isinstance(flank, int) for flank in options["flanks"]): raise ValueError( "Please specify an explit flanking sequence, not just a length, for marker %s" % marker) reported_range = add_legacy_range( reported_range_store, marker, settings.get("prefix", ""), settings.get("suffix", ""), [(unit, int(min_repeats), int(max_repeats)) for unit, min_repeats, max_repeats in PAT_STR_DEF_BLOCK.findall(settings.get("repeat", ""))], options, settings.get("genome_position", None)) if "length_adjust" in settings: reported_range.length_adjust -= settings["length_adjust"] if "block_length" in settings: reported_range.block_length = settings["block_length"] elif "explicit non-STR" in groups: # Legacy FDSTools-style definition of a non-STR marker. if "flanks" not in options: options["flanks"] = ("", "") elif any(isinstance(flank, int) for flank in options["flanks"]): raise ValueError( "Please specify an explit flanking sequence, not just a length, for marker %s" % marker) refseq = settings["no_repeat"] pos = None if "genome_position" in settings: pos = settings["genome_position"] # Sanity check: end position should reflect ref length. length = sum(pos[i] - pos[i - 1] + 1 for i in range(2, len(pos), 2)) if len(refseq) < length or (len(pos) % 2 and len(refseq) != length): raise ValueError( "Length of reference sequence of marker %s is %i bases, but " "genome positions add up to %i bases" % (marker, len(refseq), length)) add_legacy_range(reported_range_store, marker, refseq, "", [], options, pos) else: # Use STRNaming for this marker. try: genome_position = settings["genome_position"] except KeyError: raise ValueError( "No genome_position or explicit repeat or no_repeat " "configuration provided for marker %s" % marker) if not len(genome_position) % 2: raise ValueError( "Invalid genomic position given for marker %s: need an odd number of values " "(chromosome, start position, end position[, start2, end2, ...])" % marker) # TODO: Alias of STR markers was defined as excluding the prefix/suffix! if len(genome_position) == 3: chromosome, start, end = genome_position reported_range_store.add_range(marker, chromosome, start, end + 1, load_structures=True, options=options) else: reported_range_store.add_complex_range(marker, genome_position, options=options) if "microhaplotype_positions" in settings: # Put Ns in reporting range refseq for microhaplotype markers. reported_range = reported_range_store.get_range(marker) if reported_range.library: raise ValueError( "Cannot define microhaplotype positions for STR marker %s" % marker) refseq = list(reported_range.refseq) location = reported_range.location for position in settings["microhaplotype_positions"]: refseq[libsequence.get_genome_pos(location, position, invert=True)] = "N" reported_range.refseq = "".join(refseq) return reported_range_store
def __load_config(self, props_file): cp = RawConfigParser({'memory': '4g'}) cp.optionxform = str # So no lowercasing occurs cp.read(props_file) return cp
def read_config(self, path): config = RawConfigParser() config.optionxform = lambda s: s config.read(path) return config
def make_empty_library_ini(type, microhaplotypes=False): ini = RawConfigParser(allow_no_value=True) ini.optionxform = str ini.add_comment = MethodType(ini_add_comment, ini) # Create sections and add comments to explain how to use them. ini.add_section("genome_position") ini.add_comment( "genome_position", #smart, str, non-str, full "Specify the chromosome number and positions of the first and last reported nucleotide of " "each marker (both inclusive, using human genome build GRCh38%s). This range should not " "include the primer binding sites.%s" % (" and rCRS for human mtDNA" if type != "str" else "", " This section is required for automatic configuration of markers; it is optional " "for markers that are explictily configured in this library file." if type != "smart" else "")) if type != "str": ini.add_comment( "genome_position", "Specify 'M' as the chromosome name for markers on mitochondrial " "DNA. Allele names generated for these markers will follow mtDNA " "nomenclature guidelines (Parson et al., 2014). If one of your " "mtDNA fragments starts near the end of the reference sequence " "and continues at the beginning, you can obtain correct base " "numbering by specifying the fragment's genome position as \"M, " "(starting position), 16569, 1, (ending position)\". This tells " "FDSTools that the marker is a concatenation of two fragments, " "where the first fragment ends at position 16569 and the second " "fragment starts at position 1. Similarly, for a fragment that " "spans position 3107 in the rCRS (which is nonexistent), you may " "specify \"M, (starting position), 3106, 3108, (ending " "position)\".") if microhaplotypes or type == "full": ini.add_section("microhaplotype_positions") ini.add_comment( "microhaplotype_positions", "For each microhaplotype marker, specify one or more positions of SNPs that should " "be reported as part of the microhaplotype.%s" % (" If the [genome_position] of the marker is given, positions must be within the " "given range. Otherwise, the reference sequence must be explicitly provided in " "the [no_repeat] section position 1 refers to the first base in the reference " "sequence." if type in ("non-str", "full") else "")) ini.add_section("flanks") ini.add_comment( "flanks", "The TSSV tool will use a pair of short anchor sequences just outside the reported range " "of each marker (e.g., primer sequences) to identify which input reads correspond to " "which marker. %s The sequence may contain IUPAC codes for ambiguous positions to account " "for degenerate bases in the primers or for bisulfite-converted targets in methylation-" "based studies (e.g., Y matches either C or T)." % ("Specify two comma-separated values: left flank and right flank sequence, in the same " "sequence orientation (strand)." if type in ("str", "non-str") else ("The default length of the anchor sequences used can be specified as an argument to " "the TSSV tool. Individual alternative lengths can be specified here for each marker. " "Specify two comma-separated values: one for the left and one for the right flank. " "The value can be a number (the length of sequence to use) or an explicit anchor " "sequence to use.%s" % (" For markers configured explicitly in this library file, the anchor sequences " "must be specified explicitly as well." if type == "full" else ""))) ) ini.add_section("max_expected_copies") ini.add_comment( "max_expected_copies", "By default, the Allelefinder tool will report up to 2 alleles per marker, but only a " "single allele for markers %son the Y chromosome. If this is incorrect, specify the " "maximum expected number of copies (i.e., alleles) for each marker in a " "single-contributor reference sample here." % ("on mitochondrial DNA or " if type != "str" else "")) ini.add_section("expected_allele_length") ini.add_comment( "expected_allele_length", "Specify one or two values for each marker. The first value gives the " "expected minimum length (in nucleotides, %sexcluding flanks) of the " "alleles and the second value (if given) specifies the maximum allele " "length expected for that marker (both inclusive). The TSSV tool will filter " "sequences that have a length outside this range." % ("including prefix and suffix, " if type in ("str", "full") else "")) if type in ("str", "full"): ini.add_section("prefix") ini.add_comment( "prefix", "For explicitly-configured STR markers: Specify the prefix sequence of each STR " "marker. The prefix is the sequence between the left flank and the repeat and is " "omitted from allele names. The sequence is used as the reference sequence for that " "marker when generating allele names. Deviations from the reference are expressed as " "variants.") ini.add_section("suffix") ini.add_comment( "suffix", "For explicitly-configured STR markers: Specify the suffix sequence of each STR " "marker. The suffix is the sequence between the repeat and the right flank. The " "sequence is used as the reference sequence for that marker when generating allele " "names.") ini.add_section("repeat") ini.add_comment( "repeat", "For explicitly-configured STR markers: Specify the repeat structure of each STR " "marker in space-separated triples of sequence, minimum number of repeats, and " "maximum number of repeats.") ini.add_section("length_adjust") ini.add_comment( "length_adjust", "For explicitly-configured STR markers: To prevent discrepancies between traditional " "CE allele numbers and the CE number in FDSTools allele names, the CE allele number " "as calculated by FDSTools is based on the length of the repeat sequence minus the " "adjustment specified here.") ini.add_section("block_length") ini.add_comment( "block_length", "For explicitly-configured STR markers: Specify the repeat unit length of each STR " "marker. By default, the length of the repeat unit of the longest repeat is used." ) if type in ("non-str", "full"): ini.add_section("no_repeat") ini.add_comment( "no_repeat", "For explicitly-configured non-STR markers: Specify the reference sequence for each " "non-STR marker.") return ini
def __spawn_instance(self): """ Create and configure a new KRA instance using pkispawn. Creates a configuration file with IPA-specific parameters and passes it to the base class to call pkispawn """ # Create an empty and secured file (cfg_fd, cfg_file) = tempfile.mkstemp() os.close(cfg_fd) pent = pwd.getpwnam(self.service_user) os.chown(cfg_file, pent.pw_uid, pent.pw_gid) self.tmp_agent_db = tempfile.mkdtemp(prefix="tmp-", dir=paths.VAR_LIB_IPA) tmp_agent_pwd = ipautil.ipa_generate_password() # Create a temporary file for the admin PKCS #12 file (admin_p12_fd, admin_p12_file) = tempfile.mkstemp() os.close(admin_p12_fd) # Create KRA configuration config = RawConfigParser() config.optionxform = str config.add_section("KRA") # Security Domain Authentication config.set("KRA", "pki_security_domain_https_port", "443") config.set("KRA", "pki_security_domain_password", self.admin_password) config.set("KRA", "pki_security_domain_user", self.admin_user) # issuing ca config.set("KRA", "pki_issuing_ca_uri", "https://%s" % ipautil.format_netloc(self.fqdn, 443)) # Server config.set("KRA", "pki_enable_proxy", "True") config.set("KRA", "pki_restart_configured_instance", "False") config.set("KRA", "pki_backup_keys", "True") config.set("KRA", "pki_backup_password", self.admin_password) # Client security database config.set("KRA", "pki_client_database_dir", self.tmp_agent_db) config.set("KRA", "pki_client_database_password", tmp_agent_pwd) config.set("KRA", "pki_client_database_purge", "True") config.set("KRA", "pki_client_pkcs12_password", self.admin_password) # Administrator config.set("KRA", "pki_admin_name", self.admin_user) config.set("KRA", "pki_admin_uid", self.admin_user) config.set("KRA", "pki_admin_email", "root@localhost") config.set("KRA", "pki_admin_password", self.admin_password) config.set("KRA", "pki_admin_nickname", "ipa-ca-agent") config.set("KRA", "pki_admin_subject_dn", str(DN(('cn', 'ipa-ca-agent'), self.subject_base))) config.set("KRA", "pki_import_admin_cert", "False") config.set("KRA", "pki_client_admin_cert_p12", admin_p12_file) # Directory server config.set("KRA", "pki_ds_ldap_port", "389") config.set("KRA", "pki_ds_password", self.dm_password) config.set("KRA", "pki_ds_base_dn", str(self.basedn)) config.set("KRA", "pki_ds_database", "ipaca") config.set("KRA", "pki_ds_create_new_db", "False") self._use_ldaps_during_spawn(config) # Certificate subject DNs config.set("KRA", "pki_subsystem_subject_dn", str(DN(('cn', 'CA Subsystem'), self.subject_base))) config.set("KRA", "pki_sslserver_subject_dn", str(DN(('cn', self.fqdn), self.subject_base))) config.set("KRA", "pki_audit_signing_subject_dn", str(DN(('cn', 'KRA Audit'), self.subject_base))) config.set( "KRA", "pki_transport_subject_dn", str(DN(('cn', 'KRA Transport Certificate'), self.subject_base))) config.set( "KRA", "pki_storage_subject_dn", str(DN(('cn', 'KRA Storage Certificate'), self.subject_base))) # Certificate nicknames # Note that both the server certs and subsystem certs reuse # the ca certs. config.set("KRA", "pki_subsystem_nickname", "subsystemCert cert-pki-ca") config.set("KRA", "pki_sslserver_nickname", "Server-Cert cert-pki-ca") config.set("KRA", "pki_audit_signing_nickname", "auditSigningCert cert-pki-kra") config.set("KRA", "pki_transport_nickname", "transportCert cert-pki-kra") config.set("KRA", "pki_storage_nickname", "storageCert cert-pki-kra") # Shared db settings # Needed because CA and KRA share the same database # We will use the dbuser created for the CA config.set("KRA", "pki_share_db", "True") config.set( "KRA", "pki_share_dbuser_dn", str(DN(('uid', 'pkidbuser'), ('ou', 'people'), ('o', 'ipaca')))) if not (os.path.isdir(paths.PKI_TOMCAT_ALIAS_DIR) and os.path.isfile(paths.PKI_TOMCAT_PASSWORD_CONF)): # generate pin which we know can be used for FIPS NSS database pki_pin = ipautil.ipa_generate_password() config.set("KRA", "pki_pin", pki_pin) else: pki_pin = None _p12_tmpfile_handle, p12_tmpfile_name = tempfile.mkstemp(dir=paths.TMP) if self.clone: krafile = self.pkcs12_info[0] shutil.copy(krafile, p12_tmpfile_name) pent = pwd.getpwnam(self.service_user) os.chown(p12_tmpfile_name, pent.pw_uid, pent.pw_gid) # Security domain registration config.set("KRA", "pki_security_domain_hostname", self.fqdn) config.set("KRA", "pki_security_domain_https_port", "443") config.set("KRA", "pki_security_domain_user", self.admin_user) config.set("KRA", "pki_security_domain_password", self.admin_password) # Clone config.set("KRA", "pki_clone", "True") config.set("KRA", "pki_clone_pkcs12_path", p12_tmpfile_name) config.set("KRA", "pki_clone_pkcs12_password", self.dm_password) config.set("KRA", "pki_clone_setup_replication", "False") config.set( "KRA", "pki_clone_uri", "https://%s" % ipautil.format_netloc(self.master_host, 443)) else: # the admin cert file is needed for the first instance of KRA cert = self.get_admin_cert() # First make sure that the directory exists parentdir = os.path.dirname(paths.ADMIN_CERT_PATH) if not os.path.exists(parentdir): os.makedirs(parentdir) with open(paths.ADMIN_CERT_PATH, "wb") as admin_path: admin_path.write( base64.b64encode(cert.public_bytes(x509.Encoding.DER))) # Generate configuration file with open(cfg_file, "w") as f: config.write(f) try: DogtagInstance.spawn_instance(self, cfg_file, nolog_list=(self.dm_password, self.admin_password, pki_pin, tmp_agent_pwd)) finally: os.remove(p12_tmpfile_name) os.remove(cfg_file) os.remove(admin_p12_file) shutil.move(paths.KRA_BACKUP_KEYS_P12, paths.KRACERT_P12) logger.debug("completed creating KRA instance")
def write_acserver_config(self, preset): config = RawConfigParser() config.optionxform = str cfg_file = open(os.path.join(self.acserver_config_dir, 'server_cfg.ini'), 'w') config.add_section('SERVER') # build a distinct list of car names car_list = [] for driver in preset.entry_set.all(): if driver.car.dirname not in car_list: car_list.append(driver.car.dirname) # set max_clients value to the track's pitbox value if null if not preset.max_clients: preset.max_clients = preset.track.pitboxes config.set('SERVER', 'NAME', preset.server_setting.name) config.set('SERVER', 'CARS', ';'.join(car_list)) config.set('SERVER', 'CONFIG_TRACK', xstr(preset.track.subversion)) config.set('SERVER', 'TRACK', preset.track.dirname) config.set('SERVER', 'SUN_ANGLE', time_to_sun_angle(preset.time_of_day)) config.set('SERVER', 'PASSWORD', str(preset.session_password)) config.set('SERVER', 'ADMIN_PASSWORD', str(preset.server_setting.admin_password)) config.set('SERVER', 'UDP_PORT', str(preset.server_setting.udp_port)) config.set('SERVER', 'TCP_PORT', str(preset.server_setting.tcp_port)) config.set('SERVER', 'HTTP_PORT', str(preset.server_setting.http_port)) config.set('SERVER', 'PICKUP_MODE_ENABLED', str(int(preset.pickup_mode_enabled))) config.set('SERVER', 'LOOP_MODE', str(int(preset.loop_mode))) config.set('SERVER', 'SLEEP_TIME', '1') config.set('SERVER', 'CLIENT_SEND_INTERVAL', str(preset.server_setting.client_send_interval)) config.set('SERVER', 'SEND_BUFFER_SIZE', str(preset.server_setting.send_buffer_size)) config.set('SERVER', 'RECV_BUFFER_SIZE', str(preset.server_setting.recv_buffer_size)) config.set('SERVER', 'RACE_OVER_TIME', str(preset.race_over_time)) config.set('SERVER', 'KICK_QUORUM', str(preset.kick_quorum)) config.set('SERVER', 'VOTING_QUORUM', str(preset.voting_quorum)) config.set('SERVER', 'VOTE_DURATION', str(preset.vote_duration)) config.set('SERVER', 'BLACKLIST_MODE', str(preset.blacklist_mode)) config.set('SERVER', 'FUEL_RATE', str(preset.fuel_rate)) config.set('SERVER', 'DAMAGE_MULTIPLIER', str(preset.damage_multiplier)) config.set('SERVER', 'TYRE_WEAR_RATE', str(preset.tyre_wear_rate)) config.set('SERVER', 'ALLOWED_TYRES_OUT', str(preset.allowed_tyres_out)) config.set('SERVER', 'ABS_ALLOWED', str(preset.abs_allowed)) config.set('SERVER', 'TC_ALLOWED', str(preset.tc_allowed)) config.set('SERVER', 'STABILITY_ALLOWED', str(int(preset.stability_allowed))) config.set('SERVER', 'AUTOCLUTCH_ALLOWED', str(int(preset.autoclutch_allowed))) config.set('SERVER', 'TYRE_BLANKETS_ALLOWED', str(int(preset.tyre_blankets_allowed))) config.set('SERVER', 'FORCE_VIRTUAL_MIRROR', str(int(preset.force_virtual_mirror))) config.set('SERVER', 'REGISTER_TO_LOBBY', '1') config.set('SERVER', 'MAX_CLIENTS', str(preset.max_clients)) config.set('SERVER', 'UDP_PLUGIN_LOCAL_PORT', '11000') config.set('SERVER', 'UDP_PLUGIN_ADDRESS', '127.0.0.1:12000') config.set('SERVER', 'AUTH_PLUGIN_ADDRESS', '127.0.0.1:50041/acauth?timeout=300&andurl1=www.minorating.com%3A805/minodata/auth/' + preset.server_setting.minorating_grade + '/') config.set('SERVER', 'LEGAL_TYRES', 'V;E;HR;ST') config.set('SERVER', 'START_RULE', str(preset.start_rule)) config.set('SERVER', 'QUALIFY_MAX_WAIT_PERC', str(preset.qualify_max_wait_perc)) if preset.server_setting.welcome_message: config.set('SERVER', 'WELCOME_MESSAGE', str(os.path.join(self.acserver_config_dir, 'welcome_message.txt'))) if preset.practice_time != 0: config.add_section('PRACTICE') config.set('PRACTICE', 'NAME', 'Free Practice') config.set('PRACTICE', 'TIME', str(preset.practice_time)) config.set('PRACTICE', 'IS_OPEN', str(int(preset.practice_is_open))) if preset.qualify_time != 0: config.add_section('QUALIFY') config.set('QUALIFY', 'NAME', 'Qualify') config.set('QUALIFY', 'TIME', str(preset.qualify_time)) config.set('QUALIFY', 'IS_OPEN', str(int(preset.qualify_is_open))) if preset.race_laps != 0: config.add_section('RACE') config.set('RACE', 'NAME', 'Race') config.set('RACE', 'LAPS', str(preset.race_laps)) config.set('RACE', 'WAIT_TIME', str(preset.race_wait_time)) config.set('RACE', 'IS_OPEN', str(preset.race_is_open)) if preset.track_dynamism: config.add_section('DYNAMIC_TRACK') config.set('DYNAMIC_TRACK', 'SESSION_START', str(preset.track_dynamism.session_start)) config.set('DYNAMIC_TRACK', 'RANDOMNESS', str(preset.track_dynamism.randomness)) config.set('DYNAMIC_TRACK', 'SESSION_TRANSFER', str(preset.track_dynamism.session_transfer)) config.set('DYNAMIC_TRACK', 'LAP_GAIN', str(preset.track_dynamism.lap_gain)) weather_count = 0 for weather in preset.weathers.all(): weather_section = 'WEATHER_' + str(weather_count) config.add_section(weather_section) config.set(weather_section, 'GRAPHICS', weather.graphics) config.set(weather_section, 'BASE_TEMPERATURE_AMBIENT', str(weather.base_temperature_ambient)) config.set(weather_section, 'VARIATION_AMBIENT', str(weather.variation_ambient)) config.set(weather_section, 'BASE_TEMPERATURE_ROAD', str(weather.base_temperature_road)) config.set(weather_section, 'VARIATION_ROAD', str(weather.variation_road)) weather_count += 1 config.write(cfg_file, space_around_delimiters=False) cfg_file.close()
def __init__(self, monolithe_config, api_info): """ Initializes a _JavaSDKAPIVersionFileWriter """ super(APIVersionWriter, self).__init__(package="monolithe.generators.lang.vro") self.api_version = api_info["version"] self._api_version_string = SDKUtils.get_string_version( self.api_version) self.api_root = api_info["root"] self.api_prefix = api_info["prefix"] self.monolithe_config = monolithe_config self._output = self.monolithe_config.get_option( "output", "transformer") self._name = self.monolithe_config.get_option("name", "transformer") self._class_prefix = "" self._product_accronym = self.monolithe_config.get_option( "product_accronym") self._product_name = self.monolithe_config.get_option("product_name") self._url = self.monolithe_config.get_option("url", "transformer") self._package_prefix = self._get_package_prefix(self._url) self._package_name = self._package_prefix + ".vro." + self._name self._package_subdir = self._package_name.replace('.', '/') self.output_directory = "%s/vro" % (self._output) self.override_folder = os.path.normpath("%s/__overrides" % self.output_directory) self.fetchers_path = "/fetchers/" self.enums_path = "/enums/" self.attrs_defaults = RawConfigParser() path = "%s/vro/__attributes_defaults/attrs_defaults.ini" % self._output self.attrs_defaults.optionxform = str self.attrs_defaults.read(path) self.inventory_entities = RawConfigParser() path = "%s/vro/__attributes_defaults/inventory_entities.ini" % self._output self.inventory_entities.optionxform = str self.inventory_entities.read(path) self.workflow_attrs = RawConfigParser() path = "%s/vro/__attributes_defaults/workflow_attrs.ini" % self._output self.workflow_attrs.optionxform = str self.workflow_attrs.read(path) self.attrs_types = RawConfigParser() path = "%s/vro/__attributes_defaults/attrs_types.ini" % self._output self.attrs_types.optionxform = str self.attrs_types.read(path) plugin_info = RawConfigParser() path = "%s/vro/__attributes_defaults/plugin.ini" % self._output plugin_info.optionxform = str plugin_info.read(path) self.plugin_version = plugin_info.get(self.api_version, "pluginVersion") workflow_info = RawConfigParser() path = "%s/vro/__attributes_defaults/workflow.ini" % self._output workflow_info.optionxform = str workflow_info.read(path) self.workflow_version = workflow_info.get(self.api_version, "workflowVersion") with open("%s/vro/__code_header" % self._output, "r") as f: self.header_content = f.read()
def find(self, dimension): """Return the display unit for a particular dimension. **Parameters:** - *dimension*: Dictionary of base dimensions and exponents **Returns:** The display unit as a string """ return '.'.join([self[base][1] if exp == 1 else self[base][1] + str(exp) for base, exp in dimension.items()]) # Load the default display units. try: config = RawConfigParser(interpolation=None, inline_comment_prefixes=[';']) except TypeError: config = RawConfigParser() config.optionxform = str # Dimensions are case sensitive. config.read(path.join(dname, 'display.ini')) default_display_units = DisplayUnits(config.items('Default display units')) if __name__ == '__main__': # Test the contents of this file. import doctest doctest.testmod()
{{ agent }}.sinks.{{ name }}_sink.hdfs.minBlockReplicas = 1 {{ agent }}.sinks.{{ name }}_sink.hdfs.rollInterval = 0 {{ agent }}.sinks.{{ name }}_sink.hdfs.rollSize = 0 {{ agent }}.sinks.{{ name }}_sink.hdfs.rollCount = 0 {{ agent }}.sinks.{{ name }}_sink.hdfs.idleTimeout = 5 {{ agent }}.sinks.{{ name }}_sink.hdfs.filePrefix = %{basename} {{ agent }}.channels.{{ name }}_ch.type = memory ############################################################### ############################################################### {% endfor %} ''' if len(argv) > 1: config = argv[1] else: print('#Set Config File to flume_source_sink.ini') config = 'conf_template/flume_source_sink.ini' config_info = RawConfigParser() config_info.optionxform = str config_info.read(config) dirdict = { name: dict(info) for name, info in dict(config_info).items() if name != 'DEFAULT' } agent = config_info['DEFAULT']['agent'] flume_template = Template(text) rt = flume_template.render(agent=agent, dirdict=dirdict) stdout.write(rt)