Resolve data manager deprecations.

* Drop positional arguments and project_id from data objects.
* Drop Ingestion.project_id.
* FileCollection.ingest requires a project ID when build_table=True.
* Ingestion.build_objects_async requires a project ID when build_table=True.
* Adding ingredients via TableConfig.add_all_ingredients and
TableConfig.add_all_ingredients_in_output requires a Team.
* Drop ProjectCollection methods for data objects, as well as
  publishing/unpublishing datasets, owned_dataset_ids, and gemd_batch_delete.

Author: anoto-moniz

src/citrine/_utils/functions.py

@@ -319,25 +319,3 @@ def resource_path(*,
     new_url = base._replace(path='/'.join(path), query=query).geturl()
 
     return format_escaped_url(new_url, *action, **kwargs, uid=uid)
-
-
-def _data_manager_deprecation_checks(session, project_id: UUID, team_id: UUID, obj_type: str):
-    if team_id is None:
-        if project_id is None:
-            raise TypeError("Missing one required argument: team_id.")
-
-        warn(f"{obj_type} now belong to Teams, so the project_id parameter was deprecated in "
-             "3.4.0, and will be removed in 4.0. Please provide the team_id instead.",
-             DeprecationWarning)
-        # avoiding a circular import
-        from citrine.resources.project import Project
-        team_id = Project.get_team_id_from_project_id(session=session, project_id=project_id)
-    return team_id
-
-
-def _pad_positional_args(args, n):
-    if len(args) > 0:
-        warn("Positional arguments are deprecated and will be removed in v4.0. Please use keyword "
-             "arguments instead.",
-             DeprecationWarning)
-    return args + (None, ) * (n - len(args))

src/citrine/resources/data_concepts.py

@@ -18,8 +18,7 @@
 from citrine._serialization.properties import UUID as PropertyUUID
 from citrine._serialization.serializable import Serializable
 from citrine._session import Session
-from citrine._utils.functions import _data_manager_deprecation_checks, format_escaped_url, \
-    _pad_positional_args, replace_objects_with_links, scrub_none
+from citrine._utils.functions import format_escaped_url, replace_objects_with_links, scrub_none
 from citrine.exceptions import BadRequest
 from citrine.jobs.job import _poll_for_job_completion
 from citrine.resources.audit_info import AuditInfo
@@ -214,43 +213,27 @@ class DataConceptsCollection(Collection[ResourceType], ABC):
 
     """
 
-    def __init__(self,
-                 *args,
-                 session: Session = None,
-                 dataset_id: Optional[UUID] = None,
-                 team_id: UUID = None,
-                 project_id: Optional[UUID] = None):
-        # Handle positional arguments for backward compatibility
-        args = _pad_positional_args(args, 3)
-        self.project_id = project_id or args[0]
-        self.dataset_id = dataset_id or args[1]
-        self.session = session or args[2]
-        if self.session is None:
-            raise TypeError("Missing one required argument: session.")
-
-        self.team_id = _data_manager_deprecation_checks(
-            session=self.session,
-            project_id=self.project_id,
-            team_id=team_id,
-            obj_type="GEMD Objects")
+    def __init__(self, *, session: Session, team_id: UUID, dataset_id: Optional[UUID] = None):
+        self.dataset_id = dataset_id
+        self.session = session
+        self.team_id = team_id
 
     @classmethod
     @abstractmethod
     def get_type(cls) -> Type[Serializable]:
         """Return the resource type in the collection."""
 
+    @property
+    def _path_collection_key(self):
+        return self._collection_key.replace("_", "-")
+
     @property
     def _path_template(self):
-        collection_key = self._collection_key.replace("_", "-")
-        return f'teams/{self.team_id}/datasets/{self.dataset_id}/{collection_key}'
+        return f'teams/{self.team_id}/datasets/{self.dataset_id}/{self._path_collection_key}'
 
-    # After Data Manager deprecation, both can use the `teams/...` path.
     @property
     def _dataset_agnostic_path_template(self):
-        if self.project_id is None:
-            return f'teams/{self.team_id}/{self._collection_key.replace("_", "-")}'
-        else:
-            return f'projects/{self.project_id}/{self._collection_key.replace("_", "-")}'
+        return f'teams/{self.team_id}/{self._path_collection_key}'
 
     def build(self, data: dict) -> ResourceType:
         """

src/citrine/resources/dataset.py

@@ -5,12 +5,12 @@
 from gemd.entity.base_entity import BaseEntity
 from gemd.entity.link_by_uid import LinkByUID
 
-from citrine._utils.functions import format_escaped_url, _pad_positional_args
+from citrine._utils.functions import format_escaped_url
 from citrine._rest.collection import Collection
 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_deprecation_checks
+from citrine._utils.functions import scrub_none
 from citrine.exceptions import NotFound
 from citrine.resources.api_error import ApiError
 from citrine.resources.condition_template import ConditionTemplateCollection
@@ -80,10 +80,6 @@ class Dataset(Resource['Dataset']):
     """int: Time the dataset was deleted, in seconds since epoch, if it is deleted."""
     public = properties.Optional(properties.Boolean(), 'public')
     """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 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',
@@ -107,7 +103,6 @@ def __init__(self, name: str, *, summary: Optional[str] = None,
         self.update_time = None
         self.delete_time = None
         self.public = None
-        self.project_id = None
         self.team_id = None
         self.session = None
 
@@ -118,103 +113,101 @@ def __str__(self):
     def property_templates(self) -> PropertyTemplateCollection:
         """Return a resource representing all property templates in this dataset."""
         return PropertyTemplateCollection(team_id=self.team_id, dataset_id=self.uid,
-                                          session=self.session, project_id=self.project_id)
+                                          session=self.session)
 
     @property
     def condition_templates(self) -> ConditionTemplateCollection:
         """Return a resource representing all condition templates in this dataset."""
         return ConditionTemplateCollection(team_id=self.team_id, dataset_id=self.uid,
-                                           session=self.session, project_id=self.project_id)
+                                           session=self.session)
 
     @property
     def parameter_templates(self) -> ParameterTemplateCollection:
         """Return a resource representing all parameter templates in this dataset."""
         return ParameterTemplateCollection(team_id=self.team_id, dataset_id=self.uid,
-                                           session=self.session, project_id=self.project_id)
+                                           session=self.session)
 
     @property
     def material_templates(self) -> MaterialTemplateCollection:
         """Return a resource representing all material templates in this dataset."""
         return MaterialTemplateCollection(team_id=self.team_id, dataset_id=self.uid,
-                                          session=self.session, project_id=self.project_id)
+                                          session=self.session)
 
     @property
     def measurement_templates(self) -> MeasurementTemplateCollection:
         """Return a resource representing all measurement templates in this dataset."""
         return MeasurementTemplateCollection(team_id=self.team_id, dataset_id=self.uid,
-                                             session=self.session, project_id=self.project_id)
+                                             session=self.session)
 
     @property
     def process_templates(self) -> ProcessTemplateCollection:
         """Return a resource representing all process templates in this dataset."""
         return ProcessTemplateCollection(team_id=self.team_id, dataset_id=self.uid,
-                                         session=self.session, project_id=self.project_id)
+                                         session=self.session)
 
     @property
     def process_runs(self) -> ProcessRunCollection:
         """Return a resource representing all process runs in this dataset."""
         return ProcessRunCollection(team_id=self.team_id, dataset_id=self.uid,
-                                    session=self.session, project_id=self.project_id)
+                                    session=self.session)
 
     @property
     def measurement_runs(self) -> MeasurementRunCollection:
         """Return a resource representing all measurement runs in this dataset."""
         return MeasurementRunCollection(team_id=self.team_id, dataset_id=self.uid,
-                                        session=self.session, project_id=self.project_id)
+                                        session=self.session)
 
     @property
     def material_runs(self) -> MaterialRunCollection:
         """Return a resource representing all material runs in this dataset."""
         return MaterialRunCollection(team_id=self.team_id, dataset_id=self.uid,
-                                     session=self.session, project_id=self.project_id)
+                                     session=self.session)
 
     @property
     def ingredient_runs(self) -> IngredientRunCollection:
         """Return a resource representing all ingredient runs in this dataset."""
         return IngredientRunCollection(team_id=self.team_id, dataset_id=self.uid,
-                                       session=self.session, project_id=self.project_id)
+                                       session=self.session)
 
     @property
     def process_specs(self) -> ProcessSpecCollection:
         """Return a resource representing all process specs in this dataset."""
         return ProcessSpecCollection(team_id=self.team_id, dataset_id=self.uid,
-                                     session=self.session, project_id=self.project_id)
+                                     session=self.session)
 
     @property
     def measurement_specs(self) -> MeasurementSpecCollection:
         """Return a resource representing all measurement specs in this dataset."""
         return MeasurementSpecCollection(team_id=self.team_id, dataset_id=self.uid,
-                                         session=self.session, project_id=self.project_id)
+                                         session=self.session)
 
     @property
     def material_specs(self) -> MaterialSpecCollection:
         """Return a resource representing all material specs in this dataset."""
         return MaterialSpecCollection(team_id=self.team_id, dataset_id=self.uid,
-                                      session=self.session, project_id=self.project_id)
+                                      session=self.session)
 
     @property
     def ingredient_specs(self) -> IngredientSpecCollection:
         """Return a resource representing all ingredient specs in this dataset."""
         return IngredientSpecCollection(team_id=self.team_id, dataset_id=self.uid,
-                                        session=self.session, project_id=self.project_id)
+                                        session=self.session)
 
     @property
     def gemd(self) -> GEMDResourceCollection:
         """Return a resource representing all GEMD objects/templates in this dataset."""
         return GEMDResourceCollection(team_id=self.team_id, dataset_id=self.uid,
-                                      session=self.session, project_id=self.project_id)
+                                      session=self.session)
 
     @property
     def files(self) -> FileCollection:
         """Return a resource representing all files in the dataset."""
-        return FileCollection(team_id=self.team_id, dataset_id=self.uid,
-                              session=self.session, project_id=self.project_id)
+        return FileCollection(team_id=self.team_id, dataset_id=self.uid, session=self.session)
 
     @property
     def ingestions(self) -> IngestionCollection:
         """Return a resource representing all files in the dataset."""
-        return IngestionCollection(team_id=self.team_id, dataset_id=self.uid,
-                                   session=self.session, project_id=self.project_id)
+        return IngestionCollection(team_id=self.team_id, dataset_id=self.uid, session=self.session)
 
     def register(self, model: DataConcepts, *, dry_run=False) -> DataConcepts:
         """Register a data model object to the appropriate collection."""
@@ -408,7 +401,7 @@ def gemd_batch_delete(
 
 class DatasetCollection(Collection[Dataset]):
     """
-    Represents the collection of all datasets associated with a project.
+    Represents the collection of all datasets associated with a team.
 
     Parameters
     ----------
@@ -422,33 +415,11 @@ class DatasetCollection(Collection[Dataset]):
     _individual_key = None
     _collection_key = None
     _resource = Dataset
+    _path_template = 'teams/{team_id}/datasets'
 
-    def __init__(self,
-                 *args,
-                 session: Session = None,
-                 team_id: UUID = None,
-                 project_id: Optional[UUID] = None):
-        # Handle positional arguments for backward compatibility
-        args = _pad_positional_args(args, 2)
-        self.project_id = project_id or args[0]
-        self.session = session or args[1]
-        if self.session is None:
-            raise TypeError("Missing one required argument: session.")
-
-        self.team_id = _data_manager_deprecation_checks(
-            session=self.session,
-            project_id=self.project_id,
-            team_id=team_id,
-            obj_type="Datasets")
-
-    # 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:
-            return f'teams/{self.team_id}/datasets'
-        else:
-            return f'projects/{self.project_id}/datasets'
+    def __init__(self, *, session: Session, team_id: UUID):
+        self.session = session
+        self.team_id = team_id
 
     def build(self, data: dict) -> Dataset:
         """
@@ -468,7 +439,6 @@ def build(self, data: dict) -> Dataset:
         dataset = Dataset.build(data)
         dataset.team_id = self.team_id
         dataset.session = self.session
-        dataset.project_id = self.project_id
         return dataset
 
     def register(self, model: Dataset) -> Dataset:

src/citrine/resources/file_link.py

@@ -7,15 +7,13 @@
 from urllib.parse import urlparse
 from urllib.request import url2pathname
 from uuid import UUID
-from warnings import warn
 
 from citrine._rest.collection import Collection
 from citrine._rest.resource import GEMDResource
 from citrine._serialization import properties
 from citrine._serialization.serializable import Serializable
 from citrine._session import Session
-from citrine._utils.functions import _data_manager_deprecation_checks, _pad_positional_args, \
-    rewrite_s3_links_locally, write_file_locally
+from citrine._utils.functions import rewrite_s3_links_locally, write_file_locally
 from citrine.resources.response import Response
 from gemd.entity.dict_serializable import DictSerializableMeta
 from gemd.entity.bounds.base_bounds import BaseBounds
@@ -198,28 +196,10 @@ class FileCollection(Collection[FileLink]):
     _collection_key = 'files'
     _resource = FileLink
 
-    def __init__(
-        self,
-        *args,
-        session: Session = None,
-        dataset_id: UUID = None,
-        team_id: UUID = None,
-        project_id: Optional[UUID] = None
-    ):
-        args = _pad_positional_args(args, 3)
-        self.project_id = project_id or args[0]
-        self.dataset_id = dataset_id or args[1]
-        self.session = session or args[2]
-        if self.session is None:
-            raise TypeError("Missing one required argument: session.")
-        if self.dataset_id is None:
-            raise TypeError("Missing one required argument: dataset_id.")
-
-        self.team_id = _data_manager_deprecation_checks(
-            session=self.session,
-            project_id=self.project_id,
-            team_id=team_id,
-            obj_type="File Links")
+    def __init__(self, *, session: Session, dataset_id: UUID, team_id: UUID):
+        self.dataset_id = dataset_id
+        self.session = session
+        self.team_id = team_id
 
     def _get_path(self,
                   uid: Optional[Union[UUID, str]] = None,
@@ -727,15 +707,7 @@ def ingest(self,
         from citrine.resources.project import Project  # noqa: F401
 
         if build_table and project is None:
-            if self.project_id is None:
-                raise ValueError("Building a table requires a target project.")
-            else:
-                warn(
-                    "Building a table with an implicit project is deprecated "
-                    "and will be removed in v4. Please pass a project explicitly.",
-                    DeprecationWarning
-                )
-                project = self.project_id
+            raise ValueError("Building a table requires a target project.")
 
         def resolve_with_local(candidate: Union[FileLink, Path, str]) -> FileLink:
             """Resolve Path, str or FileLink to an absolute reference."""