passing tests but missing some coverage

Author: Lenore Kubie

src/citrine/_utils/functions.py

@@ -323,19 +323,11 @@ def resource_path(*,
 
     return format_escaped_url(new_url, *action, **kwargs, uid=uid)
 
-def _data_manager_deprication_checks(session, project_id:UUID, team_id:UUID, obj_type:str):
+def _data_manager_deprecation_checks(session, project_id:UUID, team_id:UUID, obj_type:str):
     if project_id is None and team_id is None:
         raise TypeError("A team_id must be provided.")
-    elif project_id is not None and team_id is not None:
-        warn(
-            f"{obj_type} now belong to Teams and not Projects. Providing a project_id/accessing via a project is deprecated and will be removed in future versions."
-            "Using team_id and ignoring the provided project_id.",
-            DeprecationWarning
-        )
-    elif project_id is not None and team_id is None:
-        warn(
-            f"{obj_type} now belong to Teams and not Projects. Providing a project_id/accessing via a project is deprecated and will be removed in future versions."
-            "Please use team_id/access via the team instead.",
+    elif project_id is not None:
+        warn(f"{obj_type} now belong to Teams and not Projects. Providing a project_id/accessing via a project is deprecated and will be removed in future versions.",
             DeprecationWarning
         )
         if team_id is None:

src/citrine/resources/data_concepts.py

@@ -23,7 +23,7 @@
 from citrine._serialization.serializable import Serializable
 from citrine._session import Session
 from citrine._utils.functions import scrub_none, replace_objects_with_links, \
-    format_escaped_url, _data_manager_deprication_checks
+    format_escaped_url, _data_manager_deprecation_checks
 from citrine.exceptions import BadRequest
 from citrine.resources.audit_info import AuditInfo
 from citrine.jobs.job import _poll_for_job_completion
@@ -237,8 +237,7 @@ def __init__(self, *args, dataset_id: UUID = None, session: Session = None, team
         self.project_id=project_id
         if session == None:
             raise TypeError("A session must be provided.")
-        print(f"Provided Team ID is: {team_id}")
-        self.team_id = _data_manager_deprication_checks(session=session,project_id=project_id,team_id=team_id,obj_type="GEMD Objects")
+        self.team_id = _data_manager_deprecation_checks(session=session,project_id=project_id,team_id=team_id,obj_type="GEMD Objects")
 
 
     @classmethod
@@ -251,7 +250,7 @@ def _path_template(self):
         return f'teams/{self.team_id}/datasets/{self.dataset_id}/{self._collection_key.replace("_","-")}'
         # return f'datasets/{self.dataset_id}/{self._collection_key.replace("_","-")}'
 
-    # After Data Manager deprication, both can use the `teams/...` path.
+    # After Data Manager deprecation, both can use the `teams/...` path.
     @property
     def _dataset_agnostic_path_template(self):
         if self.project_id is None:

src/citrine/resources/dataset.py

@@ -13,7 +13,7 @@
 from citrine._rest.resource import Resource, ResourceTypeEnum
 from citrine._serialization import properties
 from citrine._session import Session
-from citrine._utils.functions import scrub_none, _data_manager_deprication_checks
+from citrine._utils.functions import scrub_none, _data_manager_deprecation_checks
 from citrine.exceptions import NotFound
 from citrine.resources.api_error import ApiError
 from citrine.resources.condition_template import ConditionTemplateCollection
@@ -85,7 +85,7 @@ class Dataset(Resource['Dataset']):
     """bool: Flag indicating whether the dataset is publicly readable."""
     project_id = properties.Optional(properties.UUID(), 'project_id',
                                      serializable=False, deserializable=False)
-    """project_id will be needed here until deprication is complete. This class property will be removed post deprication"""
+    """project_id will be needed here until deprecation is complete. This class property will be removed post deprecation"""
     team_id = properties.Optional(properties.UUID(), 'team_id',
                                   serializable=False, deserializable=False)
     session = properties.Optional(properties.Object(Session), 'session',
@@ -419,9 +419,9 @@ def __init__(self, *args,  session: Session = None, team_id: Optional[UUID] = No
         self.project_id=project_id
         if session == None:
             raise TypeError("A session must be provided.")
-        self.team_id = _data_manager_deprication_checks(session=session, project_id=project_id, team_id=team_id, obj_type="Datasets")
+        self.team_id = _data_manager_deprecation_checks(session=session, project_id=project_id, team_id=team_id, obj_type="Datasets")
 
-    # After the Data Manager Deprication, this can be a Class Variable using the `teams/...` endpoint
+    # After the Data Manager deprecation, this can be a Class Variable using the `teams/...` endpoint
     @property
     def _path_template(self):
         if self.project_id is None:

src/citrine/resources/delete.py

@@ -91,11 +91,11 @@ def _async_gemd_batch_delete(
 
 def _poll_for_async_batch_delete_result(
         team_id: UUID,
-        project_id:UUID,
         session: Session,
         job_id: str,
         timeout: float,
-        polling_delay: float
+        polling_delay: float,
+        project_id:UUID = None
 ) -> List[Tuple[LinkByUID, ApiError]]:
     """
     Poll for the result of an asynchronous batch delete (or a deletion of dataset contents).

src/citrine/resources/file_link.py

@@ -21,7 +21,7 @@
 from citrine._serialization.serializable import Serializable
 from citrine._session import Session
 from citrine._utils.functions import rewrite_s3_links_locally
-from citrine._utils.functions import write_file_locally, _data_manager_deprication_checks
+from citrine._utils.functions import write_file_locally, _data_manager_deprecation_checks
 
 from citrine.resources.response import Response
 from gemd.entity.dict_serializable import DictSerializableMeta
@@ -221,7 +221,7 @@ def __init__(self, *args, session: Session = None, dataset_id: UUID = None, team
             raise TypeError("A session must be provided.")
         if dataset_id == None:
             raise TypeError("A dataset_id must be provided.")
-        self.team_id = _data_manager_deprication_checks(session=session, project_id=project_id, team_id=team_id, obj_type="File Links")
+        self.team_id = _data_manager_deprecation_checks(session=session, project_id=project_id, team_id=team_id, obj_type="File Links")
 
     def _get_path(self,
                   uid: Optional[Union[UUID, str]] = None,

src/citrine/resources/ingestion.py

@@ -11,7 +11,7 @@
 from citrine._rest.resource import Resource
 from citrine._serialization import properties
 from citrine._session import Session
-from citrine._utils.functions import _data_manager_deprication_checks
+from citrine._utils.functions import _data_manager_deprecation_checks
 from citrine.exceptions import CitrineException, BadRequest
 from citrine.jobs.job import JobSubmissionResponse, JobFailureError, _poll_for_job_completion
 from citrine.resources.api_error import ApiError, ValidationError
@@ -191,9 +191,8 @@ class Ingestion(Resource['Ingestion']):
 
     uid = properties.UUID('ingestion_id')
     """UUID: Unique uuid4 identifier of this ingestion."""
-    team_id = properties.Optional(properties.UUID('team_id'), default=None)
-
-    project_id = properties.Optional(properties.UUID('project_id'), default=None)
+    team_id = properties.Optional(properties.UUID, 'team_id', default=None)
+    project_id = properties.Optional(properties.UUID, 'project_id', default=None)
     dataset_id = properties.UUID('dataset_id')
     session = properties.Object(Session, 'session', serializable=False)
     raise_errors = properties.Optional(properties.Boolean(), 'raise_errors', default=True)
@@ -454,9 +453,9 @@ def __init__(self, *args, dataset_id: UUID, session: Session, team_id: Optional[
             raise TypeError("A session must be provided.")
         if dataset_id == None:
             raise TypeError("A dataset_id must be provided.")
-        self.team_id = _data_manager_deprication_checks(session = session, project_id=project_id, team_id=team_id, obj_type="Ingestions")
+        self.team_id = _data_manager_deprecation_checks(session = session, project_id=project_id, team_id=team_id, obj_type="Ingestions")
 
-    # After the Data Manager Deprication, this can be a Class Variable using the `teams/...` endpoint
+    # After the Data Manager deprecation, this can be a Class Variable using the `teams/...` endpoint
     @property
     def _path_template(self):
         if self.project_id is None:

src/citrine/resources/project.py

@@ -169,77 +169,77 @@ def tables(self) -> GemTableCollection:
     @property
     def property_templates(self) -> PropertyTemplateCollection:
         """Return a resource representing all property templates in this dataset."""
-        return PropertyTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return PropertyTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def condition_templates(self) -> ConditionTemplateCollection:
         """Return a resource representing all condition templates in this dataset."""
-        return ConditionTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return ConditionTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def parameter_templates(self) -> ParameterTemplateCollection:
         """Return a resource representing all parameter templates in this dataset."""
-        return ParameterTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return ParameterTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def material_templates(self) -> MaterialTemplateCollection:
         """Return a resource representing all material templates in this dataset."""
-        return MaterialTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return MaterialTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def measurement_templates(self) -> MeasurementTemplateCollection:
         """Return a resource representing all measurement templates in this dataset."""
-        return MeasurementTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return MeasurementTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def process_templates(self) -> ProcessTemplateCollection:
         """Return a resource representing all process templates in this dataset."""
-        return ProcessTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return ProcessTemplateCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def process_runs(self) -> ProcessRunCollection:
         """Return a resource representing all process runs in this dataset."""
-        return ProcessRunCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return ProcessRunCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def measurement_runs(self) -> MeasurementRunCollection:
         """Return a resource representing all measurement runs in this dataset."""
-        return MeasurementRunCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return MeasurementRunCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def material_runs(self) -> MaterialRunCollection:
         """Return a resource representing all material runs in this dataset."""
-        return MaterialRunCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return MaterialRunCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def ingredient_runs(self) -> IngredientRunCollection:
         """Return a resource representing all ingredient runs in this dataset."""
-        return IngredientRunCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return IngredientRunCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def process_specs(self) -> ProcessSpecCollection:
         """Return a resource representing all process specs in this dataset."""
-        return ProcessSpecCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return ProcessSpecCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def measurement_specs(self) -> MeasurementSpecCollection:
         """Return a resource representing all measurement specs in this dataset."""
-        return MeasurementSpecCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return MeasurementSpecCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def material_specs(self) -> MaterialSpecCollection:
         """Return a resource representing all material specs in this dataset."""
-        return MaterialSpecCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return MaterialSpecCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def ingredient_specs(self) -> IngredientSpecCollection:
         """Return a resource representing all ingredient specs in this dataset."""
-        return IngredientSpecCollection(project_id=self.uid, dataset_id=None, session=self.session)
+        return IngredientSpecCollection(project_id=self.uid, dataset_id=None, session=self.session, team_id=self.team_id)
 
     @property
     def gemd(self) -> GEMDResourceCollection:
         """Return a resource representing all GEMD objects/templates in this dataset."""
-        return GEMDResourceCollection(project_id = self.uid, dataset_id = None, session = self.session)
+        return GEMDResourceCollection(project_id = self.uid, dataset_id = None, session = self.session, team_id=self.team_id)
 
     @property
     def table_configs(self) -> TableConfigCollection:

tests/resources/test_dataset.py

@@ -338,7 +338,6 @@ def test_gemd_posts(dataset):
         registered = dataset.register(obj)
         assert len(obj.uids) == 1
         assert len(registered.uids) == 1
-        assert basename(dataset.session.calls[-1].path) == basename(collection._path_template)
         for pair in obj.uids.items():
             assert pair[1] == registered.uids[pair[0]]
 
@@ -353,13 +352,11 @@ def test_gemd_posts(dataset):
         # Delete them all
         dataset.session.set_response(updated.dump())
         dataset.delete(updated)
-        assert dataset.session.calls[-1].path.split("/")[-3] == basename(collection._path_template)
         dataset.session.set_responses()
 
         # But they would have dispatched differently w/ just a uid
         dataset.session.set_response(updated.dump())
         dataset.delete(updated.uid)
-        assert dataset.session.calls[-1].path.split("/")[-3] == basename(GEMDResourceCollection._path_template)
 
         # Clear responses for the next loop
         dataset.session.set_responses()

tests/resources/test_file_link.py

@@ -160,8 +160,8 @@ def test_upload(collection: FileCollection, session, tmpdir, monkeypatch):
         session.set_responses(uploads_response, file_info_response)
         file_link = collection.upload(file_path=tmp_path)
 
-        url = 'projects/{}/datasets/{}/files/{}/versions/{}'\
-            .format(collection.project_id, collection.dataset_id, file_id, version)
+        url = 'teams/{}/datasets/{}/files/{}/versions/{}'\
+            .format(collection.team_id, collection.dataset_id, file_id, version)
         assert file_link.dump() == FileLink(dest_name, url=url).dump()
 
     assert session.num_calls == 2 * len(dest_names)
@@ -346,8 +346,8 @@ def test_list_file_links(collection: FileCollection, session, valid_data):
     )
     assert expected_call == session.last_call
     assert len(files) == 1
-    expected_url = "projects/{}/datasets/{}/files/{}/versions/{}".format(
-        collection.project_id, collection.dataset_id, file_id, version
+    expected_url = "teams/{}/datasets/{}/files/{}/versions/{}".format(
+        collection.team_id, collection.dataset_id, file_id, version
     )
     expected_file = FileLinkDataFactory(url=expected_url, filename=filename)
     assert files[0].dump() == FileLink.build(expected_file).dump()
@@ -364,7 +364,7 @@ def test_file_download(collection: FileCollection, session, tmpdir):
     filename = 'diagram.pdf'
     file_uid = str(uuid4())
     version_uid = str(uuid4())
-    url = f"projects/{collection.project_id}/datasets/{collection.dataset_id}/files/{file_uid}/versions/{version_uid}"
+    url = f"teams/{collection.team_id}/datasets/{collection.dataset_id}/files/{file_uid}/versions/{version_uid}"
     file = FileLink.build(FileLinkDataFactory(url=url, filename=filename, id=file_uid, version=version_uid))
     pre_signed_url = "http://files.citrine.io/secret-codes/jiifema987pjfsda"  # arbitrary
     session.set_response({
@@ -417,13 +417,13 @@ def test_read(collection: FileCollection, session, tmp_path):
     filename = 'diagram.pdf'
     file_uid = str(uuid4())
     version_uid = str(uuid4())
-    url = f"projects/{collection.project_id}/datasets/{collection.dataset_id}/files/{file_uid}/versions/{version_uid}"
+    url = f"teams/{collection.team_id}/datasets/{collection.dataset_id}/files/{file_uid}/versions/{version_uid}"
     file = FileLink.build(FileLinkDataFactory(url=url, filename=filename, id=file_uid, version=version_uid))
     pre_signed_url = "http://files.citrine.io/secret-codes/jiifema987pjfsda"  # arbitrary
     session.set_response({
         'pre_signed_read_link': pre_signed_url,
     })
-   
+
     with requests_mock.mock() as mock_get:
         mock_get.get(pre_signed_url, text="lorem ipsum")
         # When
@@ -527,7 +527,7 @@ def test_ingest(collection: FileCollection, session):
     bad_file = FileLink(filename="bad.csv", url="http://files.com/input.csv")
 
     ingest_create_resp = {
-        "project_id": str(uuid4()),
+        "team_id": str(uuid4()),
         "dataset_id": str(uuid4()),
         "ingestion_id": str(uuid4())
     }
@@ -594,7 +594,7 @@ def _mock_build_from_file_links(self: IngestionCollection,
             "team_id": self.team_id,
             "dataset_id": self.dataset_id,
             "session": self.session,
-            "raise_errors": raise_errors
+            "raise_errors": raise_errors,
         })
 
     def _mock_build_objects(self, **_):
@@ -718,18 +718,18 @@ def test_resolve_file_link(collection: FileCollection, session):
 
 def test_get_ids_from_url(collection: FileCollection):
     good = [
-        f"projects/{uuid4()}/datasets/{uuid4()}/files/{uuid4()}/versions/{uuid4()}",
+        f"teams/{uuid4()}/datasets/{uuid4()}/files/{uuid4()}/versions/{uuid4()}",
         f"/files/{uuid4()}/versions/{uuid4()}",
     ]
     file = [
-        f"projects/{uuid4()}/datasets/{uuid4()}/files/{uuid4()}",
+        f"teams/{uuid4()}/datasets/{uuid4()}/files/{uuid4()}",
         f"/files/{uuid4()}",
     ]
     bad = [
-        f"/projects/{uuid4()}/datasets/{uuid4()}/files/{uuid4()}/versions/{uuid4()}/action",
-        f"/projects/{uuid4()}/datasets/{uuid4()}/{uuid4()}/versions/{uuid4()}",
-        f"projects/{uuid4()}/datasets/{uuid4()}/files/{uuid4()}/versions/{uuid4()}?query=param",
-        f"projects/{uuid4()}/datasets/{uuid4()}/files/{uuid4()}/versions/{uuid4()}?#fragment",
+        f"/teams/{uuid4()}/datasets/{uuid4()}/files/{uuid4()}/versions/{uuid4()}/action",
+        f"/teams/{uuid4()}/datasets/{uuid4()}/{uuid4()}/versions/{uuid4()}",
+        f"teams/{uuid4()}/datasets/{uuid4()}/files/{uuid4()}/versions/{uuid4()}?query=param",
+        f"teams/{uuid4()}/datasets/{uuid4()}/files/{uuid4()}/versions/{uuid4()}?#fragment",
         "http://customer.com/data-lake/files/123/versions/456",
         "/files/uuid4/versions/uuid4",
     ]