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_delete_image__not_only_meta_ok(ebnt: Ebonite, image_to_delete: Image,
mock_env_params):
assert ebnt.meta_repo.get_image_by_id(image_to_delete.id) is not None
assert image_to_delete.builder == mock_env_params.builder
with mock_env_params.builder.delete_image.called_within_context(times=1):
ebnt.delete_image(image_to_delete, False)
assert ebnt.meta_repo.get_image_by_id(image_to_delete.id) is None
def test_delete_task_ok(ebnt: Ebonite):
task = ebnt.get_or_create_task('Project', 'Task')
assert ebnt.meta_repo.get_task_by_id(task.id) is not None
ebnt.delete_task(task)
assert ebnt.meta_repo.get_task_by_id(task.id) is None
def test_get_model(ebnt: Ebonite):
task = ebnt.get_or_create_task("Project", "Task")
reg, data = train_model()
model = task.create_and_push_model(reg, data, 'mymodel')
assert ebnt.get_model(project='Project', task='Task',
model_name='mymodel') == model
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 test_delete_project__ok(ebnt: Ebonite):
project = ebnt.meta_repo.get_or_create_project('Project')
assert ebnt.meta_repo.get_or_create_project('Project') is not None
ebnt.delete_project(project)
assert ebnt.meta_repo.get_project_by_name('Project') is None
def test_push_model_with_same_name(ebnt: Ebonite, model: Model):
task = ebnt.get_or_create_task("Project", "Task1")
ebnt.push_model(model, task)
model2 = copy.deepcopy(model)
with pytest.raises(ExistingModelError):
ebnt.push_model(model2, task)
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 delete_pipeline_ok(ebnt: Ebonite, task_b: Task, pipeline: Pipeline):
task_b.add_pipeline(pipeline)
assert ebnt.meta_repo.get_task_by_id(task_b.id) is not None
assert ebnt.meta_repo.get_pipeline_by_id(pipeline.id) is not None
ebnt.delete_pipeline(pipeline)
assert ebnt.meta_repo.get_pipeline_by_id(pipeline.id) is None
def test_delete_project_cascade_project_with_tasks(ebnt: Ebonite):
ebnt.get_or_create_task('Project', 'Task')
project = ebnt.meta_repo.get_project_by_name('Project')
assert ebnt.meta_repo.get_project_by_id(project.id) is not None
with pytest.raises(ProjectWithTasksError):
ebnt.delete_project(project)
def test_delete_task_with_models(ebnt: Ebonite, model: Model):
task = ebnt.get_or_create_task('Project', 'Task')
model = ebnt.push_model(model, task)
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
with pytest.raises(TaskWithFKError):
ebnt.delete_task(task)
def test_push_model_project_contains_two_tasks(ebnt: Ebonite, model: Model):
task1 = ebnt.get_or_create_task("Project", "Task1")
ebnt.get_or_create_task("Project", "Task2")
pushed_model = ebnt.push_model(model, task1)
task = ebnt.meta_repo.get_task_by_id(pushed_model.task_id)
project = ebnt.meta_repo.get_project_by_id(task.project_id)
task1 = ebnt.get_or_create_task("Project", "Task1")
assert project.tasks.get(task.id) == task1
def test_delete_image__only_meta_ok(ebnt: Ebonite, image_to_delete: Image,
instance: RuntimeInstance,
mock_env_params):
assert ebnt.meta_repo.get_image_by_id(image_to_delete.id) is not None
instance.image = image_to_delete
instance.environment = image_to_delete.environment
ebnt.meta_repo.save_instance(instance)
with mock_env_params.builder.delete_image.called_within_context(times=0):
ebnt.delete_image(image_to_delete, True, True)
assert ebnt.meta_repo.get_image_by_id(image_to_delete.id) is None
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_delete_project_cascade__ok(ebnt: Ebonite):
task = ebnt.get_or_create_task('Project', 'Task')
project = ebnt.meta_repo.get_project_by_name('Project')
assert ebnt.meta_repo.get_task_by_id(task.id) is not None
assert ebnt.meta_repo.get_project_by_id(project.id) is not None
ebnt.delete_project(project, cascade=True)
assert ebnt.meta_repo.get_project_by_name('Project') is None
assert ebnt.meta_repo.get_task_by_id(task.id) is None
def test_push_model_exists(ebnt: Ebonite, model: Model):
task = ebnt.get_or_create_task("Project", "Task1")
pushed_model = ebnt.push_model(model, task)
assert pushed_model.id is not None
pushed_model.name = "Model2"
pushed_model._id = None
pushed_model2 = ebnt.push_model(pushed_model)
assert "Model2" == pushed_model2.name
def test_get_model(ebnt: Ebonite, regression_and_data):
task = ebnt.get_or_create_task("Project", "Task")
reg, data = regression_and_data
model = task.create_and_push_model(reg, data, 'mymodel')
get_model = ebnt.get_model(project='Project',
task='Task',
model_name='mymodel')
assert get_model == model
assert get_model.has_meta_repo
assert get_model.has_artifact_repo
def delete_image_ok(ebnt: Ebonite, model: Model):
task = ebnt.get_or_create_task('Project', 'Task')
model = ebnt.push_model(model, task)
image = Image(task_id=task.id, name='Image', source=BuildableMock())
image = ebnt.meta_repo.create_image(image)
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
assert ebnt.meta_repo.get_image_by_id(image.id) is not None
ebnt.delete_image(image)
assert ebnt.meta_repo.get_image_by_id(image.id) is None
def test_get_or_create_task(ebnt: Ebonite):
task = ebnt.get_or_create_task("Project", "Task")
project = ebnt.meta_repo.get_project_by_name('Project')
assert task.name == "Task"
assert task.project.name == "Project"
assert task.id in project.tasks
assert task.has_meta_repo
assert task.has_artifact_repo
def remote_ebnt(tmpdir, postgres_server, postgres_meta, s3server, s3_artifact): # noqa
with use_local_installation():
# we reconstruct all objects here to ensure that config-related code is covered by tests
ebnt = Ebonite.custom_client(
metadata="sqlalchemy", meta_kwargs={
"db_uri": postgres_meta.db_uri
},
artifact="s3", artifact_kwargs={
"bucket_name": s3_artifact.bucket_name,
"endpoint": s3_artifact.endpoint,
"region": s3_artifact.region
})
cfg_path = os.path.join(tmpdir, 'config.json')
ebnt.save_client_config(cfg_path)
yield Ebonite.from_config_file(cfg_path)
def test_delete_task_cascade_ok(ebnt: Ebonite, model: Model, mock_env,
image: Image, pipeline: Pipeline):
task = ebnt.get_or_create_task('Project', 'Task')
model = ebnt.push_model(model, task)
image.environment = ebnt.meta_repo.create_environment(mock_env)
task.add_pipeline(pipeline)
task.add_image(image)
task = ebnt.meta_repo.get_task_by_id(task.id).bind_as(task)
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
assert ebnt.meta_repo.get_pipeline_by_id(pipeline.id) is not None
assert ebnt.meta_repo.get_image_by_id(image.id) is not None
ebnt.delete_task(task, cascade=True)
assert ebnt.meta_repo.get_task_by_id(task.id) is None
assert ebnt.meta_repo.get_model_by_id(model.id) is None
assert ebnt.meta_repo.get_pipeline_by_id(pipeline.id) is None
assert ebnt.meta_repo.get_image_by_id(image.id) is None
def push_model(self, model: 'Model') -> 'Model':
"""
Push :class:`Model` instance to task repository
:param model: :class:`Model` to push
:return: same pushed :class:`Model`
"""
from ebonite.client import Ebonite
model = Ebonite(self._meta, self._art).push_model(model, self)
self._models.add(model)
return model
def delete_model(self, model: 'Model', force=False):
"""
Remove model from this task and delete it from meta repo
:param model: model to delete
:param force: whether model artifacts' deletion errors should be ignored, default is false
"""
model_id = model.id
if model_id not in self._models:
raise errors.NonExistingModelError(model)
from ebonite.client import Ebonite
Ebonite(self._meta, self._art).delete_model(model, force)
del self._models[model_id]
def test_build_and_run_instance(ebnt: Ebonite, regression_and_data,
container_name):
reg, data = regression_and_data
check_ebonite_port_free()
model = ebnt.create_model('test model', reg, data)
instance = ebnt.build_and_run_instance(container_name, model)
time.sleep(.1)
assert ebnt.get_environment(
instance.environment.name) == instance.environment
assert ebnt.get_image(instance.image.name,
instance.image.model) == instance.image
assert ebnt.get_instance(instance.name, instance.image,
instance.environment) == instance
assert instance.is_running()
ebnt.stop_instance(instance)
time.sleep(.1)
assert not instance.is_running()
def test_push_model_task_argument(ebnt: Ebonite, model: Model):
task = ebnt.get_or_create_task("Project", "Task1")
pushed_model = ebnt.push_model(model, task)
assert model.name == pushed_model.name
assert task.id == pushed_model.task_id
def test_create_model(ebnt: Ebonite, regression_and_data):
reg, data = regression_and_data
model = ebnt.create_model(reg, data, 'sklearn_model')
assert isinstance(model, Model)
assert ebnt.get_model(model.name, model.task) == model
def test_get_or_create_task_exists(ebnt: Ebonite):
task = ebnt.get_or_create_task("Project", "Task")
task2 = ebnt.get_or_create_task("Project", "Task")
assert task == task2
def test_get_or_create_task(ebnt: Ebonite):
task = ebnt.get_or_create_task("Project", "Task")
project = ebnt.meta_repo.get_project_by_id(task.project_id) # FIXME
assert task.name == "Task"
assert project.name == "Project"
def ebnt(tmpdir):
with use_local_installation():
yield Ebonite.local(str(tmpdir))
def test_build_and_run_instance(ebnt: Ebonite, regression_and_data,
container_name, mock_env):
reg, data = regression_and_data
mock_env = ebnt.meta_repo.create_environment(mock_env)
check_ebonite_port_free()
model = ebnt.create_model(reg, data, 'test_model')
p = mock_env.params
with p.builder.build_image.called_within_context(
), p.runner.run.called_within_context():
instance = ebnt.build_and_run_instance(model,
container_name,
environment=mock_env)
assert ebnt.get_environment(
instance.environment.name) == instance.environment
assert ebnt.get_image(instance.image.name,
instance.image.task) == instance.image
assert ebnt.get_instance(instance.name, instance.image,
instance.environment) == instance
with pytest.raises(ImageWithInstancesError):
ebnt.delete_image(instance.image)
with pytest.raises(EnvironmentWithInstancesError):
ebnt.delete_environment(instance.environment)
with p.runner.stop.called_within_context(
), p.runner.remove_instance.called_within_context():
ebnt.delete_instance(instance)
