def __init__(self, datadir, name="DistUpgrade.cfg",
override_dir=None, defaults_dir=None):
SafeConfigParser.__init__(self)
# we support a config overwrite, if DistUpgrade.cfg.dapper exists
# and the user runs dapper, that one will be used
from_release = subprocess.Popen(
["lsb_release", "-c", "-s"], stdout=subprocess.PIPE,
universal_newlines=True).communicate()[0].strip()
self.datadir = datadir
if os.path.exists(name + "." + from_release):
name = name + "." + from_release
maincfg = os.path.join(datadir, name)
# defaults are read first
self.config_files = []
if defaults_dir:
for cfg in glob.glob(defaults_dir + "/*.cfg"):
self.config_files.append(cfg)
# our config file
self.config_files += [maincfg]
# overrides are read later
if override_dir is None:
override_dir = CONFIG_OVERRIDE_DIR
if override_dir is not None:
for cfg in glob.glob(override_dir + "/*.cfg"):
self.config_files.append(cfg)
self.read(self.config_files)
def __init__(self, keyring_name='ofxclient',
keyring_available=KEYRING_AVAILABLE, **kwargs):
ConfigParser.__init__(self, interpolation = None)
self.keyring_name = keyring_name
self.keyring_available = keyring_available
self._unsaved = {}
self.keyring_name = keyring_name
def __init__(self, config_file=None):
ConfigParser.__init__(self)
self.config_file = config_file
if config_file is not None:
self.read(config_file)
def __init__(self, filename=None):
SafeConfigParser.__init__(self)
self.filename = filename
self.tags = dict()
self.autoload()
def __init__(self, fname, name):
if sys.version_info.major >= 3:
super(SettingsFile, self).__init__()
else:
ConfigParser.__init__(self)
self.fname = fname
self.name = name
def __init__(self, filename):
ConfigParser.__init__(self, {'client_token': '', 'client_secret':'', 'host':'', 'access_token':'','max_body': '131072', 'headers_to_sign': 'None'})
logger.debug("loading edgerc from %s", filename)
self.read(filename)
logger.debug("successfully loaded edgerc")
def __init__(self, parsetFile):
ConfigParser.__init__(self, inline_comment_prefixes=('#',';'))
config = StringIO()
# add [_global] fake section at beginning
config.write('[_global]\n'+open(parsetFile).read())
config.seek(0, os.SEEK_SET)
self.readfp(config)
def __init__(self):
"""Constructor : init a new config parser
"""
ConfigParser.__init__(self)
self.optionxform = str
# boolean that indicates if the configparser is available
self.__is_config_loaded = False
def __init__(self, filename):
ConfigParser.__init__(self, {'max_body': '2048', 'headers_to_sign': None})
logger.debug("loading edgerc from %s", filename)
self.read(filename)
self.validate()
logger.debug("successfully loaded edgerc")
def __init__(self):
ConfigParser.__init__(self)
self.id = None
self.name = None
self.on = False
self.force = False
self.ttl = 365
self.sleep = 0
def __init__(self):
ConfigParser.__init__(self, self.DEFAULTS[0]['keys'])
if not os.path.isdir(self.CONFIGDIR):
os.makedirs(self.CONFIGDIR)
if not os.path.isfile(self.CONFIGFILE):
self.create_default()
self.write()
self.read(self.CONFIGFILE)
def __init__(self, filename):
# let's read the file
ConfigParser.__init__(self, **self._configparser_kwargs())
if isinstance(filename, string_types):
self.filename = filename
self.read(filename)
else:
self.filename = None
self.read_file(filename)
def __init__(self, filename):
ConfigParser.__init__(self)
# let's read the file
if isinstance(filename, basestring):
self.filename = filename
self.read(filename)
else: # pragma: no cover
self.filename = None
self.read_file(filename)
def __init__(self, *args, **kwargs):
if sys.version_info[0] == 2:
if sys.version_info[:2] >= (2, 6):
# SafeConfigParser(dict_type=) supported in 2.6+
kwargs["dict_type"] = SortedDict
ConfigParser.__init__(self, *args, **kwargs)
else:
kwargs["dict_type"] = SortedDict
super(ConfigParser, self).__init__(*args, **kwargs)
self.seen = set()
def parse_config_files(self, filenames=None):
from configparser import ConfigParser
# Ignore install directory options if we have a venv
if sys.prefix != sys.base_prefix:
ignore_options = [
'install-base', 'install-platbase', 'install-lib',
'install-platlib', 'install-purelib', 'install-headers',
'install-scripts', 'install-data', 'prefix', 'exec-prefix',
'home', 'user', 'root']
else:
ignore_options = []
ignore_options = frozenset(ignore_options)
if filenames is None:
filenames = self.find_config_files()
if DEBUG:
self.announce("Distribution.parse_config_files():")
parser = ConfigParser()
for filename in filenames:
if DEBUG:
self.announce(" reading %s" % filename)
parser.read(filename)
for section in parser.sections():
options = parser.options(section)
opt_dict = self.get_option_dict(section)
for opt in options:
if opt != '__name__' and opt not in ignore_options:
val = parser.get(section,opt)
opt = opt.replace('-', '_')
opt_dict[opt] = (filename, val)
# Make the ConfigParser forget everything (so we retain
# the original filenames that options come from)
parser.__init__()
# If there was a "global" section in the config file, use it
# to set Distribution options.
if 'global' in self.command_options:
for (opt, (src, val)) in self.command_options['global'].items():
alias = self.negative_opt.get(opt)
try:
if alias:
setattr(self, alias, not strtobool(val))
elif opt in ('verbose', 'dry_run'): # ugh!
setattr(self, opt, strtobool(val))
else:
setattr(self, opt, val)
except ValueError as msg:
raise DistutilsOptionError(msg)
def __init__(self, configfile, nodefaults = False):
"""
Reads settings from INI file, compares with setup defaults,
adds missing settings
:param configfile: path and name of INI file
:param nodefaults: if true, no defaults are written to the INI file,
also, if INI is missing, none will be created
"""
# parse settings ONLY for first time initialization of
# configuration object, never read twice unnecessary
if ConfigHandler.cfg is None:
ConfigParser.__init__(self, interpolation=None)
self.configfile = configfile
self.nodefaults = nodefaults
# read settings
self.logger.debug("Trying to read configuration file: " + self.configfile)
try:
with open(self.configfile) as file:
self.read_file(file)
self.logger.info("Configuration file successfully loaded.")
except IOError:
self.logger.error("Configuration file could not be loaded.")
# apply new/missing defaults
if not self.nodefaults:
for section, options in self._initial_settings.items():
if not self.has_section(section):
self.add_section(section)
for option, value in options.items():
if not self.has_option(section, option):
self.set(section, option, str(value))
# check if INI pre-python
if LooseVersion(self.prg_version) < "8.0.0":
self.convert_old_format()
if LooseVersion(self.prg_version) < "8.2.5":
self.convert_to_opsi41()
# check current version to version in INI file
if LooseVersion(self.get("version", "ini")) < oPB.PROGRAM_VERSION:
self.logger.debug("Old version: " + self.prg_version)
self.logger.debug("Current version: " + oPB.PROGRAM_VERSION)
self.prg_version = oPB.PROGRAM_VERSION
# get usable passwords, if there are any
self.passwords('decrypt')
# after all, save parser in class variabel
ConfigHandler.cfg = self
def __init__(self, keyring_name='ofxclient',
keyring_available=KEYRING_AVAILABLE, **kwargs):
if sys.version_info >= (3,):
# python 3
ConfigParser.__init__(self, interpolation=None)
else:
# python 2
ConfigParser.__init__(self)
self.keyring_name = keyring_name
self.keyring_available = keyring_available
self._unsaved = {}
self.keyring_name = keyring_name
def __init__(self, config_dir=None):
ConfigParser.__init__(self, CONFIG_DEFAULTS)
self.changed = False # Flag for self.config changed status
self.delay_save_timeout = 10
if config_dir is not None:
self.config_dir = config_dir
if not os.path.exists(self.config_dir):
os.makedirs(self.config_dir)
self.config_fname = os.path.join(self.config_dir, self.config_fname)
self.load_config()
def __init__(self, defaults=None, *args, **kwargs):
configparser.__init__(self, defaults=None, *args, **kwargs)
# Improved defaults handling
if isinstance(defaults, dict):
for section, values in defaults.items():
# Break out original format defaults was passed in
if not isinstance(values, dict):
break
if section not in self.sections():
self.add_section(section)
for name, value in values.items():
self.set(section, name, str(value))
def __init__(self, filename):
"""
A :class:`configparser.ConfigParser` subclass with added
functionality.
:param filename: The path to a configuration file.
"""
ConfigParser.__init__(self)
# let's read the file
if isinstance(filename, string_types):
self.filename = filename
self.read(filename)
else: # pragma: no cover
self.filename = None
self.read_file(filename)
def __init__(self, conf_file):
try:
super(PipeConfig, self).__init__()
except TypeError:
ConfigParser.__init__(self) # Python 2.7
self.conf_file = conf_file
try:
self.readfp(open(self.conf_file), 'r') # deprecated but kept for 2.7
except IOError as Err:
if Err.errno == 2:
pass
else:
raise Err
def __init__(self, config_path="~/.msort.conf"):
""" Initialize the configuration. If a existing one doesnt exit a new one will be created
in, by default, the users home directory, unless otherwise specified by the configPath
parameter
:param config_path: Location of the config file
:type config_path: str
"""
ConfigParser.__init__(self)
self.log = getLogger(__name__)
config_path = expanduser(config_path)
if not exists(config_path):
raise ConfigError('Invalid config file, doesnt exist: {0}'.format(config_path))
self.log.debug('Reading config: {0}'.format(config_path))
self.read(config_path)
self._rules = self.parseRules()
def __init__(self):
self.fname = os.path.expanduser('~/.gvoice')
if not os.path.exists(self.fname):
try:
f = open(self.fname, 'w')
except IOError:
return
f.write(settings.DEFAULT_CONFIG)
f.close()
ConfigParser.__init__(self)
try:
self.read([self.fname])
except IOError:
return
def __init__(self):
self.logger = logging.getLogger('dcamp.types.config')
ConfigParser.__init__(self, allow_no_value=True, delimiters='=')
self.isvalid = False
self.__num_errors = 0
self.__num_warns = 0
self.global_cfg = {}
self.metrics = {}
self.groups = {}
self.kvdict = {}
self.metric_sections = {}
self.group_sections = {}
def parse_config_files(self, filenames=None):
from configparser import ConfigParser
if filenames is None:
filenames = self.find_config_files()
if DEBUG:
self.announce("Distribution.parse_config_files():")
parser = ConfigParser()
for filename in filenames:
if DEBUG:
self.announce(" reading %s" % filename)
parser.read(filename)
for section in parser.sections():
options = parser.options(section)
opt_dict = self.get_option_dict(section)
for opt in options:
if opt != '__name__':
val = parser.get(section,opt)
opt = opt.replace('-', '_')
opt_dict[opt] = (filename, val)
# Make the ConfigParser forget everything (so we retain
# the original filenames that options come from)
parser.__init__()
# If there was a "global" section in the config file, use it
# to set Distribution options.
if 'global' in self.command_options:
for (opt, (src, val)) in self.command_options['global'].items():
alias = self.negative_opt.get(opt)
try:
if alias:
setattr(self, alias, not strtobool(val))
elif opt in ('verbose', 'dry_run'): # ugh!
setattr(self, opt, strtobool(val))
else:
setattr(self, opt, val)
except ValueError as msg:
raise DistutilsOptionError(msg)
def __init__(self, configfile=None):
""" Check the config file and include the defaults. """
self.CONFIG_FILES = DEFAULT_CFG_FILES
if configfile is not None:
if not os.path.exists(configfile):
raise IOError("Configuration File does not exist.")
self.CONFIG_FILES.append(configfile)
## now set up the parent class using defaults ##
ConfigParser.__init__(self)
#reset internal configparser variable...
if sys.version_info[0]==3 and sys.version_info[1]<2:
# i know thats bad form, but this is what happens when
# you dont think ahead
self._sections=DEFAULT_CONFIGS
else:
#this is in python3.2+ only
self.read_dict(DEFAULT_CONFIGS)
def __init__(self):
ConfigParser.__init__(self, allow_no_value = True)
self.optionxform = str
self.read('config.ini', encoding='utf-8')
self.check()
self.defaults = """
[Hotkeys]
Exit = Ctrl+X
Fullscreen = F
Next = Right
Previous = Left
Directory = D
Slideshow = F3
Zoom in = Ctrl++
Zoom out = Ctrl+-
Zoom original = Ctrl+0
"""
self.locale_code = ['en_US', 'de_DE', 'ja_JP', 'vi_VN']
self._update_funcs = []
def __init__(self, iniFile):
"""Initializes a new configuration instance and sets appropriate default values."""
SafeConfigParser.__init__(self, allow_no_value = True)
self.iniFileName = iniFile
self.read(iniFile)
self.defaults = { }
self.applyDefaults({
'libartos' : {
'model_dir' : _Config.findModelDir(),
'library_path' : None,
'debug' : 0,
},
'ImageNet' : {
'repository_directory' : None
},
'GUI' : {
'max_video_width' : 640,
'max_video_height' : 480
}
});
def __init__(self, name, config_path=DEFAULT_PATH, cfg_ext=DEFAULT_CFG_EXT, default_ext=DEFAULT_DEFAULT_EXT):
"""
Create new MyConfigParser that extends ConfigParser.SafeConfigParser
@param name: name of the config to look for and load
@param config_path: path where to find the config files. Sort by order of importance.
This will be used to first load default configuration and fail in there isn't any.
Then it will load all user configurations in the respecting order of the list. Overriding default and previous user configuration.
@param cfg_ext: extension for the user configuration file.
@param default_ext: extension for the default configuration file.
@raise MyConfigParserException: if no default configuration found.
"""
ConfigParser.__init__(self)
self.name = name
self.cfg_filename = name + cfg_ext
self.default_filename = name + default_ext
self.config_path = config_path
if not hasattr(self.config_path, "__iter__"):
LOGGER.debug("[%s] convert single config_path to set" % self.name)
self.config_path = (config_path, )
LOGGER.debug("[%s] remove duplicate configuration path" % self.name)
self.config_path = list(set(self.config_path))
LOGGER.debug("[%s] find and load default cfg file" % self.name)
# in list order to respect path importance
for path in self.config_path:
full_path = join(path, self.default_filename)
if isfile(full_path):
self.default_path = full_path
LOGGER.debug("[%s] default_path = %s" % (self.name, self.default_path))
break
else:
raise MyConfigParserException(self.name, "Couldn't find default config file")
# call reload
self.reload()
def __init__(self):
ConfigParser.__init__(self,description="Configuration options description")
self.add_option('fetchto', default=None, help="Destination for fetched modules", type='')
#self.add_option('root_module', default=None, help="Path to root module for currently parsed", type='')
self.add_delimiter()
self.add_option('syn_name', default=None, help="Name of the folder at remote synthesis machine", type='')
self.add_option('syn_device', default=None, help = "Target FPGA device", type = '');
self.add_option('syn_grade', default=None, help = "Speed grade of target FPGA", type = '');
self.add_option('syn_package', default=None, help = "Package variant of target FPGA", type = '');
self.add_option('syn_top', default=None, help = "Top level module for synthesis", type = '');
self.add_option('syn_project', default=None, help = "Project file (.xise, .ise, .qpf)", type = '');
self.add_delimiter()
self.add_option('include_dirs', default=None, help="Include dirs for Verilog sources", type = [])
self.add_type('include_dirs', type = "")
self.add_delimiter()
# Modification here!
# self.add_option('sim_tool', default=None, help = "Simulation tool to be used (isim/vsim)", type = '');
self.add_option('vsim_opt', default="", help="Additional options for vsim", type='')
self.add_option('vcom_opt', default="", help="Additional options for vcom", type='')
self.add_option('vlog_opt', default="", help="Additional options for vlog", type='')
self.add_option('vmap_opt', default="", help="Additional options for vmap", type='')
self.add_delimiter()
self.add_option('modules', default={}, help="List of local modules", type={})
self.add_option('target', default=None, help="What is the target architecture", type='')
self.add_option('action', default=None, help="What is the action that should be taken (simulation/synthesis)", type='')
self.add_allowed_key('modules', key="svn")
self.add_allowed_key('modules', key="git")
self.add_allowed_key('modules', key="local")
#self.add_delimiter()
self.add_option('library', default="work",
help="Destination library for module's VHDL files", type="")
self.add_option('files', default=[], help="List of files from the current module", type='')
self.add_type('files', type=[])
from configparser import ConfigParser
IniParser = type(
'IniParser', (ConfigParser, ), {
'__init__':
lambda self, file:
(ConfigParser.__init__(self), self.read(file, 'utf-8'))[0],
'optionxform':
lambda self, optionstr: optionstr
})
def __init__(self, share_config=None, *args, **kwargs):
SafeConfigParser.__init__(self, *args, **kwargs)
self._cfg_share = share_config
def __init__(self, working_dir=None):
ConfigParser.__init__(self, converters=converters, interpolation=ExtendedInterpolation())
self.read(CONFIG_FILE_PATH)
self._cache = {}
self._working_dir = os.path.dirname(__file__) if working_dir is None else working_dir
def __init__(self, path):
ConfigParser.__init__(
self) # ConfigParser is an old-style class... Can't user 'super'
self.path = path
self.readfp(ConfigHeader(open(path)))
def __init__(self, *args, **kwargs):
ConfigParser.__init__(self, *args, **kwargs)
def __init__(self, path: str):
ConfigParser.__init__(self)
self.file = os.path.join(path, 'config_temp.ini')
self.read([self.file])
self.set_property('runtime', 'last_use',
str(datetime.datetime.utcnow()))
def __init__(self, defaults, *args, **kwargs):
self.defaults = defaults
ConfigParser.__init__(self, *args, **kwargs)
def __init__(self, file_path, *args, **kwargs):
ConfigParser.__init__(self, *args, **kwargs)
self.file_path = file_path
if os.path.exists(file_path):
self.read(file_path)
def __init__(self, filepath):
ConfigParser.__init__(self)
self.filepath = filepath
if exists(filepath):
self.read(filepath)
def __init__(self, default_config, *args, **kwargs):
ConfigParser.__init__(self, *args, **kwargs)
if default_config is not None:
self.read_string(default_config)
def __init__(self):
ConfigParser.__init__(self, interpolation=ExtendedInterpolation())
if not sys.gettrace():
self.read([self.PATH_ENV, self.PATH_INI])
else:
self.read([self.PATH_ENV_DEBUG, self.PATH_INI_DEBUG])
def __init__(self):
ConfigParser.__init__(self)
self.read(
self.CONFIG_FILE if not sys.gettrace() else self.CONFIG_FILE_DEV)
def __init__(self, defaults={}):
ConfigParser.__init__(self)
self.defaults = defaults
def __init__(self, *args, **kwargs):
BetterLogger.__init__(self)
ConfigParser.__init__(self, *args, **kwargs)
def __init__(self, defaults, *args, **kwargs):
self.defaults = defaults
ConfigParser.__init__(self, *args, **kwargs)
self.is_validated = False
def _parse_config_files(self, filenames=None): # noqa: C901
"""
Adapted from distutils.dist.Distribution.parse_config_files,
this method provides the same functionality in subtly-improved
ways.
"""
from configparser import ConfigParser
# Ignore install directory options if we have a venv
ignore_options = (
[]
if sys.prefix == sys.base_prefix
else [
'install-base',
'install-platbase',
'install-lib',
'install-platlib',
'install-purelib',
'install-headers',
'install-scripts',
'install-data',
'prefix',
'exec-prefix',
'home',
'user',
'root',
]
)
ignore_options = frozenset(ignore_options)
if filenames is None:
filenames = self.find_config_files()
if DEBUG:
self.announce("Distribution.parse_config_files():")
parser = ConfigParser()
parser.optionxform = str
for filename in filenames:
with io.open(filename, encoding='utf-8') as reader:
if DEBUG:
self.announce(" reading {filename}".format(**locals()))
parser.read_file(reader)
for section in parser.sections():
options = parser.options(section)
opt_dict = self.get_option_dict(section)
for opt in options:
if opt == '__name__' or opt in ignore_options:
continue
val = parser.get(section, opt)
opt = self.warn_dash_deprecation(opt, section)
opt = self.make_option_lowercase(opt, section)
opt_dict[opt] = (filename, val)
# Make the ConfigParser forget everything (so we retain
# the original filenames that options come from)
parser.__init__()
if 'global' not in self.command_options:
return
# If there was a "global" section in the config file, use it
# to set Distribution options.
for (opt, (src, val)) in self.command_options['global'].items():
alias = self.negative_opt.get(opt)
if alias:
val = not strtobool(val)
elif opt in ('verbose', 'dry_run'): # ugh!
val = strtobool(val)
try:
setattr(self, alias or opt, val)
except ValueError as e:
raise DistutilsOptionError(e) from e
def __init__(self, cfgFile, cfgDefaults=None):
"""
cfgFile - string, fully specified configuration file name
"""
self.file = cfgFile
ConfigParser.__init__(self, defaults=cfgDefaults, strict=False)
def __init__(self, defaults=None):
ConfigParser.__init__(self, defaults=defaults)
def __init__(self, path: str):
ConfigParser.__init__(self)
self.file = os.path.join(path, 'config_static.ini')
self.read([self.file])
def __init__(self, defaults=None):
ConfigParser.__init__(self, defaults=defaults)
self.add_sec = "Additional"
def __init__(self, filename):
ConfigParser.__init__(self,
defaults=None) #重写optionxform的方法，让option输出区分大小写
super().__init__()
self.filename = filename
self.read(filename)
def parse_config_files(self, filenames=None):
from configparser import ConfigParser
# Ignore install directory options if we have a venv
if sys.prefix != sys.base_prefix:
ignore_options = [
"install-base",
"install-platbase",
"install-lib",
"install-platlib",
"install-purelib",
"install-headers",
"install-scripts",
"install-data",
"prefix",
"exec-prefix",
"home",
"user",
"root",
]
else:
ignore_options = []
ignore_options = frozenset(ignore_options)
if filenames is None:
filenames = self.find_config_files()
if DEBUG:
self.announce("Distribution.parse_config_files():")
parser = ConfigParser()
for filename in filenames:
if DEBUG:
self.announce(" reading %s" % filename)
parser.read(filename)
for section in parser.sections():
options = parser.options(section)
opt_dict = self.get_option_dict(section)
for opt in options:
if opt != "__name__" and opt not in ignore_options:
val = parser.get(section, opt)
opt = opt.replace("-", "_")
opt_dict[opt] = (filename, val)
# Make the ConfigParser forget everything (so we retain
# the original filenames that options come from)
parser.__init__()
# If there was a "global" section in the config file, use it
# to set Distribution options.
if "global" in self.command_options:
for (opt, (src, val)) in self.command_options["global"].items():
alias = self.negative_opt.get(opt)
try:
if alias:
setattr(self, alias, not strtobool(val))
elif opt in ("verbose", "dry_run"): # ugh!
setattr(self, opt, strtobool(val))
else:
setattr(self, opt, val)
except ValueError as msg:
raise DistutilsOptionError(msg)
def __init__(self, root, defaults=None, macros=None):
ConfigParser.__init__(
self, defaults, empty_lines_in_values=False, strict=False)
if macros is None:
macros = dict()
self._sections = Parser.SectionDict(root, macros)
def __init__(self, cfgFile, cfgDefaults=None):
"""
cfgFile - string, fully specified configuration file name
"""
self.file = cfgFile # This is currently '' when testing.
ConfigParser.__init__(self, defaults=cfgDefaults, strict=False)
def __init__(self):
ConfigParser.__init__(self, dict_type=MultiDict)
def __init__(self, *args, **kwargs):
ConfigParser.__init__(self, *args, **kwargs)
self.read_string(parameterized_config(DEFAULT_CONFIG))
self.is_validated = False
def __init__(self):
ConfigParser.__init__(self)
self.config = ConfigParser()
self.config.read('files\\config.ini')
def __init__(self, config_content=None):
ConfigParser.__init__(self)
self.optionxform = str
if config_content is not None:
self._set_content(config_content)
def __init__(self):
ConfigParser.__init__(self)
def __init__(self, *args, **kwargs):
# supplied by cryptkeeper_access_methods
self.ck = kwargs.pop('ck', None)
ConfigParser.__init__(self, *args, **kwargs)
