def load_parameters(file_name, config=None, term_conds=None,
dynamics=None, optim=None, pulsegen=None):
"""
Import parameters for the optimisation objects
Will throw a ValueError if file_name does not exist
"""
parser = SafeConfigParser()
readFiles = parser.read(file_name)
if len(readFiles) == 0:
raise ValueError("Parameter file '{}' not found".format(file_name))
if config is not None:
s = 'optimconfig'
try:
attr_names = parser.options(s)
for a in attr_names:
set_param(parser, s, a, config, a)
except Exception as e:
logger.warn("Unable to load {} parameters:({}) {}".format(
s, type(e).__name__, e))
if term_conds is not None:
s = 'termconds'
try:
attr_names = parser.options(s)
for a in attr_names:
set_param(parser, s, a, term_conds, a)
except Exception as e:
logger.warn("Unable to load {} parameters:({}) {}".format(
s, type(e).__name__, e))
if dynamics is not None:
s = 'dynamics'
try:
attr_names = parser.options(s)
for a in attr_names:
set_param(parser, s, a, dynamics, a)
except Exception as e:
logger.warn("Unable to load {} parameters:({}) {}".format(
s, type(e).__name__, e))
if optim is not None:
s = 'optimizer'
try:
attr_names = parser.options(s)
for a in attr_names:
set_param(parser, s, a, optim, a)
except Exception as e:
logger.warn("Unable to load {} parameters:({}) {}".format(
s, type(e).__name__, e))
if pulsegen is not None:
s = 'pulsegen'
try:
attr_names = parser.options(s)
for a in attr_names:
set_param(parser, s, a, pulsegen, a)
except Exception as e:
logger.warn("Unable to load {} parameters:({}) {}".format(
s, type(e).__name__, e))
def load(self, filename):
"""Loads the text map data and deserializes entities"""
self.map_name = filename
file_path = self.get_folder() + sep + filename
config = SafeConfigParser()
if not config.read(file_path):
raise IOError("Map filename '%s' doesn't exist" % file_path)
# Get the save header
s = self.__cfg_header
version = float(config.get(s, "version"))
if version != WORLD_VERSION:
self.__log.warning("Version mismatch, save is %s, and internal version is %s" % (version, WORLD_VERSION))
# Deserialize and load each entity
s = self.__cfg_entities
for uid in config.options(s):
data = chr_bytes(config.get(s, uid))
self.entity_manager.deserialize_entity(int(uid), data)
s = self.__cfg_map
self.map = []
for str_x in config.options(s):
x = int(str_x)
while len(self.map) <= x:
self.map.append(None) # Fill the unnallocated space
y = config.get(s, str_x)
self.map[x] = y
for x, line in enumerate(self.map):
if line == None:
raise ParsingError("Missing map line definition at line %s" % x)
self.redraw_map = True
self.redraw_minimap = True
self.__log.info("Loaded world %s" % filename)
def createDictFromConfig():
""" Read the configuration from scipion/config/scipionbox.conf.
A dictionary will be created where each key will be a section starting
by MICROSCOPE:, all variables that are in the GLOBAL section will be
inherited by default.
"""
# Read from users' config file.
confGlobalDict = OrderedDict()
confDict = OrderedDict()
cp = SafeConfigParser()
cp.optionxform = str # keep case (stackoverflow.com/questions/1611799)
confFile = pw.getConfigPath("scipionbox.conf")
print "Reading conf file: ", confFile
cp.read(confFile)
GLOBAL = "GLOBAL"
MICROSCOPE = "MICROSCOPE:"
if not GLOBAL in cp.sections():
raise Exception("Missing section %s in %s" % (GLOBAL, confFile))
else:
for opt in cp.options(GLOBAL):
confGlobalDict[opt] = cp.get(GLOBAL, opt)
for section in cp.sections():
if section != GLOBAL and section.startswith(MICROSCOPE):
sectionDict = OrderedDict(confGlobalDict)
for opt in cp.options(section):
sectionDict[opt] = cp.get(section, opt)
confDict[section.replace(MICROSCOPE, '')] = sectionDict
return confDict
def _config_from_config_profile(config_file, profile, app):
"""
Configures ec2stack app based on configuration profile.
@param config_file: current config file configuration.
@param profile: the profile to set the attribute in.
"""
config = SafeConfigParser()
config.read(config_file)
if not config.has_section(profile):
sys.exit('No profile matching ' + profile +
' found in configuration, please run ec2stack-configure -p ' + profile)
for attribute in config.options(profile):
app.config[attribute.upper()] = config.get(profile, attribute)
instance_type_map = {}
instance_section = profile + "instancemap"
if config.has_section(instance_section):
for attribute in config.options(instance_section):
instance_type_map[attribute] = config.get(
instance_section, attribute)
app.config['INSTANCE_TYPE_MAP'] = instance_type_map
resource_type_map = {}
resource_section = profile + "resourcemap"
if config.has_section(resource_section):
for attribute in config.options(resource_section):
resource_type_map[attribute] = config.get(
resource_section, attribute)
app.config['RESOURCE_TYPE_MAP '] = resource_type_map
def check(self, filename):
""" Check the settings currently set against default.cfg """
default = Parser()
default.readfp(open(os.path.join(self.config_location, "default.cfg")))
local = Parser()
local.readfp(open(filename))
local_ok = True
diff = set(local.sections()) - set(default.sections())
for section in diff:
logging.warning("Section {} does not exist in {}".format(
section, "default.cfg"))
local_ok = False
for section in local.sections():
if not default.has_section(section):
continue
diff = set(local.options(section)) - set(default.options(section))
for option in diff:
logging.warning(
"Option {} in section {} does not exist in {}".format(
option, section, "default.cfg"))
local_ok = False
if local_ok:
logging.info("{} is OK".format(filename))
else:
logging.warning("{} contains errors.".format(filename))
return local_ok
def _config_from_config_profile(config_file, profile, app):
"""
Configures ec2stack app based on configuration profile.
@param config_file: current config file configuration.
@param profile: the profile to set the attribute in.
"""
config = SafeConfigParser()
config.read(config_file)
if not config.has_section(profile):
sys.exit('No profile matching ' + profile +
' found in configuration, please run ec2stack-configure -p ' +
profile)
for attribute in config.options(profile):
app.config[attribute.upper()] = config.get(profile, attribute)
instance_type_map = {}
instance_section = profile + "instancemap"
if config.has_section(instance_section):
for attribute in config.options(instance_section):
instance_type_map[attribute] = config.get(instance_section,
attribute)
app.config['INSTANCE_TYPE_MAP'] = instance_type_map
resource_type_map = {}
resource_section = profile + "resourcemap"
if config.has_section(resource_section):
for attribute in config.options(resource_section):
resource_type_map[attribute] = config.get(resource_section,
attribute)
app.config['RESOURCE_TYPE_MAP '] = resource_type_map
def load_config(cfgfile):
s = SafeConfigParser()
if not s.read(cfgfile):
raise Exception("Can't read configfile {0}".format(cfgfile))
conf = {
"encoding": sys.getfilesystemencoding(),
"sleeptime": "60",
}
conf.update((k, s.get('tilde', k)) for k in s.options('tilde'))
conf['sleeptime'] = int(conf['sleeptime'])
enc = conf['encoding']
conf['servers'] = srv = {}
conf['defaults'] = defaults = {'commands': None}
if s.has_section('defaults'):
defaults.update((k, s.get('defaults', k).decode(enc))
for k in s.options('defaults'))
conf['commands'] = cmds = {"ubuntu": commands.ubuntu}
for section in [
section for section in s.sections()
if section.startswith("commands:")
]:
name = section.replace("commands:", "", 1).decode(enc)
opts = dict(
(k, s.get(section, k).decode(enc)) for k in s.options(section))
inherit = opts.pop("__inherit__", None)
c = cmds[inherit].copy() if inherit else commands.Commands()
for k, v in opts.iteritems():
setattr(c, k, v)
cmds[name] = c
for section in [
section for section in s.sections()
if section.startswith("server:")
]:
name = section.replace("server:", "", 1).decode(enc)
opts = defaults.copy()
opts.update(
(k, s.get(section, k).decode(enc)) for k in s.options(section))
if opts["commands"]:
opts["commands"] = cmds[opts["commands"]]
opts.setdefault("hostname", name)
if "port" in opts:
try:
opts["port"] = int(opts["port"])
except ValueError, e:
# This may be a port name, which could be handled fine
pass
srv[name] = Server(**opts)
class ConfigIni():
def __init__(self, path):
self.parser = SafeConfigParser()
self.path = path
# Read the value from the option inside the session, output: value (string)
def read_value(self, section, option):
self.parser.read('%s' % self.path)
if section in self.parser.sections():
if option in self.parser.options(section):
return self.parser.get('%s' % section, '%s' % option)
else:
return None
# Read all values and all options inside the session, output: values list(string), options list(string)
def read_all_values(self, section):
self.parser.read('%s' % self.path)
if section in self.parser.sections():
options = self.parser.options(section)
if options:
values = []
for value in self.parser.items(section):
values.append(value[1])
return options, values
else:
return None
# Write or change the session information, if the section exist a new session is added
def write_section(self, section, options, values):
'''
Write or change the session information, if the section exist a new session is added
:param section: Init section
:param options: Must be a list
:param values: Must be a list
:return:
'''
self.parser.read('%s' % self.path)
if section not in self.parser.sections():
self.parser.add_section('%s' % section)
for option, value in zip(options, values):
self.parser.set('%s' % section, '%s' % option, '%s' % value)
cfgfile = open('%s' % self.path, 'w')
self.parser.write(cfgfile)
cfgfile.close()
# Read all sections, output: sections list(string)
def read_sections(self):
self.parser.read('%s' % self.path)
sections = self.parser.sections()
return sections
def initialise_righteous(self):
config = SafeConfigParser()
config.read('righteous.config')
if not config.has_section('auth'):
raise Exception('Please create a righteous.config file with appropriate credentials')
self.auth = dict((key,config.get('auth', key)) for key in config.options('auth'))
self.server = dict((key,config.get('server-defaults', key)) for key in config.options('server-defaults'))
righteous.init(self.auth['username'], self.auth['password'], self.auth['account_id'], **self.server)
if not righteous.config.settings.cookies:
righteous.login()
def loadStatus(self, name="./conf"):
config = SafeConfigParser()
config.read(name)
try:
if config.sections() != []:
if config.has_section("GAME"):
self._quest = config.getint("GAME", "quest")
self.setState(config.getint("GAME", "state"))
self._secState = config.get("GAME", "secState")
if self._secState != "None":
self._secState = int(self._secState)
if config.has_section("PLAYABLE_AGENTS"):
self.agentManager.reset()
for l in config.options("PLAYABLE_AGENTS"):
name = "{:s}:{:s}".format(l.split('_')[0].upper(), l.split('_')[1])
a = self.agentManager.getAgentByName(name)
params = config.get("PLAYABLE_AGENTS", l).split(';')
if a != None:
a.health = int(params[0])
a.magic = int(params[1])
l = a.agent.getLocation()
l.setLayerCoordinates(fife.ModelCoordinate(*(int(float(params[2])), int(float(params[3])))))
a.agent.setLocation(l)
a._mode = int(params[4])
self.agentManager.addNewPlayableAgent(name)
if config.has_section("BEES"):
for l in config.options("BEES"):
name = "{:s}:{:s}:{:s}".format(l.split('_')[0].upper(), l.split('_')[1], l.split('_')[2])
b = self.agentManager.getAgentByName(name)
params = config.get("BEES", l).split(';')
if b != None:
l = fife.Location(self.world.map.getLayer('TechdemoMapGroundObjectLayer'))
l.setLayerCoordinates(fife.ModelCoordinate(*(int(float(params[0])), int(float(params[1])))))
b.agent.setLocation(l)
b.state = int(params[2])
b.mode = int(params[3])
b.start()
self.dialog.hide_exit_menu()
self.dialog.hide_load_menu()
except AttributeError as e:
print "###################################################################################"
print "Unexpected error:", sys.exc_info()[0]
print e.message
print "--- Configuration file malformed. Deleted. ---"
print "--- Please, restart again the game ---"
print "###################################################################################"
self.deleteStatus()
self.exit()
def main():
if len(sys.argv) < 3:
sys.exit('Usage: AddUser.py <username> <password> \n Set password to "-" to delete a user')
parser = SafeConfigParser()
parser.read('users.ini')
if not parser.has_section('users'):
parser.add_section('users')
try:
if (sys.argv[2] == "-"):
parser.remove_option('users', sys.argv[1])
else:
parser.set('users', sys.argv[1], hashlib.md5(sys.argv[2].strip()).hexdigest() )
except:
pass
# prevent an empty file -- always have a default user if there is no other user
if len(parser.options('users')) == 0:
parser.set('users', 'default', hashlib.md5('default').hexdigest() )
file = open('users.ini', 'w')
file.write('#This is the list of users/encrypted passwords for the Linux CNC Web Server\n\n')
file.write('#Use the included python script AddUser to add users\n')
file.write('#Users can be removed by deleting the entries in this file with their user name\n')
file.write('#This file will be auto-generated and overwritten by the AddUser program\n\n')
parser.write(file)
file.close()
def main(inifile = 'example.ini', verbose = 0):
"""Parse the config file and perform actions it specifies."""
parser = SafeConfigParser()
try: parser.read(inifile.name)
except: parser.read(inifile)
if verbose > 0:
print 'verbose output'
print parser.sections()
for section_name in parser.sections():
print section_name
if verbose > 0:
print 'Section:', section_name
print ' Options:', parser.options(section_name)
for name, value in parser.items(section_name):
print ' %s = %s' % (name, value)
try:
act = parser.get(section_name, 'action')
except Exception as e:
raise e
if act == 'unzip':
unzipper(parser.get(section_name, 'input'),
parser.get(section_name, 'output'),
verbose)
elif act == 'gzip':
gzipper(parser.get(section_name, 'input'),
parser.get(section_name, 'output'),
verbose)
else:
raise Exception('how do I {0}?'.format(act))
def from_inifile(self, filename, silent=False):
"""
Reads settings from an ini file.
Settings are added to the configuration dictionary in
the following form. All section and option keys are
changed to uppercase.
<SECTION_NAME>_<OPTION_NAME>
However, all options in the special section "namake"
are added to the dictionary without the section name
as follows.
<OPTION_NAME>
"""
from ConfigParser import SafeConfigParser
filename = os.path.join(self.root_path, filename)
config = SafeConfigParser()
with open(filename, 'rb') as cfgfile:
config.readfp(cfgfile)
for section in config.sections():
for option in config.options(section):
# Try to coerce the value from the ini file into
# native python objects automatically.
for method in ['getint', 'getfloat', 'getboolean', 'get']:
try:
value = getattr(config, method)(section, option)
if section.upper() == 'NAMAKE':
self[option.upper()] = value
else:
self[section.upper() + '_' + option.upper()] = value
break
except ValueError:
pass
def setDriver(self,fname="") :
### File check
if not os.path.exists(fname) :
raise IOError(fname)
parser = SafeConfigParser()
parser.read(fname)
## ConfigParserを使って連想配列に変換する
config = {}
for sect in parser.sections() :
config[sect] = {}
for opt in parser.options(sect) :
config[sect][opt] = parser.get(sect, opt)
self.__driver = config['DataAccess']['driver']
## DriverXxxxx の形式に変換。
class_name = 'Driver' + self.__driver.capitalize()
## インポートを動的に実行。private変数の__instanceにドライバーの
## インスタンスを格納する。
module_name = __import__('driver.' + self.__driver, globals(), locals(), [class_name], -1)
class_constructor = getattr(module_name, class_name)
self.__instance = class_constructor()
## ドライバーにconfigオブジェクトを渡す
self.__instance.setConfig(config)
return self
def parse_ini():
parser = SafeConfigParser()
parser.read("danboorudownloader.ini")
for sect in parser.sections():
print(sect, parser.options(sect))
for name, value in parser.items(sect):
print(name, value)
def _loadconfig(self, arg=[]):
# manage services
for service, value in self.services.iteritems():
if self.name not in app['services'][service].services:
app['services'][service].services = {}
app['services'][service].services[self.name] = value
# add command line args to the program options + build default configuration data
defaultConf = '[' + self.name + ']\n'
group = OptionGroup(app['parser'],
self.name.capitalize() + " Options", self.desc)
if self.options.__class__ is dict:
tmp = []
for option, value in self.options.items():
tmp.append({option: value})
self.options = tmp
#for option, value in self.options.items():
for option in self.options:
option, value = option.items()[0]
if len(value) == 3:
help = value[0] + " " + value[2] + ""
defaultConf += '; ' + value[0] + ' - choices: ' + value[
2] + '\n'
else:
help = value[0]
defaultConf += '; ' + value[0] + '\n'
defaultConf += ';' + option + '=' + str(value[1]) + '\n\n'
if option != 'start':
if self.name == 'main':
group.add_option('--' + option,
'--' + self.name + '.' + option,
type='str',
help=help,
metavar=str(value[1]))
else:
group.add_option('--' + self.name + '.' + option,
type='str',
help=help,
metavar=str(value[1]))
self.conf[option] = value[1]
app['parser'].add_option_group(group)
# create default config if none
userConfFile = app['path']['conf'] + self.nameconf
if not os.path.exists(userConfFile):
if not os.path.exists(app['path']['conf']):
os.mkdir(app['path']['conf'])
fp = open(userConfFile, 'w')
fp.write(defaultConf)
fp.close()
# read user config
fileconf = SafeConfigParser()
fileconf.read(userConfFile)
# set user config
for option in fileconf.options(self.name):
self.conf[option] = fileconf.get(self.name, option)
self.pLoadconfig()
def parse_config_file(filename):
"""
Parses the config file passed into this script
NOTE: note the conversion to unicode
"""
triggers={}
parser = SafeConfigParser()
parser.read(filename)
for s in parser.sections():
if s != 'settings':
triggers[s]={}
triggers[s]['rules']=[]
for o in parser.options(s):
stuff = o.lstrip("regex_")
if stuff != o:
triggers[s]['rules'].append(stuff)
triggers[s]['rules'].append(unicode(parser.get(s,o), "utf-8"))
else:
triggers[s][o]=unicode(parser.get(s,o), "utf-8").strip("'")
return (unicode(parser.get("settings", "rabbitmqusername"), "utf-8"),
unicode(parser.get("settings", "rabbitmqpassword"), "utf-8"),
unicode(parser.get("settings", "cbserverip"), "utf-8"),
unicode(parser.get("settings", "cbtoken"), "utf-8"),
unicode(parser.get("settings", "epserverip"), "utf-8"),
unicode(parser.get("settings", "eptoken"), "utf-8"),
triggers)
def getOptions(cfgFile, section, args):
cfgParser = SafeConfigParser()
cfgParser.read(cfgFile)
argParser = OptionParser()
masterSection=section
masterOptions = cfgParser.options(masterSection);
for dest in masterOptions:
line=cfgParser.get(masterSection,dest)
line=line.strip()
if not line: continue
short, long, help, meta, type, default = line.split(";")
if default=="True":
argParser.add_option(short, long, dest=dest, action="store_false", help=help)
elif default=="False":
argParser.add_option(short, long, dest=dest, action="store_true", help=help)
else:
argParser.add_option(short, long, dest=dest, help=help, default=default, type=type, metavar=meta)
options, additionals = argParser.parse_args(args)
# '+' args are for TGE
for i in range(len(additionals)):
additionals[i] = additionals[i].replace('+', '-')
return options, additionals
def read_config(file_config="dagon.ini", section=None):
"""
Reads the configuration file specified
:param file_config: path to the configuration file
:type file_config: str
:param section: section of the file to read
:type section: str
:return: dictionary with the configuration
:rtype: dict(str, dict)
"""
config = SafeConfigParser()
config.read(file_config)
if section is not None:
try:
return dict(config.items(section))
except:
return None
else:
dictionary = defaultdict(dict)
for section in config.sections():
dictionary[section] = {}
for option in config.options(section):
# print option
dictionary[section][option] = config.get(section,
option,
raw=True)
return dictionary
def get_section(configfile_name, section_name):
parser = SafeConfigParser()
dictionary = {}
for folder in FOLDERS:
config_file_path = folder + "/" + configfile_name
log.debug(config_file_path)
if os.path.exists(config_file_path):
parser.read(config_file_path)
try:
for key in parser.options(section_name):
value = parser.get(section_name, key)
if "," in value:
value = value.split(",")
dictionary[key] = value
except NoSectionError:
continue
log.debug(dictionary)
return dictionary
def configParse(file_path) :
### File check
if not os.path.exists(file_path) :
raise IOError(file_path)
parser = SafeConfigParser()
parser.read(file_path)
### Convert to dictionary
config = {}
for sect in parser.sections() :
config[sect] = {}
for opt in parser.options(sect) :
config[sect][opt] = parser.get(sect, opt)
### Data check and convert from type
for sect in config_settings.keys() :
# if not sect in config :
# raise KeyError(sect)
for opt_attr in config_settings[sect] :
if opt_attr['required'] and (not opt_attr['name'] in config[sect]) :
raise KeyError(opt_attr['name'])
if config[sect][opt_attr['name']] == 'None' :
config[sect][opt_attr['name']] = None
else :
config[sect][opt_attr['name']] = opt_attr['type'](config[sect][opt_attr['name']])
return config
def ReadAllConf(configfile,sections,DefaultConfDict=None):
confDict = {}
scp = SafeConfigParser()
with open(configfile,'r') as f:
f.seek(0)
try:
scp.readfp(f)
except:
confDict = {}
else:
for section in scp.sections():
optionDict = {}
options = scp.options(section)
#print options
for key in options:
#print key,scp.get(section,key)
try:
value = scp.get(section,key)
except:
value = ""
optionDict[key] = value
confDict[section] = optionDict
if len(confDict) == 0:
confDict = DefaultConfDict
return confDict
class ConfigManager(object):
class Section:
def __init__(self, name, parser):
self.__dict__["name"] = name
self.__dict__["parser"] = parser
def __setattr__(self, option, value):
self.__dict__[option] = str(value)
self.parser.set(self.name, option, str(value))
def __init__(self, file_name):
self.parser = SafeConfigParser()
self.parser.read(file_name)
self.file_name = file_name
for section in self.parser.sections():
setattr(self, section, self.Section(section, self.parser))
for option in self.parser.options(section):
setattr(getattr(self, section), option, self.parser.get(section, option))
def __getattr__(self, section):
self.parser.add_section(section)
setattr(self, section, self.Section(section, self.parser))
return getattr(self, section)
def save_config(self):
with file(self.file_name, "w") as fb:
self.parser.write(fb)
def get_workflow_actions_from_text(wf_txt, is_error_wf=False):
"""Parse workflow actions in a text snippet
Note that no section header [ticket-workflow_xxx] must be provided"""
def get_line_txt(txt):
try:
msg = txt.split(']:')[1]
except IndexError:
msg = txt
return msg
error_txt = ""
config = SafeConfigParser()
try:
config.readfp(
io.BytesIO("[ticket-workflow]\n" + wf_txt.encode('utf-8')))
raw_actions = [(key, config.get('ticket-workflow', key)) for key in
config.options('ticket-workflow')]
except ParsingError, err:
error_txt = u"Parsing error: %s" % get_line_txt(
unicode(err).replace('\\n', '').replace('<???>', ''))
if not is_error_wf: # prevent recursion
actions, tmp = get_workflow_actions_for_error()
else:
actions = []
return actions, error_txt
def _load_from_file(self, *args):
config = SafeConfigParser()
config.read(args)
for section in config.sections():
for option in config.options(section):
self.data[unicode(option)] = config.get(section, option)
class ConfigManager(object):
class Section:
def __init__(self, name, parser):
self.__dict__['name'] = name
self.__dict__['parser'] = parser
def __setattr__(self, option, value):
self.__dict__[option] = str(value)
self.parser.set(self.name, option, str(value))
def __init__(self, file_name):
self.parser = SafeConfigParser()
self.parser.read(file_name)
self.file_name = file_name
for section in self.parser.sections():
setattr(self, section, self.Section(section, self.parser))
for option in self.parser.options(section):
setattr(getattr(self, section), option,
self.parser.get(section, option))
def __getattr__(self, option):
self.parser.add_section(option)
setattr(self, option, Section(option, self.parser))
return getattr(self, option)
def save_config(self):
f = open(self.file_name, 'w')
self.parser.write(f)
f.close()
def get_oauth_token(tribe_url, secrets_location):
secrets_file = SafeConfigParser()
secrets_file.read(secrets_location)
if not secrets_file.has_section('Tribe secrets'):
logger.error('Secrets file has no "Tribe secrets" section, which is'
' required to save the processed genesets to Tribe.')
sys.exit(1)
required_secrets = set(
['tribe_id', 'tribe_secret', 'username', 'password'])
secrets_set = set(secrets_file.options('Tribe secrets'))
if not required_secrets.issubset(secrets_set):
logger.error('Tribe secrets section must contain TRIBE_ID, '
'TRIBE_SECRET, USERNAME, and PASSWORD to be able to save'
' processed genesets to Tribe.')
sys.exit(1)
tribe_id = secrets_file.get('Tribe secrets', 'TRIBE_ID')
tribe_secret = secrets_file.get('Tribe secrets', 'TRIBE_SECRET')
username = secrets_file.get('Tribe secrets', 'USERNAME')
password = secrets_file.get('Tribe secrets', 'PASSWORD')
access_token_url = tribe_url + '/oauth2/token/'
access_token = obtain_token_using_credentials(username, password, tribe_id,
tribe_secret,
access_token_url)
return access_token, username
def read_config(config_filepath):
"""
Return a dictionary with subdictionaries of all configFile options/values
Parameters
----------
config_filepath : str
Filepath to configparser / ini style formatted configuration file
Returns
-------
config_dict : collections.OrderedDict
OrderedDict of parsed configuration file value
"""
if not os.path.isfile(config_filepath):
raise RasmLibIOError('Configuration File ({0}) does not '
'exist'.format(config_filepath))
config = SafeConfigParser()
config.optionxform = str
config.read(config_filepath)
sections = config.sections()
config_dict = OrderedDict()
for section in sections:
options = config.options(section)
dict2 = OrderedDict()
for option in options:
dict2[option] = config_type(config.get(section, option))
config_dict[section] = dict2
return config_dict
def load_local_config(config_file, required=[], optional=[]):
"""Loads config from ~/.cloudconnect and from os.environ, and merges values into current globals()"""
from ConfigParser import SafeConfigParser
config = SafeConfigParser()
config.optionxform = str
new_config = {}
if os.path.exists(config_file):
if "DEBUG_SETTINGS" in os.environ:
print "Reading '%s'" % config_file
config.read(config_file)
env = determine_env()
if env in config.sections():
for key in config.options(env):
val = config.get(env, key)
if key in os.environ:
val = os.environ[key]
val = cast_env_vars(val)
if "DEBUG_SETTINGS" in os.environ:
print "Setting %s to %s" % (key, str(val))
new_config[key] = val
for key in required:
if key in os.environ:
new_config[key] = cast_env_vars(os.environ[key])
for key in optional:
if key in os.environ:
new_config[key] = cast_env_vars(os.environ[key])
return new_config
def getSensorName(sensor):
parser = SafeConfigParser()
parser.read(SETTINGS_FILE)
for t_sensor in parser.options('temp sensors'):
if sensor == int(t_sensor):
return parser.get('temp sensors', t_sensor)
return 'Unknown'
def _configure(self, *args, **kwargs):
""""""
config = SafeConfigParser()
if args:
old_config = args[0]
for section in old_config.sections():
config.add_section(section)
for option in old_config.options(section):
config.set(section, option, old_config.get(section, option))
else:
config_files = [os.path.join('config', 'defaults.cfg'),
kwargs.pop('config_file', '')]
config.read(config_files)
# argparse syntax should be --section_name option1=value1 option2=value2
# kwarg syntax should be section_name={option1: value1, option2: value2}
# or option1=value1, option2=value2
config_sections = {section.lower().replace(' ', '_'): section for section in config.sections()}
config_sections['default'] = 'DEFAULT'
config_options = set()
for section in config.sections():
config_options.update(config.options(section))
for kw, arg in kwargs.iteritems():
if isinstance(arg, dict):
section = config_sections[kw]
for option, value in arg.iteritems():
assert option in config_options
config.set(section, option, str(value))
else:
option, value = kw, arg
section = re.sub('\B([A-Z][a-z])', r' \1', self.__class__.__name__)
section = re.sub('([a-z])([A-Z])', r'\1 \2', section)
assert option in config_options
config.set(section, option, str(value))
return config
def AccDataDownloader():
'''Download Acceleration data to disk
'''
time.clock()
scp = SafeConfigParser()
scp.read('Config.ini')
server = scp.get('General', 'server')
db = scp.get('General', 'db')
uid = scp.get('General', 'uid')
pwd = scp.get('General', 'pwd')
path = scp.get('General', 'path')
dtStart = scp.get('AcceCollect', 'StartDatetime')
dtEnd = scp.get('AcceCollect', 'EndDatetime')
chStart = int( scp.get('AcceCollect', 'StartChannel') )
chEnd = int( scp.get('AcceCollect', 'EndChannel') )
paras = {}
chs = scp.options('AcceSensitivity')
for ch in chs:
paras[ch] = float(scp.get('AcceSensitivity', ch))
t = AcceData(server, db, uid, pwd, paras, path, 'Acce')
t.DTInit(dtStart, dtEnd)
# cProfile.run('t.GetData(chStart, chEnd)')
t.GetData(chStart, chEnd)
print 'Finished in %6.3fs' % time.clock()
class Configs:
""" Grab data from configs """
def __init__(self):
""" Setup """
CONFIGFILE = 'settings.conf'
self.settings = SafeConfigParser()
curdir = os.path.dirname(os.path.realpath(__file__))
configfile = "{0}/{1}".format(curdir, CONFIGFILE)
self.settings.read(configfile)
def get_creds(self):
""" returns a dict of username, token """
username = self.settings.options('username')[0]
token = self.settings.get('username', username)
return {'username': username, 'token': token}
def github(self):
""" Kinda lame that this only returns github host """
return {'host': self.settings.get('github', 'host')}
def git_user(self):
""" returns just the github user in config"""
# this is added because the auth user may not be the same as git user
return {'user': self.settings.get('github', 'user')}
def config_parser(config_file):
"""
Parse data from configuration files.
:param config_file: Configuration file with currencies or exchanges data.
"""
res = []
# Parse and read configuration file.
cparser = SafeConfigParser()
cparser.read(config_file)
for section in cparser.sections():
tup = ()
for option in cparser.options(section):
value = cparser.get(section, option)
# String 'True' or 'False' values to boolean
if value == 'True':
value = True
elif value == 'False':
value = False
tup += (value, )
res.append(tup)
return res
def set_env_vars(config_file):
parser = SafeConfigParser()
parser.read(config_file)
env_base = "CONFIG_PARSER"
final_env = {}
for s in parser.sections():
sec = s.upper()
for o in parser.options(s):
final_env["___".join([env_base, sec,
o.upper()])] = parser.get(s, o)
#final_string = " ".join(["%(env)s=%(val)s" % {"env":k,"val":final_env[k]} for k in final_env.keys()])
#print final_string
final_strings = [
"%(env)s=%(val)s" % {
"env": k,
"val": final_env[k]
} for k in final_env.keys()
]
for k in final_env.keys():
print k
if len(sys.argv) > 2:
del os.environ[k]
else:
os.environ[k] = str(final_env[k])
def showVersion(self, module):
from ConfigParser import SafeConfigParser
from StringIO import StringIO
import datetime
import time
file = open(FILE_VERSION_PATH,'r')
f = StringIO(file.read())
f.seek(0)
iniPaser = SafeConfigParser()
iniPaser.readfp(f)
sections = iniPaser.sections()
number = None
try:
options = iniPaser.options(module)
for opt in options:
value = iniPaser.get(module, opt)
if number is None:
number = str(value)
else:
number = number + "." + str(value)
self.version = module + "_" + number
self.version = self.version + "_" + datetime.datetime.fromtimestamp(time.time()).strftime('%Y%m%d')
self.buildLog(self.version)
except:
self.buildLog(module + " is no version number.")
file.close()
def _add_default(self, app):
for id in ['alameter.conf', 'alameter.conf.user']:
row = self.get(id)
if row:
# configuration exists
continue
# load configuration
if id == 'alameter.conf':
path = "%s/api/etc/%s.%s" % (HOME_DEFAULT, id, app.lower())
else:
path = "%s/api/etc/%s" % (HOME_DEFAULT, id)
if not os.path.isfile(path):
continue
conf_parser = SafeConfigParser()
conf_parser.read(path)
conf = {}
for s in conf_parser.sections():
conf[s] = {}
for o in conf_parser.options(s):
conf[s][o] = conf_parser.get(s, o)
# insert to database
row = self.get(id)
if not row:
# check again to prevent concurrent insert
self.insert({'id': id, 'config': json.dumps(conf)})
def configParse(file_path):
### File check
if not os.path.exists(file_path):
raise IOError(file_path)
parser = SafeConfigParser()
parser.read(file_path)
### Convert to dictionary
config = {}
for sect in parser.sections():
config[sect] = {}
for opt in parser.options(sect):
config[sect][opt] = parser.get(sect, opt)
### Data check and convert from type
for sect in config_settings.keys():
# if not sect in config :
# raise KeyError(sect)
for opt_attr in config_settings[sect]:
if opt_attr['required'] and (not opt_attr['name'] in config[sect]):
raise KeyError(opt_attr['name'])
if config[sect][opt_attr['name']] == 'None':
config[sect][opt_attr['name']] = None
else:
config[sect][opt_attr['name']] = opt_attr['type'](
config[sect][opt_attr['name']])
return config
def configure_parameters():
global portID
global logginglevelName
global loggingLevel
global logFile
global MQTT_brokerHost
global MQTT_QOS
global MQTT_retention
global MQTT_mapString
global MQTT_mapping
global MQTT_topic
config = SafeConfigParser()
config.readfp(open('w800.conf'))
try:
sections = config.sections()
print "sections:", sections
for section in sections:
options = config.options(section)
print "section, options:", section, ":", options
for option in options:
option_value = config.get(section, option)
print "section:options: ", section + ": " + option + ": " + option_value
if section == 'ports':
print " ports: option", option, config.get(
section, option)
if option == 'portid':
portID = config.get(section, option)
else:
print "Unexpected option in ports: " + option
elif section == 'Logging':
print " logging: option", option, config.get(
section, option)
if option == 'logginglevel':
loggingLevelName = config.get(section, option)
print "logginglevelName", loggingLevelName
loggingLevel = loggingLevels[loggingLevelName]
elif option == 'logFile':
logFile = config.get(section, option)
else:
print "Unexpected option in logging: " + option
elif section == 'MQTT':
print " mqtt: option", option, config.get(section, option)
if option == 'mqtt_brokerhost':
MQTT_brokerHost = config.get(section, option)
elif option == 'mqtt_qos':
MQTT_QOS = config.getint(section, option)
elif option == 'mqtt_topic':
MQTT_topic = config.get(section, option)
elif option == 'mqtt_mapping':
MQTT_mapString = config.get(section, option)
else:
print "Unexpected option in mqtt: " + option
else:
print "Unexpected section: " + section
except:
print "The value for option '" + option + "' in section '" + section + "' isn't right"
def configme(pkg_name):
'''Given a pkg name, can I get the two possible locations to
gather config
'''
confd = {}
well_known_dir = os.path.join('/usr/local/etc/', pkg_name)
well_known_location = os.path.join(well_known_dir, 'conf.ini')
confp = SafeConfigParser()
try:
confp.read(well_known_location)
except:
#: no config at all ????
#: need a default
return confd
for section in confp.sections():
#[IAmASection]
print section
if section not in confd:
confd[section] = {}
options = confp.options(section)
for option in options:
try:
print option
print confp.get(section, option)
confd[section][option] = confp.get(section, option)
except Exception, e:
logging.error("Failed to add config to confd %s %s %s", e, section, option)
def getIncludes(resource, seen = []):
"""
Given 1 config resource returns list of included files
(recursively) with the original one as well
Simple loops are taken care about
"""
SCPWI = SafeConfigParserWithIncludes
parser = SafeConfigParser()
parser.read(resource)
resourceDir = os.path.dirname(resource)
newFiles = [ ('before', []), ('after', []) ]
if SCPWI.SECTION_NAME in parser.sections():
for option_name, option_list in newFiles:
if option_name in parser.options(SCPWI.SECTION_NAME):
newResources = parser.get(SCPWI.SECTION_NAME, option_name)
for newResource in newResources.split('\n'):
if os.path.isabs(newResource):
r = newResource
else:
r = "%s/%s" % (resourceDir, newResource)
if r in seen:
continue
s = seen + [resource]
option_list += SCPWI.getIncludes(r, s)
return newFiles[0][1] + [resource] + newFiles[1][1]
def getSensorName(sensor):
parser = SafeConfigParser()
parser.read(SETTINGS_FILE)
for t_sensor in parser.options('temp sensors'):
if sensor == int(t_sensor):
return parser.get('temp sensors',t_sensor)
return 'Unknown'
def load_config(config_file):
config = SafeConfigParser()
config.read(config_file)
sections = ['Server', 'Application', 'MongoDB']
the_config = {}
for section in sections:
options = config.options(section)
for option in options:
try:
the_config[option] = config.get(section, option)
try_next = True
if try_next:
try:
the_config[option] = str2bool(the_config[option])
try_next = False
except:
try_next = True
if try_next:
try:
the_config[option] = float(the_config[option])
try_next = False
except:
try_next = True
except:
print "Config exception on %s!" % option
the_config[option] = None
return the_config
def from_filename(filename, allow_empty=False):
from ConfigParser import SafeConfigParser, NoOptionError
parser = SafeConfigParser()
parser.read(filename)
obj = OMPEnv()
# Consistency check. Note that we only check if the option name is correct,
# we do not check whether the value is correct or not.
if "openmp" not in parser.sections():
if not allow_empty:
raise ValueError("%s does not contain any [openmp] section" % filename)
return obj
err_msg = ""
for key in parser.options("openmp"):
if key.upper() not in OMPEnv._keys:
err_msg += "unknown option %s, maybe a typo" % key
if err_msg:
raise ValueError(err_msg)
for key in OMPEnv._keys:
try:
obj[key] = str(parser.get("openmp", key))
except NoOptionError:
try:
obj[key] = str(parser.get("openmp", key.lower()))
except NoOptionError:
pass
if not allow_empty and not obj:
raise ValueError("Refusing to return with an empty dict")
return obj
def _read_config_files(paths):
"""
Read configuration data from INI-style file(s).
Data loaded from the given files is aggregated into a nested 2-level Python
mapping, where 1st-level keys are config section names (as read from the
files), and corresponding items are again key/value mappings (configuration
item name and value).
:param paths: list of filesystem paths of files to read
"""
# read given config files
configparser = SafeConfigParser()
configparser.read(paths)
# temporarily modify environment to allow both `${...}` and `%(...)s`
# variable substitution in config values
defaults = _make_defaults_dict()
config = {}
with environment(**defaults):
for section in configparser.sections():
config[section] = {}
for key in configparser.options(section):
# `configparser.get()` performs the `%(...)s` substitutions
value = configparser.get(section, key, vars=defaults)
# `expandvars()` performs the `${...}` substitutions
config[section][key] = expandvars(value)
return config
class ConfigManager(object):
class Section:
def __init__(self, name, parser):
self.__dict__['name'] = name
self.__dict__['parser'] = parser
#reason for using __dict__ is that __setattr__ is called to initiate all local class attrs and so
#declaring the below would cause __setattr__ to be called and obviously neither name nor parser exist yet
#self.name = name
#self.parser = parser
def __setattr__(self, option, value):
self.__dict__[option] = str(value)
self.parser.set(self.name, option, str(value))
def __init__(self, file_name):
self.parser = SafeConfigParser()
self.parser.read(file_name)
self.file_name = file_name
for section in self.parser.sections():
setattr(self, section, self.Section(section, self.parser))
for option in self.parser.options(section):
setattr(getattr(self, section), option,
self.parser.get(section, option))
def __getattr__(self, option):
self.parser.add_section(option)
setattr(self, option, Section(option, self.parser))
return getattr(self, option)
def save_config(self):
f = open(self.file_name, 'w')
self.parser.write(f)
f.close()
def _read_config(suite):
"""
Read the config ini file for the test suite `suite`
(identified as a group in the config)
Returns a dictionary of configuration values that will
be passed as environment variables to the test suite.
"""
if not os.path.isfile(CONFIG_PATH):
msg = """
Could not find config file at '{0}'.
Please set the CONFIG_PATH environment variable
""".format(CONFIG_PATH)
_abort(msg)
config = SafeConfigParser()
config.read(CONFIG_PATH)
result = {
key: config.get(suite, key) for key in config.options(suite)
}
# Validate the required keys
for key in ['protocol', 'test_host']:
if key not in result:
_abort("Missing '{0}' in config file.".format(key))
return result
def _read_config_files(paths):
"""
Read configuration data from INI-style file(s).
Data loaded from the given files is aggregated into a nested 2-level Python
mapping, where 1st-level keys are config section names (as read from the
files), and corresponding items are again key/value mappings (configuration
item name and value).
:param paths: list of filesystem paths of files to read
"""
# read given config files
configparser = SafeConfigParser()
configparser.read(paths)
# temporarily modify environment to allow both `${...}` and `%(...)s`
# variable substitution in config values
defaults = _make_defaults_dict()
config = {}
with environment(**defaults):
for section in configparser.sections():
config[section] = {}
for key in configparser.options(section):
# `configparser.get()` performs the `%(...)s` substitutions
value = configparser.get(section, key, vars=defaults)
# `expandvars()` performs the `${...}` substitutions
config[section][key] = expandvars(value)
return config
def get_section(configfile_name, section_name):
parser = SafeConfigParser()
dictionary = {}
for folder in FOLDERS:
config_file_path = folder + "/" + configfile_name
log.debug(config_file_path)
if os.path.exists(config_file_path):
parser.read(config_file_path)
try:
for key in parser.options(section_name):
value = parser.get(section_name, key)
if "," in value:
value = value.split(",")
dictionary[key] = value
except NoSectionError:
continue
log.debug(dictionary)
return dictionary
def read_conf(file):
"""parse the config file and return a list of dict, return empty dict with wrong config"""
res=[]
need_options=set(['cut_interval', 'expect_time', 'accept_time', 'servernames', 'pattern'])
number_options=('cut_interval','expect_time','accept_time')
parser=SafeConfigParser()
parser.read(file)
for fname in parser.sections():
options=set(parser.options(fname))
if need_options <= options:
parser_dict=dict(parser.items(fname))
d={'logfile':fname}
#d.update(dict((k,float(v) if '.' in v else int(v) ) for k,v in parser.items(fname)))
#d.update({k:float(v) if '.' in v else int(v) for k,v in parser.items(fname)})
d.update({}.fromkeys(options))
for op in number_options:
d[op]=float(parser_dict[op]) if '.' in parser_dict[op] else int(parser_dict[op])
d['servernames']=tuple(s.strip() for s in parser_dict['servernames'].split(','))
d['pattern']= parser.get(fname, 'pattern')
res.append(d)
else :
print 'Wrong config with {0}'.format(fname)
continue
#if res and 'zabbix_server' in parser.defaults():
# res.append(parser.defaults()['zabbix_server'])
return res
def config(self,file):
config=SafeConfigParser()
config.read(file)
for section in config.sections():
for option in config.options(section):
value=config.get(section,option)
setattr(self,option,value)
def getIncludes(resource, seen = []):
"""
Given 1 config resource returns list of included files
(recursively) with the original one as well
Simple loops are taken care about
"""
# Use a short class name ;)
SCPWI = SafeConfigParserWithIncludes
parser = SafeConfigParser()
parser.read(resource)
resourceDir = os.path.dirname(resource)
newFiles = [ ('before', []), ('after', []) ]
if SCPWI.SECTION_NAME in parser.sections():
for option_name, option_list in newFiles:
if option_name in parser.options(SCPWI.SECTION_NAME):
newResources = parser.get(SCPWI.SECTION_NAME, option_name)
for newResource in newResources.split('\n'):
if os.path.isabs(newResource):
r = newResource
else:
r = os.path.join(resourceDir, newResource)
if r in seen:
continue
s = seen + [resource]
option_list += SCPWI.getIncludes(r, s)
# combine lists
return newFiles[0][1] + [resource] + newFiles[1][1]
def from_file(cls, fname, allow_empty=False):
"""Initialize the object from file."""
parser = SafeConfigParser()
parser.read(fname)
inst = OMPEnvironment()
# Consistency check. Note that we only check if the option name is correct,
# we do not check whether the value is correct or not.
if "openmp" not in parser.sections():
if not allow_empty:
raise ValueError("%s does not contain any [openmp] section" %
fname)
return inst
err_msg = ""
for key in parser.options("openmp"):
if key.upper() not in OMPEnvironment._keys:
err_msg += "unknown option %s, maybe a typo" % key
if err_msg:
raise ValueError(err_msg)
for key in OMPEnvironment._keys:
try:
inst[key] = str(parser.get("openmp", key))
except NoOptionError:
try:
inst[key] = str(parser.get("openmp", key.lower()))
except NoOptionError:
pass
if not allow_empty and not inst:
raise ValueError("Refusing to return with an empty dict")
return inst
def set_env_vars(config_file):
parser = SafeConfigParser()
parser.read(config_file)
env_base = "CONFIG_PARSER"
final_env = {}
for s in parser.sections():
sec = s.upper()
for o in parser.options(s):
final_env["___".join([env_base, sec, o.upper()])] = parser.get(s, o)
# final_string = " ".join(["%(env)s=%(val)s" % {"env":k,"val":final_env[k]} for k in final_env.keys()])
# print final_string
final_strings = ["%(env)s=%(val)s" % {"env": k, "val": final_env[k]} for k in final_env.keys()]
for k in final_env.keys():
print k
if len(sys.argv) > 2:
del os.environ[k]
else:
os.environ[k] = str(final_env[k])
class Config:
"""
Initialize the config class and parse the config file.
"""
def __init__(self, path=os.path.normpath(os.getcwd()), filename="config.ini"):
# Default config file: <current directory of script>/config.ini
self.file = "%s/%s" % (path, filename)
# Initialize the ini parser class
self.parser = SafeConfigParser()
# Read and parse the ini file
self.parser.read(self.file)
# We initially have an empty config to deal with
self.config = {}
# So we don't initialize this every...damn...time.
val = ""
# Loop through each section in the ini file
for section in self.parser.sections():
# Create an empty dictionary entry for each entry (otherwise: exceptions)
self.config.update({section : dict()})
# Loop through each option in the section
for option in self.parser.options(section):
# Get the value of the option (just done for clarity)
val = self.parser.get(section, option)
# Store the new 'option' : 'option val' dictionary entry into the section dictionary
self.config[section].update({ option : val })
"""
Retrieve an item from the configuration.
"""
def __getitem__(self, section, option=None):
# First we MUST have a section name given, and only continue if it's valid
if self.config.has_key(section):
# If an option key was given and it exists, return the value
if option != None and self.config[section].has_key(option):
return self.config[section][option]
else if option == None:
# No option was given, user wants just the section data
return self.config[section]
else:
# No option was found, even tho it was requested, return empty string
return ""
else:
return {'' : ''}
"""
Simply returns a dump of the config file. Primarily for debugging purposes.
"""
def dump(self):
print self.config
def file(self):
return self.file
