def __init__(self, cfg=None):
if cfg:
self._cfg = ConfigParser()
self._cfg.read(cfg)
else:
self._cfg = None
self._session = None
self._session_key = None
def _setup_wrapper(filename, *args):
config = ConfigParser()
config.optionxform = str
config.read(filename)
try:
setup.setup(config, *args)
except OSError:
print("Above 'No module named aup.setupdb' error can be ignored")
def __new__(cls):
ctx, config = cls.ctx_and_config
current_ctx = click.get_current_context(silent=True)
if current_ctx != ctx:
config = ConfigParser()
config.read(cls.filenames)
cls.ctx_and_config = (current_ctx, config)
return config
def _read_config_file(self):
# Read the virt-who-<id> config file)
local_path = tempfile.mkstemp(suffix=self.config_file_name)[1]
ssh.download_file(self.remote_path, local_path, hostname=self.server)
parser = ConfigParser()
with open(local_path) as local_fp:
parser.read_file(local_fp)
return parser
def parse_color_map_from_file(f):
color_map_config = ConfigParser()
if isinstance(f, string_types):
with open(f, 'r') as fp:
color_map_config.read_file(fp)
else:
color_map_config.read_file(f)
return parse_color_map_from_configparser(color_map_config)
def set_config_file(filename):
"""
Change the configuration file.
Use configuration file in non standard location.
"""
global CONFIG_STORE
CONFIG_STORE = ConfigParser()
CONFIG_STORE.read(filename)
def __init__(self, host="127.0.0.1"):
self._host = host
config = ConfigParser()
config.read(constants.get_config_file())
if config.has_option('OpenMotics', 'http_port'):
self._port = config.get('OpenMotics', 'http_port')
else:
self._port = 80
def _get_names_from_config(self, cp, section):
config = ConfigParser()
config.read(cp)
if config.has_section(section):
return [
config.get(section, option)
for option in config.options(section)
]
def __init__(self, filename):
self.config_file = filename.strip()
self.config = dict()
self.parser = ConfigParser()
self.section = u'app:main'
defaults = {u'__file__': os.path.abspath(self.config_file)}
self._update_defaults(defaults)
self._create_config_object()
def parse_xml_mapping(xml_mapping_filename):
with open(xml_mapping_filename, 'r') as f:
config = ConfigParser()
if six.PY3:
config.read_file(f) # pylint: disable=no-member
else:
config.read_file(f)
return {k: dict(config.items(k)) for k in config.sections()}
def reload_storage_policies():
"""
Reload POLICIES from ``swift.conf``.
"""
global _POLICIES
if six.PY2:
policy_conf = ConfigParser()
else:
# Python 3.2 disallows section or option duplicates by default
# strict=False allows us to preserve the older behavior
policy_conf = ConfigParser(strict=False)
policy_conf.read(utils.SWIFT_CONF_FILE)
try:
_POLICIES = parse_storage_policies(policy_conf)
except PolicyError as e:
raise SystemExit('ERROR: Invalid Storage Policy Configuration '
'in %s (%s)' % (utils.SWIFT_CONF_FILE, e))
def __init__(self):
"""Grab the configuration (overridable for test purposes)"""
# If there is a setup.cfg in the package, parse it
if not os.path.exists(self.config_filename):
self.config = None
return
self.config = ConfigParser()
self.config.read(self.config_filename)
def _generate_appdata(self, destdir, prefix, activity_path):
info = ConfigParser()
info_path = os.path.join(destdir, os.path.relpath(activity_path, '/'),
'activity', 'activity.info')
info.read(info_path)
required_fields = [
'metadata_license', 'license', 'name', 'icon', 'description'
]
for name in required_fields:
if not info.has_option('Activity', name):
print('[WARNING] missing AppStream metadata, '
'see `pydoc sugar3.bundle`')
return
# See https://www.freedesktop.org/software/appstream/docs/
root = ET.Element('component', type='desktop')
ET.SubElement(root, 'project_group').text = 'Sugar'
ET.SubElement(root, 'translation', type='gettext').text = \
self.config.bundle_id
ET.SubElement(root, 'id').text = \
self.config.bundle_id + '.activity.desktop'
desc = ET.fromstring('<description>{}</description>'.format(
info.get('Activity', 'description')))
root.append(desc)
copy_pairs = [('metadata_license', 'metadata_license'),
('license', 'project_license'), ('summary', 'summary'),
('name', 'name')]
for key, ename in copy_pairs:
ET.SubElement(root, ename).text = info.get('Activity', key)
if info.has_option('Activity', 'screenshots'):
screenshots = info.get('Activity', 'screenshots').split()
ss_root = ET.SubElement(root, 'screenshots')
for i, screenshot in enumerate(screenshots):
e = ET.SubElement(ss_root, 'screenshot')
if i == 0:
e.set('type', 'default')
ET.SubElement(e, 'image').text = screenshot
if info.has_option('Activity', 'url'):
ET.SubElement(root, 'url', type='homepage').text = \
info.get('Activity', 'url')
if info.has_option('Activity', 'repository_url'):
ET.SubElement(root, 'url', type='bugtracker').text = \
info.get('Activity', 'repository_url')
elif info.has_option('Activity', 'repository'):
ET.SubElement(root, 'url', type='bugtracker').text = \
info.get('Activity', 'repository')
path = os.path.join(destdir, os.path.relpath(prefix, '/'), 'share',
'metainfo', self.config.bundle_id + '.appdata.xml')
if not os.path.isdir(os.path.dirname(path)):
os.makedirs(os.path.dirname(path))
tree = ET.ElementTree(root)
tree.write(path, encoding='UTF-8')
print('Install %s' % (path))
def read_systemini(self):
"""read group info from system.ini
this is part of the connection process
"""
self.ftpconn.connect(**self.ftpargs)
self.ftpconn.cwd(posixpath.join(self.ftphome, 'Config'))
lines = self.ftpconn.getlines('system.ini')
self.ftpconn.close()
pvtgroups = []
self.stages = OrderedDict()
self.groups = OrderedDict()
sconf = ConfigParser()
sconf.readfp(StringIO('\n'.join(lines)))
# read and populate lists of groups first
for gtype, glist in sconf.items('GROUPS'): # ].items():
if len(glist) > 0:
for gname in glist.split(','):
gname = gname.strip()
self.groups[gname] = OrderedDict()
self.groups[gname]['category'] = gtype.strip()
self.groups[gname]['positioners'] = []
if gtype.lower().startswith('multiple'):
pvtgroups.append(gname)
for section in sconf.sections():
if section in ('DEFAULT', 'GENERAL', 'GROUPS'):
continue
items = sconf.options(section)
if section in self.groups: # this is a Group Section!
poslist = sconf.get(section, 'positionerinuse')
posnames = [a.strip() for a in poslist.split(',')]
self.groups[section]['positioners'] = posnames
elif 'plugnumber' in items: # this is a stage
self.stages[section] = {
'stagetype': sconf.get(section, 'stagename')
}
if len(pvtgroups) == 1:
self.set_trajectory_group(pvtgroups[0])
for sname in self.stages:
ret = self._xps.PositionerMaximumVelocityAndAccelerationGet(
self._sid, sname)
try:
self.stages[sname]['max_velo'] = ret[1]
self.stages[sname]['max_accel'] = ret[2] / 3.0
except:
print("could not set max velo/accel for %s" % sname)
ret = self._xps.PositionerUserTravelLimitsGet(self._sid, sname)
try:
self.stages[sname]['low_limit'] = ret[1]
self.stages[sname]['high_limit'] = ret[2]
except:
print("could not set limits for %s" % sname)
return self.groups
def setUpModule():
# Backup local config file if it exists
if os.path.exists(local_cfg):
os.rename(local_cfg, local_cfg + '.bak')
# Re-read the configs
girder_worker.config = ConfigParser()
_cfgs = ('worker.dist.cfg', 'worker.local.cfg')
girder_worker.config.read(
[os.path.join(girder_worker.PACKAGE_DIR, f) for f in _cfgs])
def parse_config_file(file_path):
config = ConfigParser()
config.read(file_path)
if 'batch_scoring' not in config.sections():
# We are return empty dict, because there is nothing in this file
# that related to arguments to batch scoring.
return {}
parsed_dict = dict(config.items('batch_scoring'))
return config_validator(parsed_dict)
def get_options_from_config(config_file):
"""Get configuration information from config like setup.cfg or tox.ini"""
from six.moves.configparser import ConfigParser
conf = ConfigParser()
conf.read([config_file])
if conf.has_section('changelog'):
return dict(conf.items('changelog'))
return {}
def get_app(config='development.ini'):
cfg = PROJECT.joinpath(config)
parser = ConfigParser()
parser.read(cfg)
return glottolog3.main({
'__file__': str(cfg),
'here': str(PROJECT)
}, **{'sqlalchemy.url':
parser.get('app:main', 'sqlalchemy.url')})
def get_configuration_dict(configuration=None, value_types=None):
"""
Parse the configuration files
Parameters
----------
configuration : str or list, optional
A configuration file or list of configuration files to parse,
defaults to the deploy_default.conf file in the package and
deploy.conf in the current working directory.
value_types : dict, optional
Dictionary containing classes to apply to specific items
Returns
-------
dict
Configuration dictionary
"""
if not value_types: # pragma: no cover
value_types = config_types()
if configuration is None or configuration is '': # pragma: no cover
configuration = [
# Config file that is part of the package
# PACKAGE_DEFAULT_CONFIG,
# Any deploy.conf files in the current directory
'deploy.conf'
]
config = ConfigParser()
# Set the config defaults
try:
config.read_string(config_defaults())
except AttributeError:
config.readfp(io.BytesIO(config_defaults()))
logger.debug('Working with default dict: %r', config_defaults())
config.read(configuration)
result_dict = {}
for section in config.sections():
result_dict[section] = {}
for key, val in config.items(section):
result_dict[section][key] = str_format_env(val)
config_update(result_dict)
if 'locations' not in result_dict.keys():
result_dict['locations'] = {}
result_dict['locations']['package_scripts'] = package_scripts_directory()
if not result_dict['global'].get('virtualenv_dir', None):
result_dict['global']['virtualenv_dir'] = \
default_virtualenv_directory()
cast_types(result_dict)
return result_dict
def _parseINI(text):
from six.moves import cStringIO
from six.moves.configparser import ConfigParser
parser = ConfigParser()
try:
parser.read_file(cStringIO(text))
except AttributeError: # Python 2
parser.readfp(cStringIO(text))
return parser
def main():
# Setup an argparser and parse the known commands to get the config file
parser = argparse.ArgumentParser(add_help=False)
parser.add_argument('-C',
'--config',
help='Specify a config file to use',
default='/etc/rpkg/rfpkg.conf')
(args, other) = parser.parse_known_args()
# Make sure we have a sane config file
if not os.path.exists(args.config) and \
not other[-1] in ['--help', '-h', 'help']:
sys.stderr.write('Invalid config file %s\n' % args.config)
sys.exit(1)
# Setup a configuration object and read config file data
config = ConfigParser()
config.read(args.config)
client = rfpkg.cli.rfpkgClient(config)
client.do_imports(site='rfpkg')
client.parse_cmdline()
if not client.args.path:
try:
client.args.path = pyrpkg.utils.getcwd()
except:
print('Could not get current path, have you deleted it?')
sys.exit(1)
# setup the logger -- This logger will take things of INFO or DEBUG and
# log it to stdout. Anything above that (WARN, ERROR, CRITICAL) will go
# to stderr. Normal operation will show anything INFO and above.
# Quiet hides INFO, while Verbose exposes DEBUG. In all cases WARN or
# higher are exposed (via stderr).
log = pyrpkg.log
client.setupLogging(log)
if client.args.v:
log.setLevel(logging.DEBUG)
elif client.args.q:
log.setLevel(logging.WARNING)
else:
log.setLevel(logging.INFO)
# Run the necessary command
try:
sys.exit(client.args.command())
except KeyboardInterrupt:
pass
except Exception as e:
log.error('Could not execute %s: %s' %
(client.args.command.__name__, e))
if client.args.v:
raise
sys.exit(1)
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
_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))
# Explicit unitless 'unit'.
_new_unit('unitless', 1, list(base_list))
_update_library(_UNIT_LIB)
return _UNIT_LIB
def read_test_config():
"""Reads the test_values config file."""
config = ConfigParser()
config_file = os.sep.join([os.path.dirname(__file__), 'test_values.conf'])
config_readme = os.sep.join([os.path.dirname(__file__), 'README'])
if not os.path.isfile(config_file):
raise Exception('Integration test config file missing. See setup instructions in {}'.format(config_readme))
config.read(config_file)
return config
def get_ol(server):
config = ConfigParser()
config.read(os.path.expanduser('~/.olrc'))
ol = olapi.OpenLibrary(server)
username = config.get('account', 'username')
password = config.get('account', 'password')
ol.login(username, password)
return ol
def test_list_with_no_entries(self):
name = self.make_empty_temp_file()
to_config_file(name, "section.name", {"ports": []})
self.assertTrue(os.path.isfile(name))
config = ConfigParser()
config.read(name)
self.assertEqual("", config.get("section.name", "ports"))
def __init__(self):
"""Grab the configuration (overridable for test purposes)"""
# If there is a setup.cfg in the package, parse it
if not os.path.exists(self.config_filename):
self.config = None
return
self.config = ConfigParser()
with codecs.open(self.config_filename, 'r', 'utf8') as fp:
self.config.readfp(fp)
def handleApps(self, **kwargs):
l10nbuilds = urlopen(
'https://raw.githubusercontent.com/Pike/master-ball/'
'master/l10n-master/l10nbuilds.ini')
cp = ConfigParser()
cp.readfp(l10nbuilds)
for section in cp.sections():
self.stdout.write(section + '\n')
self.handleSection(section, dict(cp.items(section)))
def __init__(self):
self.configparser = ConfigParser()
if len(self.configparser.read(self.PYQUIL_CONFIG_PATH)) == 0:
print("! WARNING:\n"
"! There was an issue finding your pyQuil config file.\n"
"! Have you run the pyquil-config-setup command yet?\n"
"! See the getting started guide at https://go.rigetti.com/getting-started",
file=sys.stderr)
def read_param_file(self):
"""Read the parameter file and populate the relevant dictionaries
"""
self.out_values = []
# read the file
params = ConfigParser(allow_no_value=True)
f = params.read(self.config_file)
if not f:
msgr.fatal(u"File <{}> not found".format(self.config_file))
# populate dictionaries using loops instead of using update() method
# in order to not add invalid key
for k in self.raw_input_times:
if params.has_option('time', k):
self.raw_input_times[k] = params.get('time', k)
for k in self.sim_param:
if params.has_option('options', k):
self.sim_param[k] = params.getfloat('options', k)
for k in self.grass_params:
if params.has_option('grass', k):
self.grass_params[k] = params.get('grass', k)
# check for deprecated input names
if params.has_option('input', "drainage_capacity"):
msgr.warning(u"'drainage_capacity' is deprecated. "
u"Use 'losses' instead.")
self.input_map_names['losses'] = params.get(
'input', "drainage_capacity")
# search for valid inputs
for k in self.input_map_names:
if params.has_option('input', k):
self.input_map_names[k] = params.get('input', k)
# drainage parameters
for k in self.drainage_params:
if params.has_option('drainage', k):
if k in ['swmm_inp', 'output', 'swmm_gage']:
self.drainage_params[k] = params.get('drainage', k)
else:
self.drainage_params[k] = params.getfloat('drainage', k)
# statistic file
if params.has_option('statistics', 'stats_file'):
self.stats_file = params.get('statistics', 'stats_file')
else:
self.stats_file = None
# output maps
if params.has_option('output', 'prefix'):
self.out_prefix = params.get('output', 'prefix')
if params.has_option('output', 'values'):
out_values = params.get('output', 'values').split(',')
self.out_values = [e.strip() for e in out_values]
# check for deprecated values
if 'drainage_cap' in self.out_values and 'losses' not in self.out_values:
msgr.warning(u"'drainage_cap' is deprecated. "
u"Use 'losses' instead.")
self.out_values.append('losses')
self.generate_output_name()
return self
def _read_pypirc(self):
"""Reads the .pypirc file."""
rc = self._get_rc_file()
if os.path.exists(rc):
self.announce('Using PyPI login from %s' % rc)
repository = self.repository or self.DEFAULT_REPOSITORY
config = ConfigParser()
config.read(rc)
sections = config.sections()
if 'distutils' in sections:
# let's get the list of servers
index_servers = config.get('distutils', 'index-servers')
_servers = [
server.strip() for server in index_servers.split('\n')
if server.strip() != ''
]
if _servers == []:
# nothing set, let's try to get the default pypi
if 'pypi' in sections:
_servers = ['pypi']
else:
# the file is not properly defined, returning
# an empty dict
return {}
for server in _servers:
current = {'server': server}
current['username'] = config.get(server, 'username')
# optional params
for key, default in (('repository',
self.DEFAULT_REPOSITORY),
('realm', self.DEFAULT_REALM),
('password', None)):
if config.has_option(server, key):
current[key] = config.get(server, key)
else:
current[key] = default
if (current['server'] == repository
or current['repository'] == repository):
return current
elif 'server-login' in sections:
# old format
server = 'server-login'
if config.has_option(server, 'repository'):
repository = config.get(server, 'repository')
else:
repository = self.DEFAULT_REPOSITORY
return {
'username': config.get(server, 'username'),
'password': config.get(server, 'password'),
'repository': repository,
'server': server,
'realm': self.DEFAULT_REALM
}
return {}
