def test_creation_and_hydration(self): name = random_str() description = random_str() rmd_1 = RegisteredModel(name, 1, 2, description, []) self._check(rmd_1, name, 1, 2, description, []) as_dict = { "name": name, "creation_timestamp": 1, "last_updated_timestamp": 2, "description": description, "latest_versions": [] } self.assertEqual(dict(rmd_1), as_dict) proto = rmd_1.to_proto() self.assertEqual(proto.name, name) self.assertEqual(proto.creation_timestamp, 1) self.assertEqual(proto.last_updated_timestamp, 2) self.assertEqual(proto.description, description) rmd_2 = RegisteredModel.from_proto(proto) self._check(rmd_2, name, 1, 2, description, []) rmd_3 = RegisteredModel.from_dictionary(as_dict) self._check(rmd_3, name, 1, 2, description, [])
def test_creation_and_hydration(self): name = random_str() registered_model = RegisteredModel(name) self._check(registered_model, name) as_dict = {"name": name} self.assertEqual(dict(registered_model), as_dict) proto = registered_model.to_proto() self.assertEqual(proto.name, name) registered_model2 = RegisteredModel.from_proto(proto) self._check(registered_model2, name) registered_model3 = RegisteredModel.from_dictionary(as_dict) self._check(registered_model3, name)
def test_creation_and_hydration(self): name = random_str() rm = RegisteredModel(name) t1, t2 = 100, 150 source = "path/to/source" run_id = uuid.uuid4().hex mvd = ModelVersionDetailed(rm, 5, t1, t2, "version five", "user 1", "Production", source, run_id, "READY", "Model version #5 is ready to use.") self._check(mvd, name, 5, t1, t2, "version five", "user 1", "Production", source, run_id, "READY", "Model version #5 is ready to use.") expected_dict = { "version": 5, "creation_timestamp": t1, "last_updated_timestamp": t2, "description": "version five", "user_id": "user 1", "current_stage": "Production", "source": source, "run_id": run_id, "status": "READY", "status_message": "Model version #5 is ready to use." } model_version_as_dict = dict(mvd) self.assertIsInstance(model_version_as_dict["registered_model"], RegisteredModel) self.assertEqual(model_version_as_dict["registered_model"].name, name) model_version_as_dict.pop("registered_model") self.assertEqual(model_version_as_dict, expected_dict) proto = mvd.to_proto() self.assertEqual(proto.model_version.registered_model.name, name) self.assertEqual(proto.model_version.version, 5) self.assertEqual(proto.status, ModelVersionStatus.from_string("READY")) self.assertEqual(proto.status_message, "Model version #5 is ready to use.") mvd_2 = ModelVersionDetailed.from_proto(proto) self._check(mvd_2, name, 5, t1, t2, "version five", "user 1", "Production", source, run_id, "READY", "Model version #5 is ready to use.") expected_dict.update({"registered_model": RegisteredModel(name)}) mvd_3 = ModelVersionDetailed.from_dictionary(expected_dict) self._check(mvd_3, name, 5, t1, t2, "version five", "user 1", "Production", source, run_id, "READY", "Model version #5 is ready to use.")
def test_string_repr(self): rmd = RegisteredModel(name="myname", creation_timestamp=1000, last_updated_timestamp=2002, description="something about a model", latest_versions=["1", "2", "3"]) assert str(rmd) == "<RegisteredModel: creation_timestamp=1000, " \ "description='something about a model', last_updated_timestamp=2002, " \ "latest_versions=['1', '2', '3'], name='myname'>"
def test_with_latest_model_versions(self): name = random_str() mvd_1 = ModelVersion( name, "1", 1000, 2000, "version 1", "user 1", "Production", "source 1", "run ID 1", "PENDING_REGISTRATION", "Model version is in production!", ) mvd_2 = ModelVersion( name, "4", 1300, 2002, "version 4", "user 2", "Staging", "source 4", "run ID 12", "READY", "Model copied over!", ) as_dict = { "name": name, "creation_timestamp": 1, "last_updated_timestamp": 4000, "description": random_str(), "latest_versions": [mvd_1, mvd_2], "tags": [], } rmd_1 = RegisteredModel.from_dictionary(as_dict) as_dict["tags"] = {} self.assertEqual(dict(rmd_1), as_dict) proto = rmd_1.to_proto() self.assertEqual(proto.creation_timestamp, 1) self.assertEqual(proto.last_updated_timestamp, 4000) self.assertEqual(set([mvd.version for mvd in proto.latest_versions]), set(["1", "4"])) self.assertEqual(set([mvd.name for mvd in proto.latest_versions]), set([name])) self.assertEqual( set([mvd.current_stage for mvd in proto.latest_versions]), set(["Production", "Staging"]), ) self.assertEqual( set([mvd.last_updated_timestamp for mvd in proto.latest_versions]), set([2000, 2002]) ) self.assertEqual( set([mvd.creation_timestamp for mvd in proto.latest_versions]), set([1300, 1000]) )
def test_with_latest_model_versions(self): name = random_str() mvd_1 = ModelVersionDetailed(RegisteredModel(name), 1, 1000, 2000, "version 1", "user 1", "Production", "source 1", "run ID 1", "FAILED_DELETION", "Model version is in production!") mvd_2 = ModelVersionDetailed(RegisteredModel(name), 4, 1300, 2002, "version 4", "user 2", "Staging", "source 4", "run ID 12", "READY", "Model copied over!") as_dict = { "name": name, "creation_timestamp": 1, "last_updated_timestamp": 4000, "description": random_str(), "latest_versions": [mvd_1, mvd_2] } rmd_1 = RegisteredModelDetailed.from_dictionary(as_dict) self.assertEqual(dict(rmd_1), as_dict) proto = rmd_1.to_proto() self.assertEqual(proto.creation_timestamp, 1) self.assertEqual(proto.last_updated_timestamp, 4000) self.assertEqual( set([mvd.model_version.version for mvd in proto.latest_versions]), set([1, 4])) self.assertEqual( set([ mvd.model_version.registered_model.name for mvd in proto.latest_versions ]), set([ name, ])) self.assertEqual( set([mvd.current_stage for mvd in proto.latest_versions]), set(["Production", "Staging"])) self.assertEqual( set([mvd.last_updated_timestamp for mvd in proto.latest_versions]), set([2000, 2002])) self.assertEqual( set([mvd.creation_timestamp for mvd in proto.latest_versions]), set([1300, 1000]))
def test_creation_and_hydration(self): name = random_str() t1, t2 = 100, 150 source = "path/to/source" run_id = uuid.uuid4().hex run_link = "http://localhost:5000/path/to/run" tags = [ModelVersionTag("key", "value"), ModelVersionTag("randomKey", "not a random value")] mvd = ModelVersion(name, "5", t1, t2, "version five", "user 1", "Production", source, run_id, "READY", "Model version #5 is ready to use.", tags, run_link) self._check(mvd, name, "5", t1, t2, "version five", "user 1", "Production", source, run_id, "READY", "Model version #5 is ready to use.", {tag.key: tag.value for tag in (tags or [])}) expected_dict = { "name": name, "version": "5", "creation_timestamp": t1, "last_updated_timestamp": t2, "description": "version five", "user_id": "user 1", "current_stage": "Production", "source": source, "run_id": run_id, "run_link": run_link, "status": "READY", "status_message": "Model version #5 is ready to use.", "tags": {tag.key: tag.value for tag in (tags or [])}} model_version_as_dict = dict(mvd) self.assertEqual(model_version_as_dict, expected_dict) proto = mvd.to_proto() self.assertEqual(proto.name, name) self.assertEqual(proto.version, "5") self.assertEqual(proto.status, ModelVersionStatus.from_string("READY")) self.assertEqual(proto.status_message, "Model version #5 is ready to use.") self.assertEqual(set([tag.key for tag in proto.tags]), set(["key", "randomKey"])) self.assertEqual(set([tag.value for tag in proto.tags]), set(["value", "not a random value"])) mvd_2 = ModelVersion.from_proto(proto) self._check(mvd_2, name, "5", t1, t2, "version five", "user 1", "Production", source, run_id, "READY", "Model version #5 is ready to use.", {tag.key: tag.value for tag in (tags or [])}) expected_dict.update({"registered_model": RegisteredModel(name)}) expected_dict["tags"] = tags mvd_3 = ModelVersion.from_dictionary(expected_dict) self._check(mvd_3, name, "5", t1, t2, "version five", "user 1", "Production", source, run_id, "READY", "Model version #5 is ready to use.", {tag.key: tag.value for tag in (tags or [])})
def test_creation_and_hydration(self): name = random_str() rm = RegisteredModel(name) model_version = ModelVersion(rm, 100) self._check(model_version, name, 100) expected_dict = {"version": 100} model_version_as_dict = dict(model_version) self.assertEqual(model_version_as_dict["version"], 100) self.assertIsInstance(model_version_as_dict["registered_model"], RegisteredModel) self.assertEqual(model_version_as_dict["registered_model"].name, name) model_version_as_dict.pop("registered_model") self.assertEqual(model_version_as_dict, expected_dict) proto = model_version.to_proto() self.assertEqual(proto.registered_model.name, name) self.assertEqual(proto.version, 100) model_version_2 = ModelVersion.from_proto(proto) self._check(model_version_2, name, 100) expected_dict.update({"registered_model": RegisteredModel(name)}) model_version_3 = ModelVersion.from_dictionary(expected_dict) self._check(model_version_3, name, 100)
def test_string_repr(self): model_version = ModelVersionDetailed( RegisteredModel(name="myname"), version=43, creation_timestamp=12, last_updated_timestamp=100, description="This is a test model.", user_id="user one", current_stage="Archived", source="path/to/a/notebook", run_id="some run", status="PENDING_REGISTRATION", status_message="Copying!") assert str(model_version) == "<ModelVersionDetailed: creation_timestamp=12, " \ "current_stage='Archived', description='This is a test " \ "model.', last_updated_timestamp=100, " \ "registered_model=<RegisteredModel: name='myname'>, " \ "run_id='some run', source='path/to/a/notebook', " \ "status='PENDING_REGISTRATION', status_message='Copying!', " \ "user_id='user one', version=43>"
def test_with_tags(self): name = random_str() tag1 = RegisteredModelTag("key", "value") tag2 = RegisteredModelTag("randomKey", "not a random value") tags = [tag1, tag2] as_dict = { "name": name, "creation_timestamp": 1, "last_updated_timestamp": 4000, "description": random_str(), "latest_versions": [], "tags": tags } rmd_1 = RegisteredModel.from_dictionary(as_dict) as_dict["tags"] = {tag.key: tag.value for tag in (tags or [])} self.assertEqual(dict(rmd_1), as_dict) proto = rmd_1.to_proto() self.assertEqual(proto.creation_timestamp, 1) self.assertEqual(proto.last_updated_timestamp, 4000) self.assertEqual(set([tag.key for tag in proto.tags]), set(["key", "randomKey"])) self.assertEqual(set([tag.value for tag in proto.tags]), set(["value", "not a random value"]))
def _properties(cls): # aggregate with base class properties since cls.__dict__ does not do it automatically return sorted(cls._get_properties_helper() + RegisteredModel._properties())
def test_string_repr(self): model_version = ModelVersion(RegisteredModel(name="myname"), version=4) assert str(model_version) == "<ModelVersion: registered_model=<RegisteredModel: " \ "name='myname'>, version=4>"
def test_string_repr(self): registered_model = RegisteredModel(name="myname") assert str(registered_model) == "<RegisteredModel: name='myname'>"