added delete_recod_set and selete_file_view

Author: andrewelamb

synapseclient/models/curation.py

@@ -45,7 +45,7 @@ class FileBasedMetadataTaskProperties:
     A CurationTaskProperties for file-based data, describing where data is uploaded
     and a view which contains the annotations.
 
-    Represents a [Synapse FileBasedMetadataTaskProperties](https://rest-docs.synapse.org/org/sagebionetworks/repo/model/curation/metadata/FileBasedMetadataTaskProperties.html).
+    Represents a [Synapse FileBasedMetadataTaskProperties](https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/curation/metadata/FileBasedMetadataTaskProperties.html).
 
     Attributes:
         upload_folder_id: The synId of the folder where data files of this type are to be uploaded
@@ -94,7 +94,7 @@ class RecordBasedMetadataTaskProperties:
     """
     A CurationTaskProperties for record-based metadata.
 
-    Represents a [Synapse RecordBasedMetadataTaskProperties](https://rest-docs.synapse.org/org/sagebionetworks/repo/model/curation/metadata/RecordBasedMetadataTaskProperties.html).
+    Represents a [Synapse RecordBasedMetadataTaskProperties](https://rest-docs.synapse.org/rest/org/sagebionetworks/repo/model/curation/metadata/RecordBasedMetadataTaskProperties.html).
 
     Attributes:
         record_set_id: The synId of the RecordSet that will contain all record-based metadata
@@ -213,11 +213,21 @@ def get(self, *, synapse_client: Optional[Synapse] = None) -> "CurationTask":
         """
         return self
 
-    def delete(self, *, synapse_client: Optional[Synapse] = None) -> None:
+    def delete(
+        self,
+        delete_file_view: bool = False,
+        delete_record_set: bool = False,
+        *,
+        synapse_client: Optional[Synapse] = None,
+    ) -> None:
         """
         Deletes a CurationTask from Synapse.
 
         Arguments:
+            delete_file_view: If True, the associated EntityView will also be deleted
+                if the task is a FileBasedMetadataTask. Defaults to False.
+            delete_record_set: If True, the associated RecordSet will also be deleted
+                if the task is a RecordBasedMetadataTask. Defaults to False.
             synapse_client: If not passed in and caching was not disabled by
                 `Synapse.allow_client_caching(False)` this will use the last created
                 instance from the Synapse class constructor.
@@ -238,6 +248,34 @@ def delete(self, *, synapse_client: Optional[Synapse] = None) -> None:
             task = CurationTask(task_id=123)
             task.delete()
             ```
+
+        Example: Delete a curation task and its associated file view
+             
+
+            ```python
+            from synapseclient import Synapse
+            from synapseclient.models import CurationTask
+
+            syn = Synapse()
+            syn.login()
+
+            task = CurationTask(task_id=123)
+            task.delete(delete_file_view=True)
+            ```
+
+        Example: Delete a curation task and its associated record set
+             
+
+            ```python
+            from synapseclient import Synapse
+            from synapseclient.models import CurationTask
+
+            syn = Synapse()
+            syn.login()
+
+            task = CurationTask(task_id=123)
+            task.delete(delete_record_set=True)
+            ```
         """
         return None
 
@@ -602,17 +640,32 @@ async def main():
         self._set_last_persistent_instance()
         return self
 
-    async def delete_async(self, *, synapse_client: Optional[Synapse] = None) -> None:
+    async def delete_async(
+        self,
+        delete_file_view: bool = False,
+        delete_record_set: bool = False,
+        *,
+        synapse_client: Optional[Synapse] = None,
+    ) -> None:
         """
         Deletes a CurationTask from Synapse.
 
         Arguments:
+            delete_file_view: If True, the associated EntityView will also be deleted
+                if the task is a FileBasedMetadataTask. Defaults to False.
+            delete_record_set: If True, the associated RecordSet will also be deleted
+                if the task is a RecordBasedMetadataTask. Defaults to False.
             synapse_client: If not passed in and caching was not disabled by
                 `Synapse.allow_client_caching(False)` this will use the last created
                 instance from the Synapse class constructor.
 
         Raises:
             ValueError: If the CurationTask object does not have a task_id.
+            ValueError: If delete_file_view=True but the task is not a FileBasedMetadataTask or does not have a
+                file_view_id.
+            ValueError: If delete_record_set=True but the task is not a RecordBasedMetadataTask or does not have a
+                record_set_id.
+
 
         Example: Delete a curation task asynchronously
              
@@ -632,6 +685,44 @@ async def main():
 
             asyncio.run(main())
             ```
+
+        Example: Delete a curation task and its associated file view asynchronously
+             
+
+            ```python
+            import asyncio
+            from synapseclient import Synapse
+            from synapseclient.models import CurationTask
+
+            syn = Synapse()
+            syn.login()
+
+            async def main():
+                task = CurationTask(task_id=123)
+                await task.delete_async(delete_file_view=True)
+                print("Task and file view deleted successfully")
+
+            asyncio.run(main())
+            ```
+
+        Example: Delete a curation task and its associated record set asynchronously
+             
+
+            ```python
+            import asyncio
+            from synapseclient import Synapse
+            from synapseclient.models import CurationTask
+
+            syn = Synapse()
+            syn.login()
+
+            async def main():
+                task = CurationTask(task_id=123)
+                await task.delete_async(delete_record_set=True)
+                print("Task and record set deleted successfully")
+
+            asyncio.run(main())
+            ```
         """
         if not self.task_id:
             raise ValueError("task_id is required to delete a CurationTask")
@@ -642,6 +733,64 @@ async def main():
             }
         )
 
+        if delete_file_view or delete_record_set:
+            if not self.task_properties:
+                await self.get_async(synapse_client=synapse_client)
+
+        if delete_file_view:
+            if (
+                isinstance(self.task_properties, FileBasedMetadataTaskProperties)
+                and self.task_properties.file_view_id
+            ):
+                from synapseclient.models.entityview import EntityView
+
+                await EntityView(id=self.task_properties.file_view_id).delete_async(
+                    synapse_client=synapse_client
+                )
+
+            elif not isinstance(self.task_properties, FileBasedMetadataTaskProperties):
+                raise ValueError(
+                    (
+                        "The `delete_file_view` parameter was set to True, "
+                        "but the task is not configured as a FileBasedMetadataTask."
+                    )
+                )
+            else:
+                raise ValueError(
+                    (
+                        "The `delete_file_view` parameter was set to True, "
+                        "but the task does not have an associated file view ID."
+                    )
+                )
+
+        if delete_record_set:
+            if (
+                isinstance(self.task_properties, RecordBasedMetadataTaskProperties)
+                and self.task_properties.record_set_id
+            ):
+                from synapseclient.models.recordset import RecordSet
+
+                await RecordSet(id=self.task_properties.record_set_id).delete_async(
+                    synapse_client=synapse_client
+                )
+
+            elif not isinstance(
+                self.task_properties, RecordBasedMetadataTaskProperties
+            ):
+                raise ValueError(
+                    (
+                        "The `delete_record_set` parameter was set to True, "
+                        "but the task is not configured as a RecordBasedMetadataTask."
+                    )
+                )
+            else:
+                raise ValueError(
+                    (
+                        "The `delete_record_set` parameter was set to True, "
+                        "but the task does not have an associated record set ID."
+                    )
+                )
+
         await delete_curation_task(task_id=self.task_id, synapse_client=synapse_client)
 
     async def store_async(

tests/integration/synapseclient/models/async/test_curation_async.py

@@ -10,6 +10,7 @@
 
 from synapseclient import Synapse
 from synapseclient.core.exceptions import SynapseHTTPError
+from synapseclient.core.utils import make_bogus_uuid_file
 from synapseclient.models import (
     Column,
     ColumnType,
@@ -412,7 +413,35 @@ async def folder_with_view(
 
         return folder, entity_view
 
-    async def test_delete_curation_task_async(
+    @pytest.fixture(scope="class")
+    async def folder_with_record_set(
+        self,
+        project_model: Project,
+        syn: Synapse,
+        schedule_for_cleanup: Callable[..., None],
+    ) -> tuple[Folder, EntityView]:
+        """Create a folder with a a record set for record-based testing."""
+        # Create a folder
+        folder = await Folder(
+            name=str(uuid.uuid4()),
+            parent_id=project_model.id,
+        ).store_async(synapse_client=syn)
+        schedule_for_cleanup(folder.id)
+
+        filename = make_bogus_uuid_file()
+        schedule_for_cleanup(filename)
+
+        record_set = await RecordSet(
+            name=str(uuid.uuid4()),
+            parent_id=folder.id,
+            path=filename,
+            upsert_keys=["xxx"],
+        ).store_async(synapse_client=syn)
+        schedule_for_cleanup(record_set.id)
+
+        return folder, record_set
+
+    async def test_delete_file_based_curation_task_async(
         self, project_model: Project, folder_with_view: tuple[Folder, EntityView]
     ) -> None:
         # GIVEN a project, folder, and entity view
@@ -434,13 +463,118 @@ async def test_delete_curation_task_async(
         task_id = curation_task.task_id
         assert task_id is not None
 
-        # WHEN I delete the task asynchronously
-        await curation_task.delete_async(synapse_client=self.syn)
+        # WHEN I delete the task asynchronously, without deleting the file view
+        await curation_task.delete_async(
+            synapse_client=self.syn, delete_file_view=False
+        )
 
         # THEN the task should be deleted and no longer retrievable
         with pytest.raises(SynapseHTTPError):
             await CurationTask(task_id=task_id).get_async(synapse_client=self.syn)
 
+        # AND the file view should not be deleted
+        await EntityView(entity_view.id).get_async(synapse_client=self.syn)
+
+    async def test_delete_file_based_curation_task_and_fileview_async(
+        self, project_model: Project, folder_with_view: tuple[Folder, EntityView]
+    ) -> None:
+        # GIVEN a project, folder, and entity view
+        folder, entity_view = folder_with_view
+
+        # GIVEN an existing curation task
+        data_type = f"test_data_type_{str(uuid.uuid4()).replace('-', '_')}"
+        task_properties = FileBasedMetadataTaskProperties(
+            upload_folder_id=folder.id,
+            file_view_id=entity_view.id,
+        )
+        curation_task = await CurationTask(
+            data_type=data_type,
+            project_id=project_model.id,
+            instructions="Task to be deleted",
+            task_properties=task_properties,
+        ).store_async(synapse_client=self.syn)
+
+        task_id = curation_task.task_id
+        assert task_id is not None
+
+        # WHEN I delete the task and fileview asynchronously
+        await curation_task.delete_async(synapse_client=self.syn, delete_file_view=True)
+
+        # THEN the task should be deleted and no longer retrievable
+        with pytest.raises(SynapseHTTPError):
+            await CurationTask(task_id=task_id).get_async(synapse_client=self.syn)
+
+        # AND the file view should be deleted and no longer retrievable
+        with pytest.raises(SynapseHTTPError):
+            await EntityView(entity_view.id).get_async(synapse_client=self.syn)
+
+    async def test_delete_record_based_curation_task_async(
+        self, project_model: Project, folder_with_record_set: tuple[Folder, EntityView]
+    ) -> None:
+        # GIVEN a folder, and record set
+        _, record_set = folder_with_record_set
+
+        # GIVEN an existing curation task
+        data_type = f"test_data_type_{str(uuid.uuid4()).replace('-', '_')}"
+        task_properties = RecordBasedMetadataTaskProperties(
+            record_set_id=record_set.id,
+        )
+        curation_task = await CurationTask(
+            data_type=data_type,
+            project_id=project_model.id,
+            instructions="Task to be deleted",
+            task_properties=task_properties,
+        ).store_async(synapse_client=self.syn)
+
+        task_id = curation_task.task_id
+        assert task_id is not None
+
+        # WHEN I delete the task asynchronously, without deleting the record set
+        await curation_task.delete_async(
+            synapse_client=self.syn, delete_record_set=False
+        )
+
+        # THEN the task should be deleted and no longer retrievable
+        with pytest.raises(SynapseHTTPError):
+            await CurationTask(task_id=task_id).get_async(synapse_client=self.syn)
+
+        # AND the record set should not be deleted
+        await RecordSet(record_set.id).get_async(synapse_client=self.syn)
+
+    async def test_delete_record_based_curation_task_and_record_set_async(
+        self, project_model: Project, folder_with_record_set: tuple[Folder, EntityView]
+    ) -> None:
+        # GIVEN a folder, and record set
+        _, record_set = folder_with_record_set
+
+        # GIVEN an existing curation task
+        data_type = f"test_data_type_{str(uuid.uuid4()).replace('-', '_')}"
+        task_properties = RecordBasedMetadataTaskProperties(
+            record_set_id=record_set.id,
+        )
+        curation_task = await CurationTask(
+            data_type=data_type,
+            project_id=project_model.id,
+            instructions="Task to be deleted",
+            task_properties=task_properties,
+        ).store_async(synapse_client=self.syn)
+
+        task_id = curation_task.task_id
+        assert task_id is not None
+
+        # WHEN I delete the task asynchronously, without deleting the record set
+        await curation_task.delete_async(
+            synapse_client=self.syn, delete_record_set=True
+        )
+
+        # THEN the task should be deleted and no longer retrievable
+        with pytest.raises(SynapseHTTPError):
+            await CurationTask(task_id=task_id).get_async(synapse_client=self.syn)
+
+        # AND the record set should be deleted and not retrievable
+        with pytest.raises(SynapseHTTPError):
+            await RecordSet(record_set.id).get_async(synapse_client=self.syn)
+
     async def test_delete_validation_error_async(self) -> None:
         # GIVEN a CurationTask without a task_id
         curation_task = CurationTask()