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'])