def test_load_git_ok(self):
example_repo_config = config.RepositoryConfig(repoType="git",
repoUrl=self.repo_url)
sys_config = config.RuntimeConfig()
sys_config.repositories["example_repo"] = example_repo_config
stub_model_def = meta.ModelDefinition(
language="python",
repository="example_repo",
path="examples/models/python/hello_world",
entryPoint="hello_world.HelloWorldModel",
version=self.commit_hash)
loader = models.ModelLoader(sys_config)
loader.create_scope(self.test_scope)
model_class = loader.load_model_class(self.test_scope, stub_model_def)
model = model_class()
self.assertIsInstance(model_class, api.TracModel.__class__)
self.assertIsInstance(model, model_class)
self.assertIsInstance(model, api.TracModel)
loader.destroy_scope(self.test_scope)
def test_load_local_ok(self):
example_repo_url = pathlib.Path(__file__) \
.joinpath("../../../../../../..") \
.joinpath("examples/models/python") \
.resolve()
example_repo_config = config.RepositoryConfig(
repoType="local", repoUrl=str(example_repo_url))
sys_config = config.RuntimeConfig()
sys_config.repositories["example_repo"] = example_repo_config
stub_model_def = meta.ModelDefinition(
language="python",
repository="example_repo",
path="hello_world",
entryPoint="hello_world.HelloWorldModel")
loader = models.ModelLoader(sys_config)
loader.create_scope(self.test_scope)
model_class = loader.load_model_class(self.test_scope, stub_model_def)
model = model_class()
self.assertIsInstance(model_class, api.TracModel.__class__)
self.assertIsInstance(model, model_class)
self.assertIsInstance(model, api.TracModel)
loader.destroy_scope(self.test_scope)
def test_scan_model_ok(self):
def _td(basic_type: meta.BasicType) -> meta.TypeDescriptor:
return meta.TypeDescriptor(basic_type)
sys_config = config.RuntimeConfig()
loader = models.ModelLoader(sys_config)
model_class = SampleModel
model_def = loader.scan_model(model_class)
self.assertIsInstance(model_def, meta.ModelDefinition)
self.assertIsInstance(model_def.parameters, dict)
self.assertEqual({"param1", "param2"},
set(model_def.parameters.keys()))
self.assertEqual(
_td(meta.BasicType.INTEGER),
model_def.parameters["param1"].paramType,
)
self.assertEqual(_td(meta.BasicType.STRING),
model_def.parameters["param2"].paramType)
self.assertIsInstance(model_def.inputs, dict)
self.assertEqual({"input_table_1"}, set(model_def.inputs.keys()))
self.assertEqual(meta.SchemaType.TABLE,
model_def.inputs["input_table_1"].schema.schemaType)
input_table_schema = model_def.inputs["input_table_1"].schema.table
self.assertIsInstance(input_table_schema, meta.TableSchema)
self.assertEqual(4, len(input_table_schema.fields))
self.assertEqual(0, input_table_schema.fields[0].fieldOrder)
self.assertEqual("input_field_2",
input_table_schema.fields[1].fieldName)
self.assertEqual(meta.BasicType.STRING,
input_table_schema.fields[2].fieldType)
self.assertEqual("Input field 4", input_table_schema.fields[3].label)
self.assertEqual(True, input_table_schema.fields[0].businessKey)
self.assertEqual(True, input_table_schema.fields[2].categorical)
self.assertIsInstance(model_def.outputs, dict)
self.assertEqual({"output_table_1"}, set(model_def.outputs.keys()))
self.assertEqual(meta.SchemaType.TABLE,
model_def.outputs["output_table_1"].schema.schemaType)
output_table_schema = model_def.outputs["output_table_1"].schema.table
self.assertIsInstance(output_table_schema, meta.TableSchema)
self.assertEqual(
3,
len(output_table_schema.fields),
)
self.assertEqual("output_field_1",
output_table_schema.fields[0].fieldName)
self.assertEqual(1, output_table_schema.fields[1].fieldOrder)
self.assertEqual(meta.BasicType.FLOAT,
output_table_schema.fields[2].fieldType)
self.assertEqual("Output field 3", output_table_schema.fields[2].label)
self.assertEqual(True, output_table_schema.fields[0].businessKey)
def _generate_model_for_entry_point(
cls, sys_config: _cfg.RuntimeConfig, model_entry_point: str) \
-> (_meta.TagHeader, _meta.ObjectDefinition):
model_id = _util.new_object_id(_meta.ObjectType.MODEL)
model_key = _util.object_key(model_id)
cls._log.info(f"Generating model definition for [{model_entry_point}] with ID = [{model_key}]")
skeleton_modeL_def = _meta.ModelDefinition( # noqa
language="python",
repository="trac_integrated",
entryPoint=model_entry_point,
parameters={},
inputs={},
outputs={})
loader = _models.ModelLoader(sys_config)
try:
loader.create_scope("DEV_MODE_TRANSLATION")
model_class = loader.load_model_class("DEV_MODE_TRANSLATION", skeleton_modeL_def)
model_scan = loader.scan_model(model_class)
finally:
loader.destroy_scope("DEV_MODE_TRANSLATION")
model_def = _meta.ModelDefinition( # noqa
language="python",
repository="trac_integrated",
entryPoint=model_entry_point,
parameters=model_scan.parameters,
inputs=model_scan.inputs,
outputs=model_scan.outputs)
model_object = _meta.ObjectDefinition(
objectType=_meta.ObjectType.MODEL,
model=model_def)
return model_id, model_object
def start(self, wait: bool = False):
try:
self._log.info("Starting the engine...")
self._models = _models.ModelLoader(self._sys_config)
self._storage = _storage.StorageManager(self._sys_config,
self._sys_config_dir)
self._engine = _engine.TracEngine(self._sys_config,
self._models,
self._storage,
batch_mode=self._batch_mode)
self._system = _actors.ActorSystem(self._engine,
system_thread="engine")
self._system.start(wait=wait)
except Exception as e:
self._handle_startup_error(e)
def test_load_integrated_ok(self):
sys_config = config.RuntimeConfig()
sys_config.repositories["trac_integrated"] = config.RepositoryConfig(
repoType="integrated")
stub_model_def = meta.ModelDefinition(
language="python",
repository="trac_integrated",
entryPoint="tracdap_test.rt.impl.test_models.SampleModel")
loader = models.ModelLoader(sys_config)
loader.create_scope(self.test_scope)
model_class = loader.load_model_class(self.test_scope, stub_model_def)
model = model_class()
self.assertIsInstance(model_class, api.TracModel.__class__)
self.assertIsInstance(model, model_class)
self.assertIsInstance(model, api.TracModel)
loader.destroy_scope(self.test_scope)