django-to-galaxy 0.6.9.8__py3-none-any.whl → 0.6.9.9__py3-none-any.whl

django_to_galaxy/api/views/create_dataset_collection.py

@@ -0,0 +1,461 @@
+from django.core.exceptions import ObjectDoesNotExist
+from drf_yasg.utils import swagger_auto_schema
+from drf_yasg import openapi
+from rest_framework.response import Response
+
+from rest_framework.generics import GenericAPIView
+from rest_framework.status import HTTP_404_NOT_FOUND
+
+from django_to_galaxy.models import History
+from django_to_galaxy.api.serializers.create_dataset_collection import (
+    CollectionListSerializer,
+    CollectionListPairedSerializer,
+    CollectionPairedSerializer,
+)
+
+from bioblend import ConnectionError
+
+example_payload_list = {
+    "200": openapi.Response(
+        description="Dataset collection created successfully.",
+        examples={
+            "application/json": {
+                "summary": "Example payload",
+                "description": "An example of a payload to create a dataset collection.",
+                "value": {
+                    "history_id": 1,
+                    "collection_name": "My Dataset Collection",
+                    "elements_names": ["dataset1", "dataset2"],
+                    "elements_ids": ["f4b5e6d8a9c0b1e2", "a1b2c3d4e5f60708"],
+                },
+            }
+        },
+    )
+}
+
+example_payload_list_paired = {
+    "200": openapi.Response(
+        description="Dataset collection created successfully.",
+        examples={
+            "application/json": {
+                "summary": "Example payload",
+                "description": "An example of a payload to create a paired dataset collection.",
+                "value": {
+                    "history_id": 1,
+                    "collection_name": "My Paired Collection",
+                    "pairs_names": ["pair1", "pair2"],
+                    "first_elements_ids": ["id1", "id2"],
+                    "second_elements_ids": ["id3", "id4"],
+                },
+            }
+        },
+    )
+}
+
+example_payload_paired = {
+    "200": openapi.Response(
+        description="Dataset collection created successfully.",
+        examples={
+            "application/json": {
+                "summary": "Example payload",
+                "description": "An example of a payload to create a paired dataset collection.",
+                "value": {
+                    "history_id": 1,
+                    "collection_name": "My Paired Collection",
+                    "first_element_id": "id1",
+                    "second_element_id": "id2",
+                },
+            }
+        },
+    )
+}
+
+
+class CreateDatasetListCollectionView(GenericAPIView):
+    """
+    API endpoint to create a dataset collection (list) in a Galaxy history.
+
+    - POST: Creates a dataset collection in a specified Galaxy history.
+    - Serializer: CollectionListSerializer
+    - Returns: JSON response with collection details or connection errors.
+    """
+
+    serializer_class = CollectionListSerializer
+
+    @swagger_auto_schema(
+        operation_description="Create a dataset collection with dataset of an Galaxy history.",
+        operation_summary="Create a dataset collection with dataset of an Galaxy history.",
+        tags=["collections"],
+        responses=example_payload_list,
+        request_body=openapi.Schema(
+            type=openapi.TYPE_OBJECT,
+            properties={
+                "history_id": openapi.Schema(type=openapi.TYPE_INTEGER, example=1),
+                "collection_name": openapi.Schema(
+                    type=openapi.TYPE_STRING, example="My Dataset Collection"
+                ),
+                "elements_names": openapi.Schema(
+                    type=openapi.TYPE_ARRAY,
+                    items=openapi.Items(type=openapi.TYPE_STRING),
+                    example=["dataset1", "dataset2"],
+                ),
+                "elements_ids": openapi.Schema(
+                    type=openapi.TYPE_ARRAY,
+                    items=openapi.Items(type=openapi.TYPE_STRING),
+                    example=["f4b5e6d8a9c0b1e2", "a1b2c3d4e5f60708"],
+                ),
+            },
+            required=[
+                "history_id",
+                "collection_name",
+                "elements_names",
+                "elements_ids",
+            ],
+        ),
+    )
+    def post(self, request):
+        serializer_class = self.get_serializer_class()
+        serializer = serializer_class(data=request.data, context={"request": request})
+        serializer.is_valid(raise_exception=True)
+        data = serializer.data
+        # Retrieve history
+        try:
+            history = History.objects.get(id=data["history_id"])
+        except ObjectDoesNotExist:
+            return Response(
+                {
+                    "message": (
+                        "Galaxy history with id ",
+                        f"<{data['history_id']}> not found!",
+                    )
+                },
+                status=HTTP_404_NOT_FOUND,
+            )
+        # Collect ConnectionError exceptions
+        connection_errors = []
+        datasets = []
+        # Check each dataset id
+        for i in range(len(data.get("elements_names", []))):
+            try:
+                dataset = history.galaxy_owner.obj_gi.gi.datasets.show_dataset(
+                    data["elements_ids"][i]
+                )
+                datasets.append(dataset)
+            except ConnectionError as e:
+                connection_errors.append(
+                    {
+                        "index": i,
+                        "type": "elements_ids",
+                        "id": data["elements_ids"][i],
+                        "error": str(e),
+                    }
+                )
+                datasets.append(None)
+
+        # If any errors, return them as final response
+        if connection_errors:
+            return Response({"connection_errors": connection_errors}, status=400)
+
+        # Retrieve file & file path
+        collection_datamap = {
+            "name": data["collection_name"],
+            "collection_type": "list",
+            "element_identifiers": [],
+        }
+
+        for i in range(len(data.get("elements_names", []))):
+            if datasets[i] is not None:
+                collection_datamap["element_identifiers"].append(
+                    {
+                        "name": data["elements_names"][i],
+                        "src": "hda",
+                        "id": data["elements_ids"][i],
+                    }
+                )
+        try:
+            history_association = history.galaxy_history.create_dataset_collection(
+                collection_description=collection_datamap
+            )
+        except ConnectionError as e:
+            connection_errors.append(
+                {"type": "create_dataset_collection", "error": str(e)}
+            )
+            return Response({"connection_errors": connection_errors}, status=400)
+
+        message = (
+            "Collection of list of dataset has "
+            f"been created to Galaxy History <{str(history)}>"
+        )
+        return Response(
+            {
+                "message": message,
+                "history_association_id": history_association.id,
+                "history_id": history.id,
+            }
+        )
+
+
+class CreateDatasetListPairedCollectionView(GenericAPIView):
+    """
+    API endpoint to create a paired dataset collection (list:paired) in a Galaxy history.
+
+    - POST: Creates a paired dataset collection in a specified Galaxy history.
+    - Serializer: CollectionListPairedSerializer
+    - Returns: JSON response with collection details or connection errors.
+    """
+
+    serializer_class = CollectionListPairedSerializer
+
+    @swagger_auto_schema(
+        operation_description=(
+            "Create a paired dataset collection " "(list:paired) in a Galaxy history."
+        ),
+        operation_summary="Create a paired dataset collection (list:paired) in a Galaxy history.",
+        tags=["collections"],
+        responses=example_payload_list_paired,
+        request_body=openapi.Schema(
+            type=openapi.TYPE_OBJECT,
+            properties={
+                "history_id": openapi.Schema(type=openapi.TYPE_INTEGER, example=1),
+                "collection_name": openapi.Schema(
+                    type=openapi.TYPE_STRING, example="My Paired Collection"
+                ),
+                "pairs_names": openapi.Schema(
+                    type=openapi.TYPE_ARRAY,
+                    items=openapi.Items(type=openapi.TYPE_STRING),
+                    example=["pair1", "pair2"],
+                ),
+                "first_elements_ids": openapi.Schema(
+                    type=openapi.TYPE_ARRAY,
+                    items=openapi.Items(type=openapi.TYPE_STRING),
+                    example=["id1", "id2"],
+                ),
+                "second_elements_ids": openapi.Schema(
+                    type=openapi.TYPE_ARRAY,
+                    items=openapi.Items(type=openapi.TYPE_STRING),
+                    example=["id3", "id4"],
+                ),
+            },
+            required=[
+                "history_id",
+                "collection_name",
+                "pairs_names",
+                "first_elements_ids",
+                "second_elements_ids",
+            ],
+        ),
+    )
+    def post(self, request):
+        serializer_class = self.get_serializer_class()
+        serializer = serializer_class(data=request.data, context={"request": request})
+        serializer.is_valid(raise_exception=True)
+        data = serializer.data
+        # Retrieve history
+        try:
+            history = History.objects.get(id=data["history_id"])
+        except ObjectDoesNotExist:
+            return Response(
+                {
+                    "message": (
+                        "Galaxy history with id ",
+                        f"<{data['history_id']}> not found!",
+                    )
+                },
+                status=HTTP_404_NOT_FOUND,
+            )
+        # Collect ConnectionError exceptions
+        connection_errors = []
+        first_datasets = []
+        second_datasets = []
+        # Check each dataset id
+        for i in range(len(data.get("pairs_names", []))):
+            try:
+                first_dataset = history.galaxy_owner.obj_gi.gi.datasets.show_dataset(
+                    data["first_elements_ids"][i]
+                )
+                first_datasets.append(first_dataset)
+            except ConnectionError as e:
+                connection_errors.append(
+                    {
+                        "index": i,
+                        "type": "first_elements_ids",
+                        "id": data["first_elements_ids"][i],
+                        "error": str(e),
+                    }
+                )
+                first_datasets.append(None)
+            try:
+                second_dataset = history.galaxy_owner.obj_gi.gi.datasets.show_dataset(
+                    data["second_elements_ids"][i]
+                )
+                second_datasets.append(second_dataset)
+            except ConnectionError as e:
+                connection_errors.append(
+                    {
+                        "index": i,
+                        "type": "second_elements_ids",
+                        "id": data["second_elements_ids"][i],
+                        "error": str(e),
+                    }
+                )
+                second_datasets.append(None)
+
+        # If any errors, return them as final response
+        if connection_errors:
+            return Response({"connection_errors": connection_errors}, status=400)
+
+        # Retrieve file & file path
+        collection_datamap = {
+            "name": data["collection_name"],
+            "collection_type": "list:paired",
+            "element_identifiers": [],
+        }
+
+        for i in range(len(data.get("pairs_names", []))):
+            if first_datasets[i] is not None and second_datasets[i] is not None:
+                collection_datamap["element_identifiers"].append(
+                    {
+                        "name": data["pairs_names"][i],
+                        "src": "new_collection",
+                        "collection_type": "paired",
+                        "element_identifiers": [
+                            {
+                                "name": "forward",
+                                "src": "hda",
+                                "id": data["first_elements_ids"][i],
+                            },
+                            {
+                                "name": "reverse",
+                                "src": "hda",
+                                "id": data["second_elements_ids"][i],
+                            },
+                        ],
+                    }
+                )
+
+        try:
+            history_association = history.galaxy_history.create_dataset_collection(
+                collection_description=collection_datamap
+            )
+        except ConnectionError as e:
+            connection_errors.append(
+                {"type": "create_dataset_collection", "error": str(e)}
+            )
+            return Response({"connection_errors": connection_errors}, status=400)
+
+        message = (
+            "Collection of paired dataset has been "
+            f"created to Galaxy History <{str(history)}>"
+        )
+        return Response(
+            {
+                "message": message,
+                "history_association_id": history_association.id,
+                "history_id": history.id,
+            }
+        )
+
+
+class CreateDatasetPairedCollectionView(GenericAPIView):
+    """
+    API endpoint to create a paired dataset collection in a Galaxy history.
+
+    - POST: Creates a paired dataset collection in a specified Galaxy history.
+    - Serializer: CollectionPairedSerializer
+    - Returns: JSON response with collection details or connection errors.
+    """
+
+    serializer_class = CollectionPairedSerializer
+
+    @swagger_auto_schema(
+        operation_description="Create a paired dataset collection in a Galaxy history.",
+        operation_summary="Create a paired dataset collection in a Galaxy history.",
+        tags=["collections"],
+        responses=example_payload_paired,
+        request_body=openapi.Schema(
+            type=openapi.TYPE_OBJECT,
+            properties={
+                "history_id": openapi.Schema(type=openapi.TYPE_INTEGER, example=1),
+                "collection_name": openapi.Schema(
+                    type=openapi.TYPE_STRING, example="My Paired Collection"
+                ),
+                "first_element_id": openapi.Schema(
+                    type=openapi.TYPE_STRING, example="id1"
+                ),
+                "second_element_id": openapi.Schema(
+                    type=openapi.TYPE_STRING, example="id2"
+                ),
+            },
+            required=[
+                "history_id",
+                "collection_name",
+                "first_element_id",
+                "second_element_id",
+            ],
+        ),
+    )
+    def post(self, request):
+        serializer_class = self.get_serializer_class()
+        serializer = serializer_class(data=request.data, context={"request": request})
+        serializer.is_valid(raise_exception=True)
+        data = serializer.data
+        # Retrieve history
+        try:
+            history = History.objects.get(id=data["history_id"])
+        except ObjectDoesNotExist:
+            return Response(
+                {
+                    "message": (
+                        "Galaxy history with id ",
+                        f"<{data['history_id']}> not found!",
+                    )
+                },
+                status=HTTP_404_NOT_FOUND,
+            )
+
+        # Check each dataset id
+        try:
+            history.galaxy_owner.obj_gi.gi.datasets.show_dataset(
+                data["first_element_id"]
+            )
+        except ConnectionError:
+            return Response({"message": "first_element_id is not valid"}, status=400)
+
+        try:
+            history.galaxy_owner.obj_gi.gi.datasets.show_dataset(
+                data["second_element_id"]
+            )
+        except ConnectionError:
+            return Response({"message": "second_element_id is not valid"}, status=400)
+
+        # Retrieve file & file path
+        collection_datamap = {
+            "name": data["collection_name"],
+            "collection_type": "paired",
+            "element_identifiers": [
+                {"name": "forward", "src": "hda", "id": data["first_element_id"]},
+                {"name": "reverse", "src": "hda", "id": data["second_element_id"]},
+            ],
+        }
+
+        try:
+            history_association = history.galaxy_history.create_dataset_collection(
+                collection_description=collection_datamap
+            )
+        except ConnectionError as e:
+            return Response(
+                {"message": str(e)},
+                status=400,
+            )
+        message = (
+            "Collection of paired dataset has been "
+            f"created to Galaxy History <{str(history)}>"
+        )
+
+        return Response(
+            {
+                "message": message,
+                "history_association_id": history_association.id,
+                "history_id": history.id,
+            }
+        )

django_to_galaxy/api/views/create_history.py

@@ -3,15 +3,18 @@ from rest_framework.response import Response
 from rest_framework.generics import RetrieveAPIView
 
 from django_to_galaxy.models import GalaxyUser
+from django_to_galaxy.api.serializers.create_history import HistoryCreatedSerializer
 
 
 class CreateHistoryView(RetrieveAPIView):
     queryset = GalaxyUser.objects.all()
+    serializer_class = None
 
     @swagger_auto_schema(
         operation_description="Create history from a user.",
         operation_summary="Create history from a user.",
         tags=["galaxy_users"],
+        responses={200: HistoryCreatedSerializer},
     )
     def get(self, request, *args, **kwargs):
         instance = self.get_object()

django_to_galaxy/api/views/invocation.py

@@ -4,7 +4,10 @@ from rest_framework.response import Response
 from rest_framework.generics import RetrieveAPIView
 
 from django_to_galaxy.models.invocation import Invocation
-from django_to_galaxy.api.serializers.invocation import InvocationSerializer
+from django_to_galaxy.api.serializers.invocation import (
+    InvocationSerializer,
+    UpdateOutputFilesResponseSerializer,
+)
 
 
 class InvocationViewSet(viewsets.ReadOnlyModelViewSet):
@@ -18,11 +21,13 @@ class InvocationViewSet(viewsets.ReadOnlyModelViewSet):
 
 class UpdateOutputFilesView(RetrieveAPIView):
     queryset = Invocation.objects.all()
+    serializer_class = UpdateOutputFilesResponseSerializer
 
     @swagger_auto_schema(
         operation_description="Update output files from an invocation.",
         operation_summary="Update output files from an invocation.",
         tags=["invocations"],
+        responses={200: UpdateOutputFilesResponseSerializer},
     )
     def get(self, request, *args, **kwargs):
         instance = self.get_object()

django_to_galaxy/api/views/invoke_workflow.py

@@ -11,6 +11,7 @@ from django_to_galaxy.models import History, Workflow, GalaxyUser
 from django_to_galaxy.api.serializers.invoke_workflow import (
     InvokeWorkflowSerializer,
     ExecuteWorkflowSerializer,
+    GenericDictSerializer,
 )
 
 
@@ -61,35 +62,36 @@ class InvokeWorkflowView(GenericAPIView):
 
 class GetWorkflowDatamapTemplateView(RetrieveAPIView):
     queryset = Workflow.objects.all()
+    serializer_class = GenericDictSerializer
 
     @swagger_auto_schema(
         operation_description="Get workflow datamap to prepare workflow invocation.",
         operation_summary="Get workflow datamap to prepare workflow invocation.",
         tags=["workflows"],
+        responses={200: GenericDictSerializer},
     )
     def get(self, request, *args, **kwargs):
         instance = self.get_object()
-        inputs = instance.galaxy_workflow.inputs
-        steps = instance.galaxy_workflow.steps
-        input_mapping = {}
-        datamap_template = {}
-        for input_id, input_dict in inputs.items():
-            input_mapping[input_id] = {}
-            input_mapping[input_id]["label"] = input_dict["label"]
-            input_mapping[input_id]["type"] = steps[input_id].type
-            input_mapping[input_id]["tool_inputs"] = steps[input_id].tool_inputs
-
-            if steps[input_id].type == "parameter_input":
-                datamap_template[input_id] = input_mapping[input_id]["tool_inputs"][
-                    "parameter_type"
-                ]
-            else:
-                datamap_template[input_id] = {"id": "", "src": "hda"}
-            # TODO: Add template for a collection input
-
-        return Response(
-            data={"input_mapping": input_mapping, "datamap_template": datamap_template}
-        )
+        datamap = instance.get_workflow_datamap_template()
+
+        return Response(data=datamap)
+
+
+"""
+class GetWorkflowInputsView(RetrieveAPIView):
+    queryset = Workflow.objects.all()
+
+    @swagger_auto_schema(
+        operation_description="Get workflow inputs information from Galaxy.",
+        operation_summary="Get workflow inputs information from Galaxy.",
+        tags=["workflows"],
+    )
+    def get(self, request, *args, **kwargs):
+        instance = self.get_object()
+        data = instance.get_workflow_inputs()
+
+        return Response(data=data)
+"""
 
 
 class ExecuteWorkflowView(GenericAPIView):