django-to-galaxy 0.7.0.0__py3-none-any.whl

django_to_galaxy/admin/workflow.py

@@ -0,0 +1,131 @@
+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 (
+    Format,
+    WorkflowInput,
+    WorkflowInputTextOption,
+)
+
+from .galaxy_element import GalaxyElementAdmin
+
+
+@admin.register(Workflow)
+class WorkflowAdmin(GalaxyElementAdmin):
+    list_display = (
+        "id",
+        "name",
+        "annotation",
+        "galaxy_id",
+        "get_is_meta",
+        "get_step_count",
+        "published",
+        "galaxy_owner",
+        "get_tags",
+    )
+    readonly_fields = (
+        "id",
+        "name",
+        "annotation",
+        "galaxy_id",
+        "get_is_meta",
+        "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_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):
+    list_display = (
+        "id",
+        "format",
+    )
+    readonly_fields = (
+        "id",
+        "format",
+    )
+
+
+@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",
+        "galaxy_step_id",
+        "label",
+        "workflow",
+        "get_formats",
+        "parameter_type",
+        "collection_type",
+        "optional",
+        "default_value",
+        "multiple",
+    )
+
+    def get_formats(self, obj):
+        return ", ".join([p.format for p in obj.formats.all()])

django_to_galaxy/api/serializers/asymetricslugrelatedfield.py

@@ -0,0 +1,31 @@
+from collections import OrderedDict
+
+from rest_framework.relations import SlugRelatedField
+
+
+class AsymetricSlugRelatedField(SlugRelatedField):
+    def to_representation(self, value):
+        return self.serializer_class(value).data
+
+    # Get choices used by DRF autodoc and expect to_representation() to return an ID
+    # We overload to use item.pk instead of to_representation()
+    def get_choices(self, cutoff=None):
+        queryset = self.get_queryset()
+        if queryset is None:
+            return {}
+
+        if cutoff is not None:
+            queryset = queryset[:cutoff]
+
+        return OrderedDict([(item.pk, self.display_value(item)) for item in queryset])
+
+    # DRF skip validations  when it only has id, we deactivate that
+    def use_pk_only_optimization(self):
+        return False
+
+    @classmethod
+    def from_serializer(cls, serializer, name=None, *args, **kwargs):
+        if name is None:
+            name = f"{serializer.__class__.__name__}AsymetricSlugAutoField"
+
+        return type(name, (cls,), {"serializer_class": serializer})(*args, **kwargs)

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/galaxy_instance.py

@@ -0,0 +1,10 @@
+from rest_framework import serializers
+
+
+from django_to_galaxy.models.galaxy_instance import GalaxyInstance
+
+
+class GalaxyInstanceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = GalaxyInstance
+        fields = ["id", "url", "name"]

django_to_galaxy/api/serializers/galaxy_output_file.py

@@ -0,0 +1,17 @@
+from rest_framework import serializers
+
+from django_to_galaxy.models.galaxy_output_file import GalaxyOutputFile
+
+
+class GalaxyOutputFileSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = GalaxyOutputFile
+        fields = [
+            "id",
+            "galaxy_id",
+            "workflow_name",
+            "galaxy_state",
+            "history_name",
+            "src",
+            "invocation",
+        ]

django_to_galaxy/api/serializers/galaxy_user.py

@@ -0,0 +1,20 @@
+from rest_framework import serializers
+
+from django_to_galaxy.api.serializers.galaxy_instance import GalaxyInstanceSerializer
+from django_to_galaxy.models.galaxy_user import GalaxyUser
+from django_to_galaxy.models.galaxy_instance import GalaxyInstance
+
+from .asymetricslugrelatedfield import AsymetricSlugRelatedField
+
+
+class GalaxyUserSerializer(serializers.ModelSerializer):
+    galaxy_instance = AsymetricSlugRelatedField.from_serializer(
+        GalaxyInstanceSerializer,
+        queryset=GalaxyInstance.objects.all(),
+        slug_field="id",
+        required=False,
+    )
+
+    class Meta:
+        model = GalaxyUser
+        fields = ["id", "email", "galaxy_instance"]

django_to_galaxy/api/serializers/history.py

@@ -0,0 +1,17 @@
+from rest_framework import serializers
+
+from django_to_galaxy.models.history import History
+
+
+class HistorySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = History
+        fields = [
+            "id",
+            "galaxy_id",
+            "name",
+            "annotation",
+            "published",
+            "galaxy_owner",
+            "galaxy_state",
+        ]

django_to_galaxy/api/serializers/invocation.py

@@ -0,0 +1,22 @@
+from rest_framework import serializers
+
+from django_to_galaxy.models.invocation import Invocation
+
+
+class InvocationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Invocation
+        fields = [
+            "id",
+            "galaxy_id",
+            "galaxy_state",
+            "status",
+            "workflow",
+            "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

@@ -0,0 +1,24 @@
+from rest_framework import serializers
+
+from .upload_to_history import FileSerializer
+
+
+class DatamapSerializer(serializers.Serializer):
+    id = serializers.CharField(required=False, default="")
+    src = serializers.CharField()
+
+
+class InvokeWorkflowSerializer(serializers.Serializer):
+    workflow_id = serializers.IntegerField()
+    history_id = serializers.IntegerField()
+    datamap = serializers.DictField(child=DatamapSerializer())
+
+
+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/upload_to_history.py

@@ -0,0 +1,25 @@
+import django.apps
+from django.core.exceptions import ValidationError
+from rest_framework import serializers
+
+
+class FileSerializer(serializers.Serializer):
+    model = serializers.CharField()
+    path_field = serializers.CharField()
+    file_type = serializers.CharField()
+    id = serializers.IntegerField()
+
+    def validate(self, attrs):
+        old_attrs = attrs.copy()
+        for key, value in old_attrs.items():
+            if key == "model":
+                all_models = django.apps.apps.get_models()
+                all_models_dict = {m.__name__.lower(): m for m in all_models}
+                if value not in all_models_dict.keys():
+                    raise ValidationError(f"model <{value}> does not exist on the app.")
+        return attrs
+
+
+class UploadHistorySerializer(serializers.Serializer):
+    history_id = serializers.IntegerField()
+    file = FileSerializer()

django_to_galaxy/api/serializers/workflow.py

@@ -0,0 +1,41 @@
+from rest_framework import serializers
+
+from django_to_galaxy.models.workflow import Workflow
+
+
+class WorkflowSerializer(serializers.ModelSerializer):
+    tags = serializers.SerializerMethodField()
+    workflowinputs = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Workflow
+        fields = [
+            "id",
+            "galaxy_id",
+            "name",
+            "annotation",
+            "tags",
+            "published",
+            "galaxy_owner",
+            "workflowinputs",
+        ]
+        read_only_fields = ["tags", "workflowinputs"]
+
+    def get_tags(self, obj):
+        return [tag.label for tag in obj.tags.all()]
+
+    def get_workflowinputs(self, obj):
+        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

@@ -0,0 +1,53 @@
+from django.urls import path
+from rest_framework import routers
+
+from django_to_galaxy.api.views.create_history import CreateHistoryView
+from django_to_galaxy.api.views.galaxy_instance import GalaxyInstanceViewSet
+from django_to_galaxy.api.views.galaxy_output_file import GalaxyOutputFileViewSet
+from django_to_galaxy.api.views.galaxy_user import GalaxyUserViewSet
+from django_to_galaxy.api.views.history import HistoryViewSet
+from django_to_galaxy.api.views.invocation import (
+    InvocationViewSet,
+    UpdateOutputFilesView,
+)
+from django_to_galaxy.api.views.workflow import WorkflowViewSet
+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)
+api_router.register(r"galaxy_output_files", GalaxyOutputFileViewSet)
+api_router.register(r"galaxy_users", GalaxyUserViewSet)
+api_router.register(r"histories", HistoryViewSet)
+api_router.register(r"invocations", InvocationViewSet)
+api_router.register(r"workflows", WorkflowViewSet)
+
+urlpatterns = [
+    path("create_history/<int:pk>", CreateHistoryView.as_view()),
+    path("upload_to_history/", UploadToHistoryView.as_view()),
+    path("invoke_workflow/", InvokeWorkflowView.as_view()),
+    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