def _construct(item: Any) -> Sequence[Any]:
result = None
if isinstance(item, str) and item in variables:
result = variables[item]
if isinstance(item, str) and item not in variables:
result = CobaRegistry.construct(item)
if isinstance(item, dict):
result = CobaRegistry.construct(item)
if isinstance(item, list):
pieces = list(map(_construct, item))
if hasattr(pieces[0][0], 'read'):
result = [
Pipes.join(s, *f) for s in pieces[0]
for f in product(*pieces[1:])
]
else:
result = sum(pieces, [])
if result is None:
raise CobaException(
f"We were unable to construct {item} in the given environment definition file."
)
return result if isinstance(
result, collections.abc.Sequence) else [result]
def test_not_registered(self):
CobaRegistry.register("test", TestObject)
with self.assertRaises(Exception) as cm:
CobaRegistry.construct("test2")
self.assertEqual("Unknown recipe test2", str(cm.exception))
def _config(cls) -> Dict[str, Any]:
if cls._config_backing is None:
try:
_raw_config: Dict[str, Any] = {
"api_keys": collections.defaultdict(lambda: None),
"cacher": {
"DiskCacher": None
},
"logger": {
"IndentLogger": "Console"
},
"experiment": {
"processes": 1,
"maxchunksperchild": 0,
"chunk_by": "source"
}
}
for key, value in cls._load_file_configs().items():
if key in _raw_config and isinstance(
_raw_config[key],
dict) and not CobaRegistry.is_known_recipe(value):
if key == "experiment" and "maxtasksperchild" in value:
value["maxchunksperchild"] = value[
"maxtasksperchild"]
del value["maxtasksperchild"]
_raw_config[key].update(value)
else:
_raw_config[key] = value
cls._config_backing = {
'api_keys': _raw_config['api_keys'],
'cacher': CobaRegistry.construct(_raw_config['cacher']),
'logger': CobaRegistry.construct(_raw_config['logger']),
'experiment': ExperimentConfig(**_raw_config['experiment'])
}
except CobaException as e:
messages = [
'',
"ERROR: An error occured while initializing CobaContext. Execution is unable to continue. Please see below for details:",
f" > {e}", ''
]
coba_exit('\n'.join(messages))
except Exception as e:
messages = [
'',
"ERROR: An error occured while initializing CobaContext. Execution is unable to continue. Please see below for details:",
''.join(traceback.format_tb(e.__traceback__)), ''.join(
traceback.TracebackException.from_exception(
e).format_exception_only())
]
coba_exit('\n'.join(messages))
return cls._config_backing
def test_invalid_recipe2(self):
CobaRegistry.register("test", TestObject)
recipe = {"test": [1, 2, 3], "name": "test", "args": [4, 5, 6]}
with self.assertRaises(Exception) as cm:
CobaRegistry.construct(recipe)
self.assertEqual(f"Invalid recipe {str(recipe)}", str(cm.exception))
def test_invalid_recipe3(self):
CobaRegistry.register("test", TestObject)
recipe = {"test": {"a": 1}, "name": "test", "kwargs": {"a": 1}}
with self.assertRaises(Exception) as cm:
CobaRegistry.construct(recipe)
self.assertEqual(f"Invalid recipe {str(recipe)}", str(cm.exception))
def filter(self, config: Dict[str,Any]) -> 'Benchmark':
variables = { k: CobaRegistry.construct(v) for k,v in config.get("variables",{}).items() }
def _construct(item:Any) -> Sequence[Any]:
result = None
if isinstance(item, str) and item in variables:
result = variables[item]
if isinstance(item, str) and item not in variables:
result = CobaRegistry.construct(item)
if isinstance(item, dict):
result = CobaRegistry.construct(item)
if isinstance(item, list):
if any([ isinstance(i,list) for i in item ]):
raise Exception("Recursive structures are not supported in benchmark simulation configs.")
pieces = list(map(_construct, item))
result = [ Pipe.join(s, f) for s in pieces[0] for f in product(*pieces[1:])]
if result is None:
raise Exception(f"We were unable to construct {item} in the given benchmark file.")
return result if isinstance(result, collections.Sequence) else [result]
if not isinstance(config['simulations'], list): config['simulations'] = [config['simulations']]
simulations = [ simulation for recipe in config['simulations'] for simulation in _construct(recipe)]
return Benchmark(simulations)
def test_registered_create_array_arg(self):
CobaRegistry.register("test", TestArgObject)
klass = CobaRegistry.construct({"test": [1, 2, 3]})
self.assertEqual(klass.arg, [1, 2, 3])
def test_registered_create_args_kwargs(self):
CobaRegistry.register("test", TestObject)
klass = CobaRegistry.construct({"test": [1, 2, 3], "kwargs": {"a": 1}})
self.assertEqual(klass.args, (1, 2, 3))
self.assertEqual(klass.kwargs, {"a": 1})
def test_registered_create(self):
CobaRegistry.register("test", TestObject)
klass = CobaRegistry.construct("test")
self.assertEqual(klass.args, ())
self.assertEqual(klass.kwargs, {})
def test_registered_create_args3(self):
CobaRegistry.register("test", TestObject)
klass = CobaRegistry.construct({"test": "abc"})
self.assertEqual(klass.args, ("abc", ))
self.assertEqual(klass.kwargs, {})
def test_register_decorator(self):
@coba_registry_class("MyTestObject")
class MyTestObject(TestObject):
pass
klass = CobaRegistry.construct("MyTestObject")
self.assertIsInstance(klass, MyTestObject)
self.assertEqual(klass.args, ())
self.assertEqual(klass.kwargs, {})
def test_registered_create_foreach1(self):
CobaRegistry.register("test", TestObject)
recipe = {"test": [[1, 2, 3]], "kwargs": {"a": 1}, "method": "foreach"}
klasses = CobaRegistry.construct(recipe)
self.assertEqual(len(klasses), 1)
self.assertEqual(klasses[0].args, (1, 2, 3))
self.assertEqual(klasses[0].kwargs, {"a": 1})
def test_registered_create_recursive3(self):
CobaRegistry.register("test", TestObject)
klass = CobaRegistry.construct({"test": {"a": "test"}})
self.assertEqual(klass.args, ())
self.assertEqual(1, len(klass.kwargs))
self.assertIsInstance(klass.kwargs["a"], TestObject)
self.assertEqual(klass.kwargs["a"].args, ())
self.assertEqual(klass.kwargs["a"].kwargs, {})
def _construct(item:Any) -> Sequence[Any]:
result = None
if isinstance(item, str) and item in variables:
result = variables[item]
if isinstance(item, str) and item not in variables:
result = CobaRegistry.construct(item)
if isinstance(item, dict):
result = CobaRegistry.construct(item)
if isinstance(item, list):
if any([ isinstance(i,list) for i in item ]):
raise Exception("Recursive structures are not supported in benchmark simulation configs.")
pieces = list(map(_construct, item))
result = [ Pipe.join(s, f) for s in pieces[0] for f in product(*pieces[1:])]
if result is None:
raise Exception(f"We were unable to construct {item} in the given benchmark file.")
return result if isinstance(result, collections.Sequence) else [result]
def from_file(arg) -> 'Benchmark': #type: ignore
"""Instantiate a Benchmark from a config file."""
if isinstance(arg, str) and arg.startswith('http'):
content = '\n'.join(ResponseToLines().filter(
HttpSource(arg).read()))
elif isinstance(arg, str) and not arg.startswith('http'):
content = '\n'.join(DiskSource(arg).read())
else:
content = arg.read() #type: ignore
return CobaRegistry.construct(CobaConfig.Benchmark['file_fmt']).filter(
JsonDecode().filter(content))
def test_registered_create_foreach4(self):
CobaRegistry.register("test", TestObject)
recipe = {"test": [[1, 2], 3], "method": "foreach"}
klasses = CobaRegistry.construct(recipe)
self.assertEqual(len(klasses), 2)
self.assertEqual(klasses[0].args, (1, 2))
self.assertEqual(klasses[0].kwargs, {})
self.assertEqual(klasses[1].args, (3, ))
self.assertEqual(klasses[1].kwargs, {})
def read(self) -> Sequence[Environment]:
definitions: dict = JsonDecode().filter('\n'.join(self._source.read()))
variables = {
k: CobaRegistry.construct(v)
for k, v in definitions.get("variables", {}).items()
}
def _construct(item: Any) -> Sequence[Any]:
result = None
if isinstance(item, str) and item in variables:
result = variables[item]
if isinstance(item, str) and item not in variables:
result = CobaRegistry.construct(item)
if isinstance(item, dict):
result = CobaRegistry.construct(item)
if isinstance(item, list):
pieces = list(map(_construct, item))
if hasattr(pieces[0][0], 'read'):
result = [
Pipes.join(s, *f) for s in pieces[0]
for f in product(*pieces[1:])
]
else:
result = sum(pieces, [])
if result is None:
raise CobaException(
f"We were unable to construct {item} in the given environment definition file."
)
return result if isinstance(
result, collections.abc.Sequence) else [result]
if not isinstance(definitions['environments'], list):
definitions['environments'] = [definitions['environments']]
return [
environment for recipe in definitions['environments']
for environment in _construct(recipe)
]
def test_registered_create_foreach3(self):
CobaRegistry.register("test", TestObject)
recipe = {
"test": [1, 2],
"kwargs": [{
"a": 1
}, {
"a": 2
}],
"method": "foreach"
}
klasses = CobaRegistry.construct(recipe)
self.assertEqual(len(klasses), 2)
self.assertEqual(klasses[0].args, (1, ))
self.assertEqual(klasses[0].kwargs, {"a": 1})
self.assertEqual(klasses[1].args, (2, ))
self.assertEqual(klasses[1].kwargs, {"a": 2})
def Logger(cls) -> Logger:
if cls._log is None:
cls._log = CobaRegistry.construct(cls._load_config()['logger'])
return cls._log
def Cacher(cls) -> Cacher[str, bytes]:
if cls._cache is None:
cls._cache = CobaRegistry.construct(cls._load_config()['cacher'])
return cls._cache
def test_registered_create_dict_arg(self):
CobaRegistry.register("test", TestArgObject)
with self.assertRaises(Exception):
klass = CobaRegistry.construct({"test": {"a": 1}})
