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

django_to_galaxy/admin/__init__.py

@@ -3,5 +3,11 @@ from .galaxy_user import GalaxyUserAdmin  # noqa
 from .galaxy_output_file import GalaxyOutputFileAdmin  # noqa
 from .history import HistoryAdmin  # noqa
 from .invocation import InvocationAdmin  # noqa
-from .workflow import WorkflowAdmin, WorkflowInputAdmin, FormatAdmin  # noqa
+from .workflow import (  # noqa
+    WorkflowAdmin,  # noqa
+    WorkflowInputAdmin,  # noqa
+    FormatAdmin,  # noqa
+    WorkflowInputTextOptionAdmin,  # noqa
+)  # noqa
 from .tag import TagAdmin  # noqa
+from .utils import *  # noqa

django_to_galaxy/admin/galaxy_user.py

@@ -10,7 +10,7 @@ from django.utils.translation import ngettext
 
 from django_to_galaxy.models.galaxy_user import GalaxyUser
 from django_to_galaxy.models.galaxy_element import Tag
-from django_to_galaxy.models.accepted_input import Format, WorkflowInput
+from django_to_galaxy.admin.utils import update_workflowinputs
 
 
 @admin.register(GalaxyUser)
@@ -146,40 +146,26 @@ class GalaxyUserAdmin(admin.ModelAdmin):
                     id_tags.append(savedtag.id)
                 if wf.galaxy_id in galaxy_id_to_save:
                     wf.save()
-                    for elem, elem_dict in wf.galaxy_workflow.inputs.items():
-                        for step, step_dict in wf.galaxy_workflow.steps.items():
-                            if step == elem:
-                                (
-                                    workflowinput,
-                                    created,
-                                ) = WorkflowInput.objects.get_or_create(
-                                    galaxy_step_id=step,
-                                    label=elem_dict["label"],
-                                    workflow=wf,
-                                )
-                                if hasattr(step_dict.tool_inputs, "format"):
-                                    for format in step_dict.tool_inputs["format"]:
-                                        (
-                                            winputformat,
-                                            created,
-                                        ) = Format.objects.get_or_create(
-                                            format=format.strip()
-                                        )
-                                        workflowinput.formats.add(winputformat.id)
-                                workflowinput.optional = step_dict.tool_inputs[
-                                    "optional"
-                                ]
-                                workflowinput.save()
-                    for tag in id_tags:
-                        wf.tags.add(tag)
-                    wf.save()
-                    existing_workflows.append(wf)
-                    new_workflows.remove((wf, tags))
-            self.message_user(
-                request,
-                f"Successfully imported {len(galaxy_id_to_save)} workflow(s)",
-                messages.SUCCESS,
-            )
+                    try:
+                        update_workflowinputs(wf.id)
+                    except Exception as e:
+                        self.message_user(
+                            request,
+                            f"Could not import '{wf.name}' workflow: {e}",
+                            messages.ERROR,
+                        )
+                    else:
+                        for tag in id_tags:
+                            wf.tags.add(tag)
+                        wf.save()
+                        existing_workflows.append(wf)
+                        new_workflows.remove((wf, tags))
+                        self.message_user(
+                            request,
+                            f"Successfully imported '{wf.name}' workflow",
+                            messages.SUCCESS,
+                        )
+
         context = dict(
             self.admin_site.each_context(request),
             galaxy_user=galaxy_user,

django_to_galaxy/admin/utils.py

@@ -0,0 +1,112 @@
+from django_to_galaxy.models.workflow import Workflow
+from django.db import transaction
+from django_to_galaxy.models.accepted_input import (
+    Format,
+    WorkflowInput,
+    DATA,
+    COLLECTION,
+    PARAMETER,
+    P_TEXT,
+    WorkflowInputTextOption,
+)
+
+"""
+Update inputs information of a workflow functions
+"""
+
+
+def search_step_info_value(key, value_none, step_info):
+    if key in step_info["tool_inputs"].keys():
+        value = step_info["tool_inputs"][key]
+    else:
+        try:
+            value = step_info["target_tools"][0]["tool_input"][key]
+        except Exception:
+            value = value_none
+
+    return value
+
+
+def update_workflowinputs(workflow_id):
+    wf = Workflow.objects.get(id=workflow_id)
+    try:
+        with transaction.atomic():
+            # Saving workflow inputs
+            input_mapping = wf.get_workflow_inputs()
+            for step, step_info in input_mapping.items():
+                input_type = step_info["type"]
+                if input_type == DATA:
+                    workflowinput, created = WorkflowInput.objects.get_or_create(
+                        galaxy_step_id=step,
+                        label=step_info["label"],
+                        workflow=wf,
+                        input_type=input_type,
+                        parameter_type=None,
+                        collection_type=None,
+                        optional=step_info["tool_inputs"]["optional"],
+                        default_value=None,
+                        multiple=False,
+                    )
+                elif input_type == COLLECTION:
+                    workflowinput, created = WorkflowInput.objects.get_or_create(
+                        galaxy_step_id=step,
+                        label=step_info["label"],
+                        workflow=wf,
+                        input_type=input_type,
+                        parameter_type=None,
+                        collection_type=step_info["tool_inputs"]["collection_type"],
+                        optional=step_info["tool_inputs"]["optional"],
+                        default_value=None,
+                        multiple=False,
+                    )
+                elif input_type == PARAMETER:
+                    parameter_type = step_info["tool_inputs"]["parameter_type"]
+                    default_value = search_step_info_value("default", None, step_info)
+                    multiple = search_step_info_value("multiple", False, step_info)
+
+                    workflowinput, created = WorkflowInput.objects.get_or_create(
+                        galaxy_step_id=step,
+                        label=step_info["label"],
+                        workflow=wf,
+                        input_type=input_type,
+                        parameter_type=parameter_type,
+                        collection_type=None,
+                        optional=step_info["tool_inputs"]["optional"],
+                        default_value=default_value,
+                        multiple=multiple,
+                    )
+                    if created and parameter_type == P_TEXT:
+                        # Add TextOption
+                        if "restrictions" in step_info["tool_inputs"].keys():
+                            # If there are restrictions, we're saving them
+                            for value in step_info["tool_inputs"]["restrictions"]:
+                                (
+                                    workflowinputtextoption,
+                                    _,
+                                ) = WorkflowInputTextOption.objects.get_or_create(
+                                    workflow_input=workflowinput, text_option=value
+                                )
+                        else:
+                            # If no restrictions, we are getting the options from the 1st tool
+                            try:
+                                tool_info = step_info["target_tools"][0]
+                                for opt in tool_info["tool_input"]["options"]:
+                                    (
+                                        workflowinputtextoption,
+                                        _,
+                                    ) = WorkflowInputTextOption.objects.get_or_create(
+                                        workflow_input=workflowinput, text_option=opt[1]
+                                    )
+                            except (KeyError, ValueError):
+                                pass
+                if "format" in step_info["tool_inputs"].keys():
+                    for format in step_info["tool_inputs"]["format"]:
+                        (
+                            winputformat,
+                            _,
+                        ) = Format.objects.get_or_create(format=format.strip())
+                        workflowinput.formats.add(winputformat.id)
+    except Exception as e:
+        raise e
+    else:
+        return

django_to_galaxy/admin/workflow.py

@@ -1,7 +1,12 @@
-from django.contrib import admin
+from django.contrib import admin, messages
+from django_to_galaxy.admin.utils import update_workflowinputs
 
 from django_to_galaxy.models.workflow import Workflow
-from django_to_galaxy.models.accepted_input import WorkflowInput, Format
+from django_to_galaxy.models.accepted_input import (
+    Format,
+    WorkflowInput,
+    WorkflowInputTextOption,
+)
 
 from .galaxy_element import GalaxyElementAdmin
 
@@ -14,7 +19,7 @@ class WorkflowAdmin(GalaxyElementAdmin):
         "annotation",
         "galaxy_id",
         "get_is_meta",
-        "get_step_jobs_count",
+        "get_step_count",
         "published",
         "galaxy_owner",
         "get_tags",
@@ -25,21 +30,48 @@ class WorkflowAdmin(GalaxyElementAdmin):
         "annotation",
         "galaxy_id",
         "get_is_meta",
-        "get_step_jobs_count",
+        "get_step_count",
         "published",
         "galaxy_owner",
         "get_tags",
     )
+    actions = ["update_workflow_inputs"]
 
     def get_is_meta(self, obj):
         return obj.get_is_meta()
 
-    def get_step_jobs_count(self, obj):
-        return obj.get_step_jobs_count()
+    def get_step_count(self, obj):
+        return obj.get_step_count()
 
     def get_tags(self, obj):
         return ", ".join([p.label for p in obj.tags.all()])
 
+    @admin.action(description="Update workflow inputs (1 workflow only)")
+    def update_workflow_inputs(self, request, queryset):
+        if queryset.count() > 1:
+            self.message_user(
+                request,
+                "You can update the workflow inputs of 1 workflow only at a time.",
+                messages.ERROR,
+            )
+            return
+        workflow = queryset[0]
+
+        try:
+            update_workflowinputs(workflow.id)
+        except Exception as e:
+            self.message_user(
+                request,
+                f"Could not update workflow inputs of '{workflow.name}' workflow: {e}",
+                messages.ERROR,
+            )
+        else:
+            self.message_user(
+                request,
+                f"Successfully updated workflow inputs of '{workflow.name}' workflow",
+                messages.SUCCESS,
+            )
+
 
 @admin.register(Format)
 class FormatAdmin(GalaxyElementAdmin):
@@ -53,15 +85,34 @@ class FormatAdmin(GalaxyElementAdmin):
     )
 
 
+@admin.register(WorkflowInputTextOption)
+class WorkflowInputTextOptionAdmin(GalaxyElementAdmin):
+    list_display = ("id", "get_workflow", "workflow_input", "text_option")
+
+    readonly_fields = ("id", "get_workflow", "workflow_input", "text_option")
+
+    def get_workflow(self, obj):
+        return obj.workflow_input.workflow
+
+
 @admin.register(WorkflowInput)
 class WorkflowInputAdmin(GalaxyElementAdmin):
+    # Limit 20 items per page
+    list_per_page = 20
+    list_max_show_all = 50
+
     list_display = (
         "id",
         "galaxy_step_id",
         "label",
         "workflow",
+        "input_type",
         "get_formats",
+        "parameter_type",
+        "collection_type",
         "optional",
+        "default_value",
+        "multiple",
     )
     readonly_fields = (
         "id",
@@ -69,7 +120,11 @@ class WorkflowInputAdmin(GalaxyElementAdmin):
         "label",
         "workflow",
         "get_formats",
+        "parameter_type",
+        "collection_type",
         "optional",
+        "default_value",
+        "multiple",
     )
 
     def get_formats(self, obj):

django_to_galaxy/api/serializers/create_dataset_collection.py

@@ -0,0 +1,118 @@
+from rest_framework import serializers
+from django.core.exceptions import ValidationError
+
+dataset_id_error_messages = {
+    "min_length": "Dataset ID must be at least 16 characters long.",
+}
+
+
+class CollectionListSerializer(serializers.Serializer):
+    history_id = serializers.IntegerField(
+        required=True,
+        help_text=(
+            "Internal Django to galaxy ID of the Galaxy "
+            "history where the collection will be created."
+        ),
+    )
+    collection_name = serializers.CharField(
+        required=True, help_text="Name of the dataset collection to be created."
+    )
+    elements_names = serializers.ListSerializer(
+        child=serializers.CharField(required=True),
+        help_text="List of names for each element in the collection.",
+    )
+    elements_ids = serializers.ListSerializer(
+        child=serializers.CharField(
+            required=True, min_length=16, error_messages=dataset_id_error_messages
+        ),
+        help_text="List of galaxy dataset IDs corresponding to each element in the collection.",
+    )
+
+    def validate(self, attrs):
+        if len(attrs["elements_names"]) != len(attrs["elements_ids"]):
+            raise ValidationError(
+                {
+                    "lists_lengths": (
+                        "List of elements_names and list of "
+                        "elements_ids must be of same length."
+                    )
+                }
+            )
+        return attrs
+
+
+class CollectionListPairedSerializer(serializers.Serializer):
+    history_id = serializers.IntegerField(
+        required=True,
+        help_text=(
+            "Internal Django to galaxy ID of the Galaxy "
+            "history where the collection will be created."
+        ),
+    )
+    collection_name = serializers.CharField(
+        required=True, help_text="Name of the dataset collection to be created."
+    )
+    pairs_names = serializers.ListSerializer(
+        child=serializers.CharField(),
+        help_text="List of names for each paired datasets in the collection.",
+    )
+    first_elements_ids = serializers.ListSerializer(
+        child=serializers.CharField(
+            required=True, min_length=16, error_messages=dataset_id_error_messages
+        ),
+        help_text=(
+            "List of galaxy dataset IDs corresponding to "
+            "the first element in each paired datasets."
+        ),
+    )
+    second_elements_ids = serializers.ListSerializer(
+        child=serializers.CharField(
+            required=True, min_length=16, error_messages=dataset_id_error_messages
+        ),
+        help_text=(
+            "List of galaxy dataset IDs corresponding to "
+            "the second element in each paired datasets."
+        ),
+    )
+
+    def validate(self, attrs):
+        if (
+            len(attrs["first_elements_ids"]) != len(attrs["second_elements_ids"])
+            or len(attrs["first_elements_ids"]) != len(attrs["pairs_names"])
+            or len(attrs["pairs_names"]) != len(attrs["second_elements_ids"])
+        ):
+            raise ValidationError(
+                {
+                    "lists_lengths": (
+                        "List of pairs names and list "
+                        "of elements ids must be of same length."
+                    )
+                }
+            )
+
+        return attrs
+
+
+class CollectionPairedSerializer(serializers.Serializer):
+    history_id = serializers.IntegerField(
+        required=True,
+        help_text=(
+            "Internal Django to galaxy ID of the Galaxy history"
+            " where the collection will be created."
+        ),
+    )
+    collection_name = serializers.CharField(
+        required=True, help_text="Name of the dataset collection to be created."
+    )
+    first_element_id = serializers.CharField(
+        required=True,
+        min_length=16,
+        error_messages=dataset_id_error_messages,
+        help_text="Galaxy dataset IDs corresponding to the first element of the paired dataset.",
+    )
+    second_element_id = serializers.CharField(
+        required=True,
+        min_length=16,
+        error_messages=dataset_id_error_messages,
+        help_text="Galaxy dataset IDs corresponding to the second element of the paired dataset.",
+    )

django_to_galaxy/api/serializers/create_history.py

@@ -0,0 +1,6 @@
+from rest_framework import serializers
+
+
+class HistoryCreatedSerializer(serializers.Serializer):
+    message = serializers.CharField()
+    history_id = serializers.IntegerField()

django_to_galaxy/api/serializers/invocation.py

@@ -15,3 +15,8 @@ class InvocationSerializer(serializers.ModelSerializer):
             "history",
             "create_time",
         ]
+
+
+class UpdateOutputFilesResponseSerializer(serializers.Serializer):
+    message = serializers.CharField()
+    galaxy_output_file_ids = serializers.ListField(child=serializers.IntegerField())

django_to_galaxy/api/serializers/invoke_workflow.py

@@ -18,3 +18,7 @@ class ExecuteWorkflowSerializer(serializers.Serializer):
     workflow_id = serializers.IntegerField()
     galaxy_user_id = serializers.IntegerField()
     fake_datamap = serializers.DictField(child=FileSerializer())
+
+
+class GenericDictSerializer(serializers.Serializer):
+    data = serializers.DictField()

django_to_galaxy/api/serializers/workflow.py

@@ -28,8 +28,14 @@ class WorkflowSerializer(serializers.ModelSerializer):
         return [
             {
                 "galaxy_step_id": input.galaxy_step_id,
+                "label": input.label,
+                "input_type": input.input_type,
                 "formats": [format.format for format in input.formats.all()],
+                "parameter_type": input.parameter_type,
+                "collection_type": input.collection_type,
                 "optional": input.optional,
+                "default_value": input.default_value,
+                "multiple": input.multiple,
             }
             for input in obj.workflowinput_set.all()
         ]

django_to_galaxy/api/urls.py

@@ -15,8 +15,14 @@ from django_to_galaxy.api.views.upload_to_history import UploadToHistoryView
 from django_to_galaxy.api.views.invoke_workflow import (
     InvokeWorkflowView,
     GetWorkflowDatamapTemplateView,
+    # GetWorkflowInputsView,
     ExecuteWorkflowView,
 )
+from django_to_galaxy.api.views.create_dataset_collection import (
+    CreateDatasetListCollectionView,
+    CreateDatasetListPairedCollectionView,
+    CreateDatasetPairedCollectionView,
+)
 
 api_router = routers.DefaultRouter()
 api_router.register(r"instances", GalaxyInstanceViewSet)
@@ -33,6 +39,15 @@ urlpatterns = [
     path("execute_workflow/", ExecuteWorkflowView.as_view()),
     path("update_galaxy_output_files/<int:pk>", UpdateOutputFilesView.as_view()),
     path("get_datamap_template/<int:pk>", GetWorkflowDatamapTemplateView.as_view()),
+    path(
+        "create_dataset_collection_paired/", CreateDatasetPairedCollectionView.as_view()
+    ),
+    path("create_dataset_collection_list/", CreateDatasetListCollectionView.as_view()),
+    path(
+        "create_dataset_collection_list_paired/",
+        CreateDatasetListPairedCollectionView.as_view(),
+    ),
+    # path("get_workflow_inputs/<int:pk>", GetWorkflowInputsView.as_view()),
 ]
 
 urlpatterns += api_router.urls