def make(cls):
"""Makes the conf object, merging in the following order:
- ENV
- default config: default.yml
- stage config: {stage}.yml
- remote config: remote_settings
"""
anyconfig.merge(cls.conf, os.environ.copy())
stage = cls.conf.get("stage", None)
project_config_dir = cls.conf.get("project_config_dir", ".")
project_default_config_file_path = os.path.join(
project_config_dir, "default.yml")
if os.path.exists(project_default_config_file_path):
anyconfig.merge(cls.conf,
anyconfig.load(project_default_config_file_path))
project_stage_config_file_path = os.path.join(project_config_dir,
f"{stage}.yml")
if os.path.exists(project_stage_config_file_path):
anyconfig.merge(cls.conf,
anyconfig.load(project_stage_config_file_path))
remote_settings = cls.conf.get("use_remote_settings", None)
if remote_settings:
project_name = cls.conf.get("project_name", None)
parameters_path = f"/{project_name}/{stage}/"
remote_settings_class = cls.create_remote_settings_class()
remote_conf = remote_settings_class.get_remote_params(
parameters_path)
anyconfig.merge(cls.conf, remote_conf)
def main():
params_file = None
if len(sys.argv) < 4:
print('Usage: python test.py TEST_PARAMS_FILE DEFAULT_CONFIG_FILE NUM_ROUNDS')
sys.exit(1)
else:
params_file = str(sys.argv[1])
default_config = str(sys.argv[2])
num_rounds = int(sys.argv[3])
variable_params = anyconfig.load(params_file)
default_config = anyconfig.load(default_config)
configs = []
for k, v in variable_params.items():
if v is not None:
options = v
for option in options:
new_config = copy.deepcopy(default_config)
new_config[k] = option
str_option = str(option)
new_config['results_file'] = 'results_{}_{}.txt'.format(k, str_option.replace('.', '_'))
new_config['num_rounds'] = num_rounds
cs = anyconfig.dumps(new_config, ac_parser='yaml')
configs.append(cs)
pool = mp.Pool(processes=48)
for config_str in configs:
pool.apply_async(run_param_test, (config_str,))
pool.join()
def _is_project(project_path: Union[str, Path]) -> bool:
metadata_file = Path(project_path).expanduser().resolve() / _PYPROJECT
if not metadata_file.is_file():
return False
try:
anyconfig.load(metadata_file)
except Exception: # pylint: disable=broad-except
return False
return True
def load_config(path):
default_configuration = anyconfig.load(resource_filename('cecmqtt.config', 'default.yaml'))
try:
config = anyconfig.load(path)
except IOError:
logger.warning("no config file found at: %s", path)
config = {}
config = default_configuration + AttrDict(config)
return normalize_config(config)
def init_config():
getLogger(__name__).debug('Loading default configuration')
cfg = load(_config_defaults,
ignore_missing=False)
getLogger(__name__).debug(f"Loading user configuration overrides {' '.join(_config_search)}")
user_config = load(_config_search,
ac_merge=MS_REPLACE,
ignore_missing=True)
merge(cfg, user_config)
getLogger(__name__).debug(f"Configuration complete, dumping value")
getLogger(__name__).debug(cfg)
return cfg
def _try_loads(files):
for filepath in files:
try:
cnf = anyconfig.load(filepath, ac_parser="fortios")
assert cnf
exp_path = str(filepath).replace(".txt", ".json")
ref = anyconfig.load(exp_path, ordered=True)
except anyconfig.UnknownFileTypeError:
print("all types=%r" % anyconfig.list_types())
raise
assert cnf == ref
def __init__(
self,
full_course: Path = Path("/app/head_chef/full_course.yaml")) -> None:
"""
Give the Head Chef the instructions needed to prepare the full course
i.e. Initialize the following from a YAML configuration file:
- location (where to output the file)
- python_format (the Python data type after processing)
- file_format (the file format with which to save the data)
Args:
full_course (Path): A YAML file within the head_chef directory containing
the ingredients to prepare
"""
sous_chef = SousChef()
self.ingredients = sous_chef.prepare_ingredients()
self.full_course = dict()
self.tools = dict()
# Load from full_course.yaml
for key, value in anyconfig.load(full_course).items():
self.full_course[key] = FullCourse(**value)
# Find the right tool for the job (data saving)
self.tools[key] = prepare_tools(
python_format=self.full_course[key].python_format,
file_format=self.full_course[key].file_format,
)
def render_secrets(
config_path,
secret_path,
):
"""combine a jinja template with a secret .ini file
Args:
config_path (str): path to .cfg file with jinja templating
secret_path (str): path to .ini-like secrets file
Returns:
ProsperConfig: rendered configuration object
"""
with open(secret_path, 'r') as s_fh:
secret_ini = anyconfig.load(s_fh, ac_parser='ini')
with open(config_path, 'r') as c_fh:
raw_cfg = c_fh.read()
rendered_cfg = anytemplate.renders(raw_cfg, secret_ini, at_engine='jinja2')
p_config = ProsperConfig(config_path)
local_config = configparser.ConfigParser()
local_config.optionxform = str
local_config.read_string(rendered_cfg)
p_config.local_config = local_config
return p_config
def __init__(self):
logging.basicConfig()
self.logger = logging.getLogger()
self.logger.setLevel(logging.INFO)
self.garage_data = anyconfig.load("garage_data.json")['garage_data']
self.sg = sendgrid.SendGridClient(SENDGRID_USERNAME, SENDGRID_PASSWORD)
self.keen_client = None
def load(filename, fpath=(), dpath=None, **kwds):
'''Load a file and return its data structure.
If dpath given, return substructure at that "path" in the
resulting data structure.
If filename is not absolute, it will be searched for first in the
current working directory, then moo's built-in directory, then in
any user-provided paths in "fpath" and finally in directories
provided by moo.io.default_load_path. The application is free to
provide this fallback. When moo is used from its CLI the
MOO_LOAD_PATH environment variable is consulted.
'''
fmt = os.path.splitext(filename)[-1]
paths = clean_paths(fpath) + list(default_load_path)
filename = resolve(filename, paths)
if fmt in (".jsonnet", ".schema"):
data = moo.jsonnet.load(filename, paths, **kwds)
elif fmt in (".csv", ):
data = moo.csvio.load(filename, paths, **kwds)
elif fmt in (".xls", ".xlsx"):
data = moo.xls.load(filename, paths, **kwds)
else:
data = anyconfig.load(filename)
if data is None:
raise ValueError(f'no data from {filename}')
if dpath:
return select_path(data, dpath)
return data
def getAppURLs(self):
app_config = anyconfig.load(
os.path.join(self.destination, self.compose_file))
protocol = "https" if self.config.https else "http"
app_urls = []
for service in app_config["services"]:
service_name = service
service_config = app_config["services"][service]
if "labels" in service_config:
for label in service_config["labels"]:
key, value = label.split("=")
if key == "backplane.enabled":
if value == "true":
if self.config.verbose > 0:
typer.secho(
f"backplane enabled for service {service_name}",
err=False,
fg=typer.colors.BRIGHT_BLACK,
)
app_urls.append(
f"{protocol}://{service_name}.{self.config.domain}"
)
return app_urls
def load_config(config_dir=DEFAULT_CONFIG_DIRECTORY, config_override_file=None):
try:
config_files = [os.path.join(config_dir, DEFAULT_CONFIG_FILE)]
if config_override_file is not None:
config_files.append(os.path.join(config_dir, config_override_file))
fconfig = anyconfig.load(config_files, ac_parser="yaml")
db_settings = fconfig['db']
# Set the DB configuration
config.db_name = db_settings['name']
config.db_user = db_settings['user']
config.db_password = db_settings['password']
config.db_min_conn = db_settings['min_conn']
config.db_max_conn = db_settings['max_conn']
config.db_port = db_settings['port']
config.db_host = db_settings['host']
# Set the Twitter configuration
twitter_settings = fconfig['twitter']
config.twitter_screen_name = twitter_settings['screen_name']
config.twitter_consumer_key = twitter_settings['consumer_key']
config.twitter_consumer_secret = twitter_settings['consumer_secret']
config.twitter_access_token_key = twitter_settings['access_token_key']
config.twitter_access_token_secret = twitter_settings['access_token_secret']
# Set the Calais configuration information
calais_settings = fconfig['calais']
config.calais_api_token = calais_settings['api_token']
# Set the chatter app configurations
if fconfig.get('domains_to_ignore', None) is not None:
config.domains_to_ignore = fconfig['domains_to_ignore']
except Exception as e:
print('Unable to load configuration file make sure your config.yaml exists and is accessible.')
print(e)
exit(1)
def actuators(self):
"""return actuators for all systems, with added `system_name` variable"""
actuators = []
systems = anyconfig.load([self.systems.config_path, self.devices.config_path], merge=anyconfig.MS_DICTS)
for system_name, system in self.systems.list().iteritems():
for uuid, actuator in system.get('actuators').iteritems():
actuator["id"] = uuid
actuator['system_name'] = system_name
actuator['system_plan'] = system.get('plan')
plan = self.__get_plan(actuator)
if not plan:
LOG.error("missing plan for %s object: %s" % (uuid,actuator))
continue
actuator["plan_full"] = plan
actuator["plan_name"] = plan["name"]
actuators.append(actuator)
LOG.debug(actuators)
return actuators
def test_10_render_to(self):
ctx = A.load(_CONFFILE_0)
tmpl = _TMPL_0
output = os.path.join(self.workdir, "tmpl.out")
TT.render_to(tmpl, ctx, output, self.tpaths)
self.assertTrue(os.path.exists(output))
def load(self):
"""
Load Whiriho catalog.
"""
try:
# Open and parse catalog (in forced format or by analyzing file extension)
data = anyconfig.load(self.path, ac_parser=self.forced_format)
# Validate generic catalog version. We only accept version 1.x.x
jsonschema.validate(data, __whiriho_catalog__)
# Analyze catalog version.
self.version = Whiriho.parse_version(data['version'])
# Parse catalog in version 1
if self.version.major == 1:
jsonschema.validate(data, __whiriho_catalog_v1__)
self.catalog = data['catalog']
else:
raise CatalogVersionException(
'Whiriho (%s) cannot use catalog version %s' %
(__version__, self.version))
except (jsonschema.ValidationError,
anyconfig.UnknownFileTypeError) as error:
raise CatalogFormatException('Invalid catalog format: %s' %
error.message)
except jsonschema.SchemaError:
raise AssertionError('Internal library error; invalid schema')
except IOError:
raise CatalogNotFoundException(
'Failed to load configuration catalog')
def get_news_dict(ts=None):
"""Returns a dict containing list of editorials after timestamp ts. By
default, the difference is mentioned as 'default_offset' in data.yml."""
# Getting url of the api to call from data.yml file
config = anyconfig.load('data.yml')
if config is None or 'baseurl' not in config or 'default_offset' not in config:
print "Error parsing yaml"
return None
baseurl = config['baseurl']
listurl = baseurl + '/api/list'
# Getting timestamp of default offset as mentioned in data.yml
if ts is None:
doff = config['default_offset']
now = datetime.now()
prev = now - timedelta(doff)
ts = (prev - datetime(1970, 1, 1)).total_seconds()
# Adding the timestamp to payload
payload = {}
payload['timestamp'] = ts
# Sending the request
resp = requests.post(listurl, data=payload)
# Analysing the response
if resp.status_code != 200:
print "Error received : " + str(resp.status_code)
return None
else:
cntnt = json.loads(resp.content)
return cntnt
def main():
import sys
import pathlib
__dir__ = pathlib.Path(os.path.abspath(__file__))
sys.path.append(str(__dir__))
sys.path.append(str(__dir__.parent.parent))
from models import build_model, build_loss
from data_loader import get_dataloader
from utils import Trainer
from utils import get_post_processing
from utils import get_metric
config = anyconfig.load(open('config.yaml', 'rb'))
train_loader = get_dataloader(config['dataset']['train'])
validate_loader = get_dataloader(config['dataset']['validate'])
criterion = build_loss(config['loss']).cuda()
model = build_model(config['arch'])
post_p = get_post_processing(config['post_processing'])
metric = get_metric(config['metric'])
trainer = Trainer(config=config,
model=model,
criterion=criterion,
train_loader=train_loader,
post_process=post_p,
metric_cls=metric,
validate_loader=validate_loader)
trainer.train()
def load_config(options):
conf = anyconfig.load(options.config_file, "json")
for i, value in vars(options).iteritems():
if value is not None and i in conf:
conf[i] = value
return conf
def main(argv):
args = parser.parse_args(argv)
employee_timelogs = []
for timelogs_file in args.files:
print 'processing %s' % timelogs_file.name
employee_timelogs.append(Timelogs(timelogs_file))
for t in employee_timelogs:
print '############# START #############'
t.pretty_print()
print '############## END ##############'
print '############ SUMMARRY #############'
for t in employee_timelogs:
t.print_summary()
print '############ END SUMMARRY #############'
if args.subcommand == 'freshbooks':
home = os.path.expanduser('~')
config_path = os.path.join(home, '.timelogparser.json')
freshbooks_config = anyconfig.load([config_path], merge=anyconfig.MS_DICTS_AND_LISTS)
freshbooks_args = {'freshbooks': {}}
if args.endpoint:
freshbooks_args['freshbooks'].update({'endpoint': args.endpoint})
if args.token:
freshbooks_args['freshbooks'].update({'token': args.token})
freshbooks_config.update(freshbooks_args, anyconfig.MS_DICTS_AND_LISTS)
if raw_input("send to freshbooks? ").lower().startswith('y'):
freshbooks_client = api.TokenClient(freshbooks_config['freshbooks']['endpoint'],
freshbooks_config['freshbooks']['token'],
user_agent='github/radeinla/timelogparser')
send_to_freshbooks(employee_timelogs, args.client_id, freshbooks_client)
def write(self, custom_config: dict = None):
# Note: this is only dealing with user config
if not os.path.exists(self.config_path):
# Create an empty config
with open(self.config_path, "a"):
os.utime(self.config_path, None)
try:
if not custom_config:
backplane_config = anyconfig.loads(
json.dumps(self.toDict()), ac_parser="json"
)
else:
# Only write user config, not the whole thing
user_config = anyconfig.load([str(self.config_path)])
anyconfig.merge(user_config, self.toDict(custom_config))
backplane_config = user_config
# anyconfig.merge(backplane_config, config)
# if os.path.exists(config_path):
# Open ~/.backplane/contexts/default/backplane.yml
# Save config as yml
with open(self.config_path, "w+") as writer:
writer.write(anyconfig.dumps(backplane_config, ac_parser="yaml"))
return backplane_config
except OSError as e:
raise ConfigNotFound(e)
def __init__(self):
currentDir = os.path.dirname(os.path.realpath(__file__))
configFile = currentDir + "/../" + self.CONFIG_FILE
conf = anyconfig.load(configFile)
bconf = bunch.bunchify(conf)
self.ttsWatson = TtsWatson(bconf.user, bconf.password, bconf.voice,
bconf.url, bconf.chunk)
def checkpoint_to_saved_model(cls, ckpt_dir: str, config_file: str,
output_path: str):
cfg = anyconfig.load(config_file)
config = EasyDict(cfg)
model = MasterModel(
config.model, dataset_utils.LabelTransformer.nclass,
(config.dataset.train.width, config.dataset.train.height))
checkpoint = tf.train.Checkpoint(model=model)
status = checkpoint.restore(ckpt_dir)
status.expect_partial()
model([
tf.random.normal([1, 48, 160, 1], dtype=tf.float32, name='image'),
tf.constant(np.ones([1, 52]), dtype=tf.int32, name='transcript')
])
signatures = {
'decode':
model.decode.get_concrete_function(
tf.TensorSpec([None, 48, 160, 1],
dtype=tf.float32,
name='image'))
}
tf.saved_model.save(model, output_path, signatures=signatures)
print('Model is saved at {}'.format(output_path))
def __load(self):
if not os.path.isfile(self.__path):
return
self.__config = anyconfig.load(
self.__path,
ac_parser=not os.path.splitext(self.__path)[1]
and 'ini').get('pyutrack', {})
def load(path=None, with_defaults=False, validate=False):
"""
Load the configuration.
:param str path: configuration file path. If set to `None`, it makes the configuration file optional, meaning
that either only the defaults will be loaded or that the configuration will be empty. Otherwise the
loading will fail if the file is not found.
:param bool with_defaults: if `True`, loads the default values when they are not specified in the configuration file
:param bool validate: if `True`, validates the configuration. If an error is detected, a `SyntaxError`
will be raised. The error message should indicate which part of the configuration file was invalid.
:returns: (dict) A dictionary representing the configuration.
"""
# Prepare the configuration dictionary, with the default values if requested.
conf = CONFIGURATION_DEFAULTS if with_defaults else {}
# Load the configuration file if specified.
conf_from_file = {} if path is None else anyconfig.load(path)
# Merge the configuration into the dictionary containing the defaults.
# If `with_defaults` is False, this step simply loads the configuration file.
anyconfig.merge(conf, conf_from_file)
# Validate the configuration.
if validate:
(rc, err) = anyconfig.validate(conf, CONFIGURATION_SCHEMA)
if not rc:
raise SyntaxError(err)
return conf
def __init__(self):
logging.basicConfig()
self.logger = logging.getLogger()
self.logger.setLevel(logging.INFO)
self.garage_data = anyconfig.load("garage_data.json")['garage_data']
self.sg = sendgrid.SendGridClient(SENDGRID_USERNAME, SENDGRID_PASSWORD)
self.keen_client = None
def test_10_render_to(self):
ctx = A.load(_CONFFILE_0)
tmpl = _TMPL_0
output = os.path.join(self.workdir, "tmpl.out")
TT.render_to(tmpl, ctx, output, self.tpaths)
self.assertTrue(os.path.exists(output))
def _load_config_file(config_file: Path) -> Dict[str, Any]:
"""Load an individual config file using `anyconfig` as a backend.
Args:
config_file: Path to a config file to process.
Raises:
BadConfigException: If configuration is poorly formatted and
cannot be loaded.
Returns:
Parsed configuration.
"""
# for performance reasons
import anyconfig # pylint: disable=import-outside-toplevel
try:
# Default to UTF-8, which is Python 3 default encoding, to decode the file
with open(config_file, encoding="utf8") as yml:
return {
k: v
for k, v in anyconfig.load(yml).items()
if not k.startswith("_")
}
except AttributeError as exc:
raise BadConfigException(
f"Couldn't load config file: {config_file}"
) from exc
def main():
requests.packages.urllib3.disable_warnings()
defaultConfig = {
'url': 'https://stream.watsonplatform.net/text-to-speech/api',
'user': '******',
'password': '******',
'voice': 'en-US_AllisonVoice',
'chunk': 2048
}
home = os.path.expanduser("~")
defaultConfigFile = home + '/.config-tts-watson.yml'
parser = argparse.ArgumentParser(
description='Text to speech using watson')
parser.add_argument('-f', action='store', dest='configFile', default=defaultConfigFile,
help='config file',
required=False)
parser.add_argument('text_to_transform', action='store', nargs='+')
args = parser.parse_args()
conf = anyconfig.container(defaultConfig)
if not os.path.isfile(args.configFile):
print "Config file '" + args.configFile + "' doesn't exist."
print "Creating it ..."
user = raw_input("Watson user: "******"Watson password: "******" ".join(args.text_to_transform))
def main(config_path: str, dry: bool):
config = load_config(config_path)
for entry in tqdm(
os.scandir(config['working_dir']),
total=len(os.listdir(config['working_dir']))
):
if not entry.name.startswith(f'run{SECTION_SEPARATOR}'):
continue
# switch to correct directory
print(entry.name)
wd = os.getcwd()
os.chdir(entry.path)
# load config
conf_name = (TEMP_CONFIG_NAME
if config['base_config'] is None
else os.path.basename(config['base_config']))
cur_config = anyconfig.load(conf_name)
# execute commands
for cmd in config['exec_command']:
cmd_mod = cmd.format(**cur_config)
print(f' > {cmd_mod}')
if not dry:
os.system(cmd_mod)
os.chdir(wd)
def test_10_get_or_upload_networks(self):
for fpath in self.net_files:
fname = os.path.basename(fpath)
headers = {"content-type": "application/json"}
content = open(fpath).read()
opath = nof.utils.uploaded_filepath(fname,
TT.FT_NETWORKS,
content=content)
nof.utils.ensure_dir_exists(opath)
upath = os.path.join(TT.API_PREFIX, fname)
resp = self.client.post(upath, data=content, headers=headers)
self.assertStatus(resp, 201, resp.data)
self.assertTrue(os.path.exists(opath))
odata = anyconfig.load(opath)
self.assertTrue(odata.get("nodes", False))
self.assertTrue(odata.get("links", False))
fname = os.path.basename(opath) # Updated filename
upath = os.path.join(TT.API_PREFIX, fname)
resp = self.client.get(upath)
self.assert200(resp,
_err_msg(resp, "path: " + upath, "file: " + opath))
self.assertEqual(resp.data, content.encode("utf-8"))
def __init__(self):
self.webcam = self.videocapture()
self.ip_url = "http://192.168.43.67:8080/shot.jpg"
self.height_window = 680
self.width_window = 1540
self.window = self.create_window()
self.canvas = self.create_canvas()
self.button = self.create_button()
self.photo = None
self.count = 0
self.frame_save = None
self.yolomodel = Yolo_opencv()
self.segmentation_image = None
self.segmentation = SegmentCharacter()
cfg = anyconfig.load("config_Cnn.yaml")
cfg = munch.munchify(cfg)
self.recognition = ClassifyService(cfg)
self.bboxes_yolo = None
self.image_result_yolo = None
self.lp_recognition = None
self.tesseract = TesseractRecognition()
#Option
self.type_camera = "IP" #default "IP"
self.modelRecognition = "Segmentation Recognition" #default "Segmentation Recognition"
#Database
self.database = MySQL_Database()
# Label Tkinter
self.label_lp = None
def __init__(self, config_path=None):
path = os.getenv('FIBRATUS_CONFIG_PATH', __DEFAULT_CONFIG_PATH__)
path = config_path or path
try:
self._yaml = anyconfig.load(path, ignore_missing=False)
except FileNotFoundError:
panic('ERROR - %s configuration file does not exist' % path)
def test_10_renderto_sync(self):
ctx = A.load(_CONFFILE_0)
tmpl = _TMPL_0
output = os.path.join(self.workdir, "tmpl.out")
TT.renderto(self.tpaths, ctx, tmpl, output, ask=True, async=False)
self.assertTrue(os.path.exists(output))
def parse(self, config_file=None, specs=None, default_file=None):
"""Read a config_file, check the validity with a JSON Schema as specs
and get default values from default_file if asked.
All parameters are optionnal.
If there is no config_file defined, read the venv base
dir and try to get config/app.yml.
If no specs, don't validate anything.
If no default_file, don't merge with default values."""
self._config_exists(config_file)
self._specs_exists(specs)
self.loaded_config = anyconfig.load(self.config_file, ac_parser='yaml')
if default_file is not None:
self._merge_default(default_file)
if self.specs is None:
return self.loaded_config
self._validate()
return self.loaded_config
def get_config(cls, domain=None):
conf_path = os.path.abspath(
os.path.join(cls.get_current_project(), cls.config_path))
if not os.path.exists(conf_path):
print "config does not exists in {0}".format(conf_path)
try:
print conf_path
conf = anyconfig.load(conf_path, "toml")
if domain is not None:
for k in domain.split("."):
conf = conf[k]
return conf
except Exception as e:
import traceback
print traceback.format_exc()
if "Reserved escape sequence used" in e:
print u"不正な文字（おそらくパス名にバックスラッシュ）が使用されています".encode('cp932')
print conf_path
return None
def _load_file(path):
if anyconfig:
# Note: anyconfig v0.11.0 parses ac_template=False as positive (fixed in v0.11.1).
# https://github.com/ssato/python-anyconfig/pull/126
return anyconfig.load(path, ac_template=False)
else:
with open(path, "r") as reader:
return json.load(reader)
def __init__(self, config_file=None):
"""Construct an instance of the Config object."""
config_list = [os.path.join(sys.path[0], "config_default.yml")]
if config_file:
config_list.append(config_file)
self.config = anyconfig.load(config_list)
def test_dataset():
config = anyconfig.load(
'/home/luning/dev/projects/master-tf/configs/master.yaml')
config = easydict.EasyDict(config)
train_ds, eval_ds = get_dataset(config)
#ds = dataset.LMDBDataset("/home/luning/dev/data/SynthText800k/synth_lmdb", 100, 48)
for index, v in enumerate(eval_ds):
print(index)
def load(path: Path, ftype: typing.Optional[str] = None) -> FileContentType:
"""
:param path: The path to target object
:param filetype: Expected file type, e.g. yaml and json
:return: Loaded content as str or an (maybe mapping) object
"""
return anyconfig.load(path, ac_parser=ftype)
def _merge_default(self, default_file: str) -> None:
if not os.path.isfile(default_file):
raise IOError("Your default ({}) does not exist".format(default_file))
default_config = anyconfig.load(default_file)
anyconfig.merge(default_config, self.loaded_config)
self.loaded_config = default_config
def read(self):
"""
Load the configuration files, set globals.
"""
# Parse the configuration.
self.config = anyconfig.load(self.paths, ignore_missing=True)
def load_config_from_file(self, config_file, force_format=None):
""" Load config from file
Args:
config_file: Config's filename to be loaded
f: Force config format ex. yaml, json
"""
data = anyconfig.load(config_file, force_format)
self.set_cluster(data)
def __init__(self, paths):
"""Initialize the configuration object.
Args:
paths (list): YAML paths, from most to least specific.
"""
config = anyconfig.load(paths, ignore_missing=True)
return super().__init__(config)
def test_12_renderto_async(self):
ctx = A.load(_CONFFILE_0)
tmpl = _TMPL_0
output = os.path.join(self.workdir, "tmpl.out")
job = TT.renderto(self.tpaths, ctx, tmpl, output, ask=False,
async=True)
TT.finish_renderto_procs([job])
self.assertTrue(os.path.exists(output))
def _load_helper(self, **kwargs):
try:
anyconfig.api.load_plugins()
return anyconfig.load(self.conf_path, **kwargs)
except anyconfig.UnknownFileTypeError:
for psr in anyconfig.api.Parsers().list():
print("%r: type=%r, exts=%r" % (psr, psr.type(),
psr.extensions()))
raise
def read(self):
"""
Load the configuration files, set connections.
"""
self.config = anyconfig.load(self.paths, ignore_missing=True)
self.es = self.get_es()
self.rq = self.get_rq()
def load(self, validate=True):
schema_file = os.path.join(sys._MEIPASS, 'schema.yml') \
if hasattr(sys, '_MEIPASS') else self._default_schema_path
try:
self._yaml = anyconfig.load(self.path, ignore_missing=False)
except FileNotFoundError:
panic('ERROR - %s configuration file does not exist' % self.path)
if validate:
validator = Core(source_file=self.path, schema_files=[schema_file])
validator.validate(raise_exception=True)
def test_40_run(self):
for sc in self.scanners:
sc.run()
# pylint: disable=maybe-no-member
outfile = sc._mk_output_path(sc.inputs)
# print >> open("/tmp/t.log", 'a'), "outfile=" + outfile
self.assertTrue(os.path.exists(outfile))
x = anyconfig.load(outfile)
self.assertTrue(x.get("data", None), str(x))
def load_guest_confs(self, name, group=None):
"""
:param name: Guest's name, e.g. satellite-1
:param group: Guest's group, e.g. satellite
"""
confs = self.list_guest_confs(name, group)
logging.info("Loading guest configs: %s", name)
c = anyconfig.load(confs, ac_template=True)
return _add_special_confs(_guest_add_missings(c))
def convert(self, value, param, ctx):
fp = super(AnyConfigType, self).convert(value, param, ctx)
try:
config = anyconfig.load(fp.name)
if not config:
raise ValueError
return config
except ValueError:
self.fail(
'Could not load configuration from file: %s.'
'It must be one of yaml/ini/json' % (fp.name)
)
def __init__(self, optional_env_var=CONFIG_ENV_VAR):
config_paths = [DEFAULT_CONFIG]
env_var_path = os.environ.get(optional_env_var)
if env_var_path:
config_paths.append(env_var_path)
options = anyconfig.load(config_paths, forced_type='yaml',
ignore_missing=False, merge=anyconfig.MS_REPLACE)
self.update(options)
def test_10_gen_site_conf_files(self):
conf = anyconfig.load(CTXS)
tmpldirs = [TMPLDIR]
confdir = TT.gen_site_conf_files(conf, tmpldirs, self.workdir)
dirs = ["common", "guests.d", "host.d", "networks.d"]
for d in dirs:
d = os.path.join(self.workdir, "default", d)
self.assertTrue(os.path.exists(d), "dir=" + d)
self.assertEquals(confdir, os.path.join(self.workdir, "default"))
def load_guest_confs(self, name, group=None):
"""
:param name: Guest's name, e.g. satellite-1
:param group: Guest's group, e.g. satellite
"""
confs = self.list_guest_confs(name, group)
logging.info("Loading guest config files: " + name)
logging.debug("Configs: " + str(confs))
c = anyconfig.load(confs)
return _add_special_confs(_guest_add_missings(c))
def main(argv=sys.argv):
p = option_parser()
(options, args) = p.parse_args(argv[1:])
sos_analyzer.utils.set_loglevel(options.loglevel)
if not args:
p.print_usage()
return -1
conf = anyconfig.load(options.conf) if options.conf else None
if options.workdir:
LOGGER.info("Try using working dir: %s", options.workdir)
sos_analyzer.utils.setup_workdir(options.workdir)
else:
options.workdir = sos_analyzer.utils.setup_workdir()
LOGGER.info("Created working dir: %s", options.workdir)
tarfile = args[0]
datadir = os.path.join(options.workdir, DATA_SUBDIR)
if not os.path.exists(datadir):
LOGGER.info("Create datadir: %s", datadir)
os.makedirs(datadir)
d = sos_analyzer.utils.find_dir_has_target(datadir, "sos_commands")
if d:
LOGGER.info("sosreport archive looks already extracted in %s", d)
datadir = d
else:
LOGGER.info("Extract sosreport archive %s to %s", tarfile, datadir)
sos_analyzer.archive.extract_archive(tarfile, datadir)
d = sos_analyzer.utils.find_dir_has_target(datadir, "sos_commands")
if d:
LOGGER.info("Set datadir to %s", d)
datadir = d
else:
LOGGER.error("No sosreport data found under %s", d)
return -1
sos_analyzer.runner.run_scanners(options.workdir, datadir, conf)
if options.analyze:
sos_analyzer.runner.run_analyzers(options.workdir, datadir, conf)
sos_analyzer.runner.dump_collected_results(options.workdir)
if options.report:
sos_analyzer.runner.run_report_generators(options.workdir,
options.conf)
return 0
def main(argv=sys.argv):
if len(argv) < 5:
print("Usage: %s TEMPLATE_FILE CONTEXT_FILE OUTPUT_FILE TPATHS" % argv[0])
sys.exit(-1)
(template, context_f, output, paths) = argv[1:5]
tpaths = paths.split(':')
context = anyconfig.load(context_f)
anytemplate.render_to(template, context, output, at_paths=tpaths,
at_engine="jinja2", at_ask_missing=True,
extensions=_JINJA2_EXTS)
def main():
defaultConfig = {
'url': 'https://gateway.watsonplatform.net/dialog/api',
'user': '******',
'password': '******',
}
home = os.path.expanduser("~")
defaultConfigFile = home + '/.config-dialog-watson.yml'
parser = argparse.ArgumentParser(
description='Text to speech using watson')
parser.add_argument('-f', action='store', dest='configFile', default=defaultConfigFile,
help='config file',
required=False)
parser.add_argument('dialog_file', action='store', nargs=1)
parser.add_argument('-n', '--name', dest='dialog_name', action='store', help='Dialog name', required=True)
parser.add_argument('--clean', dest='clean', action='store_true')
args = parser.parse_args()
dialog_file = "".join(args.dialog_file)
conf = anyconfig.container(defaultConfig)
if not os.path.isfile(args.configFile):
print "Config file '" + args.configFile + "' doesn't exist."
print "Creating it ..."
user = raw_input("Watson user: "******"Watson password: "******"".join(args.dialog_name), bconf.url,
os.path.dirname(dialog_file) + "/dialog_id_file.txt")
if args.clean:
watsonClient.clean_dialogs()
resp = watsonClient.start_dialog()
print ''
print bcolors.WARNING + "Watson: " + bcolors.OKBLUE + "\n".join(resp.response) + bcolors.ENDC
while True:
userResponse = raw_input(bcolors.WARNING + "You: " + bcolors.OKGREEN)
resp = watsonClient.converse(userResponse)
print bcolors.WARNING + "Watson: " + bcolors.OKBLUE + "\n".join(resp.response) + bcolors.ENDC
if userResponse == "bye":
break
print ""
print "Your profile:"
for name, value in watsonClient.get_profile().get_data().iteritems():
print "\t" + name + ": " + value
if __name__ == "__main__":
main()
def load(self, filename):
"""
Handles the actual loading and preporcessing of files.
Args:
filename (str): the file to load.
Returns:
collection: returns load collection and all recusively loaded ones.
"""
try:
realname = os.path.realpath(filename)
working_path = os.path.dirname(realname)
with working_directory(working_path):
data = anyconfig.load(realname, safe=True)
assert isinstance(data, dict)
if 'includes' in data:
include_data = {}
# Iterate through the includes in order merging
# the dictionaries. NOTE: Ordering matters here.
for include_file in data['includes']:
# Dict entries in new include file can override entries
# already in include_data.
sub = self.load(include_file)
if sub:
if include_data:
include_data.update(sub)
else:
include_data = sub
# Finally, merge the include data with our data
# our data will take priority in the merge if
# duplicate keys are found.
if include_data:
include_data.update(data)
data = include_data
return data
except ValueError as exc:
# If we get a ValueError while building up
# the dict, rethrow the error but supply the
# filename it failed on.
raise ValueError(
'{} file {}'.format(
exc.message,
os.path.realpath(filename)
)
)
def test_10_dump_and_load(self):
obj = dict(name="a", a=1, b=dict(b=[1, 2], c="C"))
obj_path = os.path.join(self.workdir, "a.json")
TT.dump(obj, obj_path)
self.assertTrue(os.path.exists(obj_path))
obj1 = TT.load(obj_path)
self.assertEqual(obj1["name"], obj["name"])
self.assertEqual(obj1["a"], obj["a"])
self.assertEqual(obj1["b"]["b"], obj["b"]["b"])
self.assertEqual(obj1["b"]["c"], obj["b"]["c"])
def make_from_file(cls, filename, name=""):
"""
Loads the settings dict from a file and passes it to Config.make.
Args:
filename (str): name of the file to load
name (str, optional): the name of the config
Returns:
Config: the created config obj
"""
settings = anyconfig.load(filename, safe=True)
return cls.make(settings=settings, name=name)
def test_30_compile_conf_templates(self):
conf = A.load(_CONFFILE_0)
tmpldirs = self.tpaths
templates_key = "ddd_templates"
TT.compile_conf_templates(conf, tmpldirs, self.workdir, templates_key)
# see miniascape/tests/00_sample.yml:ddd_templates.*.dst
self.assertTrue(os.path.exists(os.path.join(self.workdir,
"a/b/c/00_sample.out")))
self.assertTrue(os.path.exists(os.path.join(self.workdir,
"00_sample.tmpl")))
self.assertFalse(os.path.exists(os.path.join(self.workdir,
"dummy_out")))
