def __init__(
self,
api: falcon.API,
project_name: str,
api_hosts: Union[str, Sequence[str]] = "/",
api_version: str = "1.0.0",
description: str = "",
):
"""Resource for '/swagger.yaml'
:param api: Your falcon.API instance
:param project_name: Title for your documentation
:param api_hosts: List of places where api can be
:param api_version: String with number of version of you project
:param description: Absolute path to template with description of your project
"""
public_resources = set()
spec = APISpec(
title=project_name,
version=api_version,
openapi_version="3.0.2",
info={"description": description},
plugins=[MarshmallowPlugin()],
)
routes = collect_routes(api)
for resource in {type(route.resource) for route in routes}:
if resource.Meta.skip_doc:
continue
if resource.Meta.auth:
public_resources.add(resource)
spec.components.schema(resource.Meta.name, schema=resource)
models_definition = spec.to_dict()
docs = APIDocs(routes, models_definition, api_hosts,
frozenset(public_resources))
docs_data = docs.run()
pyaml.add_representer(
Decimal,
lambda dumper, data: dumper.represent_scalar(
"tag:yaml.org,2002:str", str(data)),
)
self.data = pyaml.dump(docs_data, safe=True)
**hp_info
} for category, hparams in hparam_infos.items()
for hp_name, hp_info in hparams.items()]
metric_infos = [{
'tag': f'val/metric/{score_type}/{n}',
'display_name': f'{score_type}/{n}',
'dataset_type': 'validation'
} for score_type, names in metric_infos.items() for n in names]
experiment = {
'name': 'proteins',
'time_created_secs': int((args.datetime_created.timestamp()))
}
pyaml.add_representer(type,
lambda dumper, data: dumper.represent_str(data.__name__))
pyaml.print(
{
'experiment': experiment,
'hparams': hparam_infos,
'metrics': metric_infos
},
safe=True,
sort_dicts=False,
force_embed=True)
folder = (Path(args.folder) / 'hparams').expanduser().resolve()
with SummaryWriter(folder) as writer:
experiment_summary = make_experiment_summary(hparam_infos, metric_infos,
experiment)
writer.file_writer.add_summary(experiment_summary,
# Make it so yaml multi line strings use the | syntax that we prefer
def str_presenter(dumper, data):
data = data.rstrip()
if len(data.splitlines()) > 1: # check for multiline string
return dumper.represent_scalar('tag:yaml.org,2002:str',
data,
style='|')
if data.startswith('{') or data.endswith('}'):
return dumper.represent_scalar('tag:yaml.org,2002:str',
data,
style="'")
return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='')
pyaml.add_representer(str, str_presenter)
def represent_ordereddict(dumper, data):
value = []
if 'name' in data and 'suites' in data:
for key in ['name', 'suites', 'type', 'args']:
value.append(
(dumper.represent_data(key), dumper.represent_data(data[key])))
else:
for item_key, item_value in data.items():
node_key = dumper.represent_data(item_key)
node_value = dumper.represent_data(item_value)
value.append((node_key, node_value))
import uuid
from pyaml import UnsafePrettyYAMLDumper, add_representer
import jsondiff
from .symbols import insert, delete
# replace object symbols with more portable JSON ones: + and -
jsondiff.insert = insert
jsondiff.delete = delete
# handle Symbols from jsondiff in pyyaml/pyaml
add_representer(
jsondiff.Symbol,
lambda s, o: s.represent_scalar('tag:yaml.org,2002:str', str(o)))
add_representer(uuid.UUID, UnsafePrettyYAMLDumper.represent_stringish)
try:
import asyncpg
except ImportError:
pass
else:
add_representer(asyncpg.Record, UnsafePrettyYAMLDumper.represent_dict)
# for pyaml, do not print out aliases
UnsafePrettyYAMLDumper.ignore_aliases = lambda *a: True
ok = 1
x = math.floor(v) # integer part
y = v - x # fractional part
i = int(round(y * (len(blocks) - 1)))
bar = "█" * x
barfrac = blocks[i]
n = width - x - 1
nobar = fill * n
if reverse:
bar = f'{lsep}{nobar}{barfrac}{bar}{rsep}'
else:
bar = f'{lsep}{bar}{barfrac}{nobar}{rsep}'
return bar
def model_to_dict(m):
d = dict()
for s in str(m).split('\n'):
s = s.strip()
if s == '':
continue
k, v = s.split(':', 1)
d[k] = v.strip()
return d
pyaml.add_representer(np.float64, lambda s, d: s.represent_float(d))
pyaml.add_representer(np.float32, lambda s, d: s.represent_float(d))
pyaml.add_representer(np.int32, lambda s, d: s.represent_int(d))
pyaml.add_representer(np.int64, lambda s, d: s.represent_int(d))
pyaml.add_representer(None, lambda s, d: s.represent_str(str(d)))
return os.getenv(name, *args)
# check default value
defval = self[name]['default']
if defval != self._NODEFUALT and len(args) == 0:
args = (defval, )
result = os.getenv(name, *args)
if result == '':
result = None
if result is None:
msg = f"env var {name} ({self[name]['description']}) is not set"
if len(args) == 0:
raise ValueError(msg)
else:
result = args[0]
self.logger.debug(msg + f', use default {result}')
return result
def summary(self):
"""Return a string as a summary of the env vars."""
result = {}
for k, v in self.items():
result[k] = dict(value=self.get(k), **v)
return result
env_registry = EnvRegistry.create()
"""A global environment variable registry instance."""
pyaml.add_representer(EnvRegistry, lambda s, d: s.represent_dict(d.summary()))