def test_create_existing_model(meta: MetadataRepository, project: Project,
task: Task, model: Model, model2: Model):
task.project = meta.create_project(project)
task = meta.create_task(task)
assert task is not None
model.task_id = task.id
model = meta.create_model(model)
assert model is not None
model2.task_id = task.id
model2.name = model.name
with pytest.raises(ExistingModelError):
meta.create_model(model2)
def test_update_task_is_reference(meta: MetadataRepository, project: Project,
model: Model):
task_entity = Task("Test Task")
task_entity.project = meta.create_project(project)
task = meta.create_task(task_entity)
assert task is not None
id = task.id
model.task_id = task.id
model = meta.create_model(model)
task.name = "Test Task 2"
task.add_model(model)
task = meta.update_task(task)
assert id == task.id
assert "Test Task 2" == task.name
assert model == task.models.get(model.id)
task.name = "KEK"
actual_task = meta.get_task_by_id(task.id)
assert_objects_equal_except_fields(task,
actual_task,
excepted_fields=['name'])
def len_model():
def f2(a):
return len(a)
model = Model.create(f2, 'a', '2')
model._id = 2
return model
def test_update_model_source_is_changed(meta: MetadataRepository,
project: Project, task: Task,
model: Model):
task.project = meta.create_project(project)
task = meta.create_task(task)
assert task is not None
model.task_id = task.id
saved_model = meta.create_model(model)
assert saved_model is not None
id = saved_model.id
saved_model = update_object_fields(model,
excepted_fields=[
'id', 'wrapper', 'artifact',
'output_meta', 'input_meta',
'requirements', 'transformer',
'task_id'
])
saved_model = meta.update_model(saved_model)
assert id == saved_model.id
assert model == meta.get_model_by_id(saved_model.id)
assert model is saved_model
def test_save_updated_existing_model_with_existing_name(
meta: MetadataRepository, project: Project, task: Task, model: Model,
model2: Model):
project = meta.create_project(project)
task.project = project
task = meta.create_task(task)
model.task_id = task.id
model = meta.create_model(model)
model2.task_id = task.id
model2 = meta.create_model(model2)
model.name = model2.name
with pytest.raises(ExistingModelError):
meta.save_model(model)
def test_update_task_with_models(meta: MetadataRepository, project: Project,
task: Task, model: Model):
task.project = meta.create_project(project)
task = meta.create_task(task)
assert task is not None
id = task.id
model.task = task
model = meta.create_model(model)
task.add_model(model)
task = update_object_fields(task,
excepted_fields=['id', 'models', 'project_id'])
model = update_object_fields(model,
excepted_fields=[
'id', 'wrapper', 'artifact',
'output_meta', 'input_meta',
'requirements', 'transformer', 'task_id'
])
updated_task = meta.update_task(task)
assert id == task.id
assert updated_task is task
assert task == meta.get_task_by_id(task.id)
assert len(task.models) == 1
assert model.id in task.models
assert model == meta.get_model_by_id(model.id)
assert meta.get_model_by_id(model.id).name == 'Test Model2'
assert task.has_meta_repo
def test_push_model(ebnt: Ebonite, model: Model):
task = ebnt.get_or_create_task("Project", "Task1")
model.task_id = task.id # For test purpose
pushed_model = ebnt.push_model(model)
assert model.name == pushed_model.name
assert task.id == pushed_model.task_id
def test_push_model_with_same_name(ebnt: Ebonite, model: Model):
task = ebnt.get_or_create_task("Project", "Task1")
model = ebnt.push_model(model, task)
model._id = None
with pytest.raises(ExistingModelError):
ebnt.push_model(model, task)
def double_model():
def f1(a):
return a + a
model = Model.create(f1, 'a', '1')
model._id = 1
return model
def test_create_model(sklearn_model_obj, pandas_data):
model = Model.create(sklearn_model_obj, pandas_data)
assert model is not None
assert isinstance(model.wrapper, SklearnModelWrapper)
input_meta, output_meta = model.wrapper.method_signature('predict')
assert input_meta.columns == list(pandas_data)
assert output_meta.real_type == np.ndarray
assert {'numpy', 'sklearn', 'pandas'}.issubset(model.requirements.modules)
def test_push_model_with_task_and_task_argument_with_different_project(ebnt: Ebonite, model: Model):
task = ebnt.get_or_create_task("Project", "Task1")
task2 = ebnt.get_or_create_task("Project2", "Task1")
model.task = task2 # For test purpose
with pytest.raises(ValueError):
ebnt.push_model(model, task)
def model(data, prediction):
dataset_meta = DatasetAnalyzer.analyze(data)
output_meta = DatasetAnalyzer.analyze(prediction)
return Model('test model',
SklearnModelWrapper(),
input_meta=dataset_meta,
output_meta=output_meta,
requirements=Requirements([]))
def factory(saved=False):
nonlocal counter
counter += 1
model = Model('Test Model-{}'.format(counter), DummyModelWrapper())
if saved:
task = task_factory(True)
task.add_model(model)
return model
def test_get_models(meta: MetadataRepository, project: Project, task: Task,
model: Model):
task.project = meta.create_project(project)
created_task = meta.create_task(task)
model.task = created_task
created_model = meta.create_model(model)
actual_models = meta.get_models(created_task)
assert actual_models == [created_model]
def test_create_model_with_custom_wrapper(sklearn_model_obj, pandas_data):
wrapper = SklearnModelWrapper().bind_model(sklearn_model_obj, input_data=pandas_data)
model = Model.create(sklearn_model_obj, pandas_data, custom_wrapper=wrapper)
assert model is not None
assert model.wrapper is wrapper
input_meta, output_meta = model.wrapper.method_signature('predict')
assert input_meta.columns == list(pandas_data)
assert output_meta.real_type == np.ndarray
assert {'numpy', 'sklearn', 'pandas'}.issubset(model.requirements.modules)
def test_create_model(sklearn_model_obj, pandas_data):
model = Model.create(sklearn_model_obj, pandas_data)
assert model is not None
assert isinstance(model.wrapper, SklearnModelWrapper)
assert model.input_meta.columns == list(pandas_data)
# assert model.input_meta. == data.values
assert model.output_meta.real_type == np.ndarray
assert {'numpy', 'sklearn', 'pandas'}.issubset(model.requirements.modules)
def test_create_model_source_is_changed(meta: MetadataRepository,
project: Project, task: Task,
model: Model):
task.project = meta.create_project(project)
task = meta.create_task(task)
assert task is not None
model.task_id = task.id
saved_model = meta.create_model(model)
assert saved_model is model
def delete_model_ok(ebnt: Ebonite):
task = ebnt.get_or_create_task('Project', 'Task')
model = Model(name='Model', task_id=task.id)
model = ebnt.meta_repo.create_model(model)
assert ebnt.meta_repo.get_task_by_id(task.id) is not None
assert ebnt.meta_repo.get_model_by_id(model.id) is not None
ebnt.delete_model(model)
assert ebnt.meta_repo.get_model_by_id(model.id) is None
def test_create_model(meta: MetadataRepository, project: Project, task: Task,
model: Model):
task.project = meta.create_project(project)
task = meta.create_task(task)
assert task is not None
model.task_id = task.id
model = meta.create_model(model)
assert model is not None
assert model.has_meta_repo
def test_create_model_with_custom_wrapper(sklearn_model_obj, pandas_data):
wrapper = SklearnModelWrapper().bind_model(sklearn_model_obj)
model = Model.create(sklearn_model_obj,
pandas_data,
custom_wrapper=wrapper)
assert model is not None
assert isinstance(model.wrapper, SklearnModelWrapper)
assert model.input_meta.columns == list(pandas_data)
assert model.output_meta.real_type == np.ndarray
assert {'numpy', 'sklearn', 'pandas'}.issubset(model.requirements.modules)
def test_update_not_existing_model(meta: MetadataRepository, project: Project,
task: Task, model: Model):
task.project = meta.create_project(project)
task = meta.create_task(task)
assert task is not None
model.task_id = task.id
with pytest.raises(NonExistingModelError):
meta.update_model(model)
def test_create_model_with_additional_artifact(artifact, sklearn_model_obj, pandas_data, artifact_repository):
model = Model.create(sklearn_model_obj, pandas_data, additional_artifacts=artifact)
assert model is not None
model._id = 'test_model'
artifact_repository.push_model_artifacts(model)
assert len(model.artifact_req_persisted.bytes_dict()) == 4
model_payloads = model.artifact_req_persisted.bytes_dict()
for name, payload in artifact.bytes_dict().items():
assert name in model_payloads
assert model_payloads[name] == payload
def test_create_model_with_custom_requirements(sklearn_model_obj, pandas_data):
requirements = Requirements([
InstallableRequirement('dumb', '0.4.1'),
InstallableRequirement('art', '4.0')
])
model = Model.create(sklearn_model_obj,
pandas_data,
custom_requirements=Requirements([Requirement()]))
assert model is not None
assert all(req in [r.module for r in requirements.installable]
for req in model.requirements.installable)
def to_obj(self) -> Model:
model = Model(name=self.name,
author=self.author,
creation_date=self.creation_date,
wrapper=safe_loads(self.wrapper, ModelWrapper),
artifact=safe_loads(self.artifact, ArtifactCollection),
input_meta=safe_loads(self.input_meta, DatasetType),
output_meta=safe_loads(self.output_meta, DatasetType),
requirements=safe_loads(self.requirements, Requirements),
id=tostr(self.id),
task_id=tostr(self.task_id))
return self.attach(model)
def to_obj(self) -> Model:
model = Model(name=self.name,
wrapper_meta=safe_loads(self.wrapper, dict),
author=self.author,
creation_date=self.creation_date,
artifact=safe_loads(self.artifact, ArtifactCollection),
requirements=safe_loads(self.requirements, Requirements),
description=self.description,
params=safe_loads(self.params, Dict[str, Any]),
id=self.id,
task_id=self.task_id)
return self.attach(model)
def test_create_model_is_reference(meta: MetadataRepository, project: Project,
task: Task, model: Model):
task.project = meta.create_project(project)
task = meta.create_task(task)
assert task is not None
model.task_id = task.id
model = meta.create_model(model)
assert model is not None
model.name = "KEK"
actual_model = meta.get_model_by_id(model.id)
assert_objects_equal_except_fields(model,
actual_model,
excepted_fields=['name'])
model.task_id = None
actual_model = meta.get_model_by_id(model.id)
assert_objects_equal_except_fields(model,
actual_model,
excepted_fields=['name', 'task_id'])
def test_save_existing_model(meta: MetadataRepository, project: Project,
task: Task, model: Model):
project = meta.create_project(project)
task.project = project
task = meta.create_task(task)
model.task_id = task.id
model = meta.create_model(model)
saved_model = meta.save_model(model)
assert saved_model.id == model.id
assert saved_model.task_id == model.task_id
assert model == meta.get_model_by_id(saved_model.id)
def create_model(self, model: Model) -> Model:
self._validate_model(model)
existing_task = self.get_task_by_id(model.task_id)
if existing_task is None:
raise NonExistingTaskError(model.task_id)
if self.get_model_by_name(model.name, existing_task) is not None:
raise ExistingModelError(model)
model._id = self.data.get_and_increment('next_model_id')
self.data.add_model(copy.deepcopy(model))
self.save()
return model
def create_model(self, model: Model) -> Model:
self._validate_model(model)
existing_task = self.get_task_by_id(model.task_id)
if existing_task is None:
raise NonExistingTaskError(model.task_id)
if self.get_model_by_name(model.name, existing_task) is not None:
raise ExistingModelError(model)
model._id = str(uuid.uuid4())
existing_task._models.add(model)
self.data.add_model(copy.deepcopy(model))
self.save()
return model
def test_save_model_is_reference(meta: MetadataRepository, project: Project,
task: Task, model: Model):
project = meta.create_project(project)
task.project = project
task = meta.create_task(task)
model.task_id = task.id
saved_model = meta.save_model(model)
saved_model.name = "KEK"
actual_model = meta.get_model_by_id(saved_model.id)
assert_objects_equal_except_fields(saved_model,
actual_model,
excepted_fields=['name'])
