def check(self):
""" Verify options exists
"""
for opt in self.spec_options:
try:
# Support new option format
key = opt["key"]
is_required = opt.get("required", False)
deep_get(self.spec, key)
except (KeyError, TypeError):
if is_required:
raise SpecConfigException(f"A required {key} not found, stopping.")
def get_compose_version(self):
compose_version = deep_get(self.docker, 'compose.version')
if compose_version:
if float(compose_version) < deep_get(
self.defaults, 'docker-compose.version.minimum'):
raise Exception(
f"devdock requires at least version "
f"{deep_get(self.defaults, 'docker-compose.version.minimum')} "
f"for docker-compose format")
else:
compose_version = str(
deep_get(self.defaults, 'docker-compose.version.auto'))
return compose_version
def expand_employee(target, paths):
"""
get the values given a path from the target, likely to be an integer key.
lookup the "foreign" keys from in-memory db
set the values given a path to the target.
:param target: employee
:param paths: dot noted keys
:return: enritched employee
"""
# resolve the path for each recursive key path
obj = target.copy()
for key_path in paths:
_id = dict_deep.deep_get(obj, key_path)
if type(_id) is dict:
_id = _id['id']
# skip also null "foreign keys"
if not _id:
continue
# root key comes first
db_key = key_path.split(".")[-1]
try:
record = db[db_key][_id].copy()
except KeyError:
raise KeyError(f"Could not resolve path for '{key_path}'")
except Exception:
raise
dict_deep.deep_set(obj, key_path, record)
return obj
def get_plugin_option(self, key):
""" Return option defined within a spec plugin
"""
try:
val = deep_get(self.spec, key)
return self._convert_to_env(val)
except (KeyError, TypeError):
app.log.debug(f"Option {key} - unavailable, skipping")
return None
def extract_from_tags(self, metadata) -> Dict[str, Any]:
tags = {
"authors": ["author"],
"description": ["description"],
"type": ["og.type"],
"url": ["og.url"],
"site": ["og.site_name"],
"site_twitter": ["twitter.site"],
}
result = {}
for key, locations in tags.items():
for loc in locations:
x = deep_get(metadata, loc)
if x is not None:
result[key] = x
break
if "authors" in result and type(result["authors"]) is not list:
result["authors"] = [result["authors"]]
return result
def try_get(self, prop, default):
if '.' in prop:
value = deep_get(self._data, prop)
return value if value else default
else:
return self._data[prop] if prop in self._data else default
def get_config(prop_path, default_value=None):
v = deep_get(cfg, prop_path)
if v is None:
return default_value
return v