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

django_to_galaxy/__init__.py

@@ -0,0 +1 @@
+from .version import __version__  # noqa

django_to_galaxy/admin/__init__.py

@@ -0,0 +1,13 @@
+from .galaxy_instance import GalaxyInstanceAdmin  # noqa
+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 (  # noqa
+    WorkflowAdmin,  # noqa
+    WorkflowInputAdmin,  # noqa
+    FormatAdmin,  # noqa
+    WorkflowInputTextOptionAdmin,  # noqa
+)  # noqa
+from .tag import TagAdmin  # noqa
+from .utils import *  # noqa

django_to_galaxy/admin/galaxy_element.py

@@ -0,0 +1,6 @@
+from django.contrib import admin
+
+
+class GalaxyElementAdmin(admin.ModelAdmin):
+    def has_add_permission(self, *args, **kwargs) -> bool:
+        return False

django_to_galaxy/admin/galaxy_instance.py

@@ -0,0 +1,26 @@
+from django.contrib import admin
+from django.urls import reverse
+from django.utils.html import format_html
+from django.utils.http import urlencode
+
+from django_to_galaxy.models.galaxy_instance import GalaxyInstance
+
+
+@admin.register(GalaxyInstance)
+class GalaxyInstanceAdmin(admin.ModelAdmin):
+    list_display = ("url", "name", "get_registered_users", "is_online")
+
+    def get_registered_users(self, obj):
+        count = obj.users.count()
+        url = (
+            reverse("admin:django_to_galaxy_galaxyuser_changelist")
+            + "?"
+            + urlencode({"galaxy_instance__id": f"{obj.id}"})
+        )
+        return format_html('<a href="{}">{}</a>', url, count)
+
+    def is_online(self, obj):
+        return obj.is_online()
+
+    get_registered_users.short_description = "Registered users"
+    is_online.boolean = True

django_to_galaxy/admin/galaxy_output_file.py

@@ -0,0 +1,79 @@
+from typing import List
+
+from django.contrib import admin, messages
+from django.utils.translation import ngettext
+
+from django_to_galaxy.models.galaxy_output_file import GalaxyOutputFile
+
+from .galaxy_element import GalaxyElementAdmin
+
+
+@admin.register(GalaxyOutputFile)
+class GalaxyOutputFileAdmin(GalaxyElementAdmin):
+    list_display = (
+        "id",
+        "galaxy_id",
+        "workflow_name",
+        "history_name",
+        "galaxy_state",
+        "src",
+        "invocation",
+    )
+    readonly_fields = (
+        "id",
+        "galaxy_id",
+        "workflow_name",
+        "history_name",
+        "galaxy_state",
+        "src",
+        "invocation",
+    )
+    actions = ["synchronize_file"]
+
+    def _get_message_output_file_synchronize(
+        self,
+        request,
+        output_files: List[GalaxyOutputFile],
+        message_singular: str,
+        message_plural: str,
+        message_type: int,
+    ):
+        count = len(output_files)
+        details = ", ".join([f"{i}" for i in output_files])
+        self.message_user(
+            request,
+            ngettext(
+                f"%d {message_singular} [{details}].",
+                f"%d {message_plural} [{details}].",
+                count,
+            )
+            % count,
+            message_type,
+        )
+
+    @admin.action(description="Synchronize data from Galaxy")
+    def synchronize_file(self, request, queryset):
+        sync_output_files = []
+        error_output_files = []
+        for output_file in queryset:
+            try:
+                output_file.synchronize()
+                sync_output_files.append(output_file)
+            except:  # noqa
+                error_output_files.append(output_file)
+        if sync_output_files:
+            self._get_message_output_file_synchronize(
+                request,
+                sync_output_files,
+                "output_file was successfully synchronized",
+                "output_files were successfully synchronized",
+                messages.SUCCESS,
+            )
+        if error_output_files:
+            self._get_message_output_file_synchronize(
+                request,
+                error_output_files,
+                "output_file could not be synchronized",
+                "output_files could not be synchronized",
+                messages.ERROR,
+            )

django_to_galaxy/admin/galaxy_user.py

@@ -0,0 +1,183 @@
+from typing import List
+
+from django.contrib import admin, messages
+from django.http import HttpResponseRedirect
+from django.shortcuts import render
+from django.urls import reverse
+from django.utils.html import format_html
+from django.utils.http import urlencode
+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.admin.utils import update_workflowinputs
+
+
+@admin.register(GalaxyUser)
+class GalaxyUserAdmin(admin.ModelAdmin):
+    list_display = (
+        "id",
+        "email",
+        "hide_api_key",
+        "galaxy_instance",
+        "get_number_histories",
+        "get_number_workflows",
+    )
+    list_filter = ("galaxy_instance",)
+    actions = ["create_history", "import_workflows"]
+
+    def get_urls(self):
+        from django.urls import path
+
+        return [
+            path(
+                "<path:object_id>/import_workflows/",
+                self._import_workflows_view,
+                name="Import workflow",
+            ),
+        ] + super().get_urls()
+
+    def hide_api_key(self, obj):
+        api_key = obj.api_key
+        return api_key.replace(api_key[4:-4], len(api_key[4:-4]) * "*")
+
+    def get_number_histories(self, obj):
+        count = obj.histories.count()
+        url = (
+            reverse("admin:django_to_galaxy_history_changelist")
+            + "?"
+            + urlencode({"galaxy_owner__id": f"{obj.id}"})
+        )
+        return format_html('<a href="{}">{}</a>', url, count)
+
+    def get_number_workflows(self, obj):
+        count = obj.workflows.count()
+        url = (
+            reverse("admin:django_to_galaxy_workflow_changelist")
+            + "?"
+            + urlencode({"galaxy_owner__id": f"{obj.id}"})
+        )
+        return format_html('<a href="{}">{}</a>', url, count)
+
+    def _get_message_history_creation(
+        self,
+        request,
+        users: List[GalaxyUser],
+        message_singular: str,
+        message_plural: str,
+        message_type: int,
+    ):
+        count = len(users)
+        details = ", ".join([f"{u.email}->{u.galaxy_instance.url}" for u in users])
+        self.message_user(
+            request,
+            ngettext(
+                f"%d {message_singular} ({details}).",
+                f"%d {message_plural} ({details}).",
+                count,
+            )
+            % count,
+            message_type,
+        )
+
+    @admin.action(description="Create history")
+    def create_history(self, request, queryset):
+        created_users = []
+        skipped_users = []
+        for user in queryset:
+            try:
+                user.create_history()
+                created_users.append(user)
+            except:  # noqa
+                skipped_users.append(user)
+        if created_users:
+            self._get_message_history_creation(
+                request,
+                created_users,
+                "history was successfully created",
+                "histories were successfully created",
+                messages.SUCCESS,
+            )
+        if skipped_users:
+            self._get_message_history_creation(
+                request,
+                skipped_users,
+                "history could not be created",
+                "histories could not be created",
+                messages.ERROR,
+            )
+
+    @admin.action(description="Import workflow(s) (1 user only)")
+    def import_workflows(self, request, queryset):
+        if queryset.count() > 1:
+            self.message_user(
+                request,
+                "You can import workflow from 1 user only at a time.",
+                messages.ERROR,
+            )
+            return
+        user = queryset[0]
+        if not user.galaxy_instance.is_online():
+            self.message_user(
+                request,
+                (
+                    f"{user.galaxy_instance} is currently not available."
+                    " Please try later or contact its administrator(s)."
+                ),
+                messages.ERROR,
+            )
+            return None
+        return HttpResponseRedirect(f"{user.id}/import_workflows/")
+
+    def _import_workflows_view(self, request, object_id):
+        galaxy_user = GalaxyUser.objects.prefetch_related("workflows").get(id=object_id)
+        existing_workflows = list(galaxy_user.workflows.all())
+        existing_galaxy_ids = tuple(wf.galaxy_id for wf in existing_workflows)
+        new_workflows = []
+        for galaxy_wf, tags in galaxy_user.available_workflows:
+            if galaxy_wf.galaxy_id not in existing_galaxy_ids:
+                new_workflows.append((galaxy_wf, tags))
+        if request.method == "POST":
+            galaxy_id_to_save = tuple(request.POST.getlist("save_to_app"))
+            for wf, tags in new_workflows:
+                id_tags = []
+                for tag in tags:
+                    savedtag, created = Tag.objects.get_or_create(label=tag)
+                    id_tags.append(savedtag.id)
+                if wf.galaxy_id in galaxy_id_to_save:
+                    wf.save()
+                    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,
+            existing_workflows=existing_workflows,
+            new_workflows=new_workflows,
+        )
+        return render(
+            request,
+            "admin/import_workflows.html",
+            context=context,
+        )
+
+    hide_api_key.short_description = "API Key"
+    get_number_histories.short_description = "Histories"
+    get_number_workflows.short_description = "Workflows"

django_to_galaxy/admin/history.py

@@ -0,0 +1,91 @@
+from typing import List
+
+from django.contrib import admin, messages
+from django.utils.translation import ngettext
+
+from django_to_galaxy.models.history import History
+
+from .galaxy_element import GalaxyElementAdmin
+
+
+@admin.register(History)
+class HistoryAdmin(GalaxyElementAdmin):
+    list_display = (
+        "id",
+        "name",
+        "annotation",
+        "galaxy_id",
+        "published",
+        "galaxy_owner",
+        "tags",
+        "galaxy_state",
+        "create_time",
+    )
+    readonly_fields = (
+        "id",
+        "name",
+        "annotation",
+        "galaxy_id",
+        "published",
+        "galaxy_owner",
+        "tags",
+        "galaxy_state",
+        "create_time",
+    )
+    actions = ["synchronize_history"]
+
+    def tags(self, obj):
+        return ", ".join([p.label for p in obj.tags.all()])
+
+    def delete_queryset(self, request, queryset):
+        """Might be slow when dealing with lot of items."""
+        for item in queryset:
+            item.delete()
+
+    def _get_message_history_synchronize(
+        self,
+        request,
+        histories: List[History],
+        message_singular: str,
+        message_plural: str,
+        message_type: int,
+    ):
+        count = len(histories)
+        details = ", ".join([f"{h.galaxy_id} from {h.galaxy_owner}" for h in histories])
+        self.message_user(
+            request,
+            ngettext(
+                f"%d {message_singular} [{details}].",
+                f"%d {message_plural} [{details}].",
+                count,
+            )
+            % count,
+            message_type,
+        )
+
+    @admin.action(description="Synchronize data from Galaxy")
+    def synchronize_history(self, request, queryset):
+        sync_histories = []
+        error_histories = []
+        for history in queryset:
+            try:
+                history.synchronize()
+                sync_histories.append(history)
+            except:  # noqa
+                error_histories.append(history)
+        if sync_histories:
+            self._get_message_history_synchronize(
+                request,
+                sync_histories,
+                "history was successfully synchronized",
+                "histories were successfully synchronized",
+                messages.SUCCESS,
+            )
+        if error_histories:
+            self._get_message_history_synchronize(
+                request,
+                error_histories,
+                "history could not be synchronized",
+                "histories could not be synchronized",
+                messages.ERROR,
+            )

django_to_galaxy/admin/invocation.py

@@ -0,0 +1,154 @@
+from typing import List
+
+from django.contrib import admin, messages
+from django.utils.translation import ngettext
+from django.utils.html import format_html
+from django.utils.http import urlencode
+from django.urls import reverse
+
+from django_to_galaxy.models.invocation import Invocation
+
+from .galaxy_element import GalaxyElementAdmin
+
+
+@admin.register(Invocation)
+class InvocationAdmin(GalaxyElementAdmin):
+    list_display = (
+        "id",
+        "galaxy_id",
+        "display_percentage_done",
+        "status",
+        "workflow",
+        "history",
+        "create_time",
+        "get_number_output_files",
+    )
+    readonly_fields = (
+        "id",
+        "galaxy_id",
+        "display_percentage_done",
+        "status",
+        "workflow",
+        "history",
+        "create_time",
+    )
+    actions = ["synchronize_invocation", "update_output_files"]
+
+    @admin.display(description="Percentage Done")
+    def display_percentage_done(self, obj):
+        return format_html(
+            """
+            <progress value="{0}" max="100"></progress>
+            <span style="font-weight:bold">{0}%</span>
+            """,
+            obj.percentage_done,
+        )
+
+    def _get_message_invocation(
+        self,
+        request,
+        invocations: List[Invocation],
+        message_singular: str,
+        message_plural: str,
+        message_type: int,
+    ):
+        count = len(invocations)
+        details = ", ".join([f"{i}" for i in invocations])
+        self.message_user(
+            request,
+            ngettext(
+                f"%d {message_singular} [{details}].",
+                f"%d {message_plural} [{details}].",
+                count,
+            )
+            % count,
+            message_type,
+        )
+
+    def _get_message_output_files(
+        self,
+        request,
+        invocations: List[Invocation],
+        message_singular: str,
+        message_plural: str,
+        message_type: int,
+    ):
+        count = 0
+        for inv in invocations:
+            count += inv.output_files.count()
+        details = ", ".join([f"{i}" for i in invocations])
+        self.message_user(
+            request,
+            ngettext(
+                f"%d {message_singular} [{details}].",
+                f"%d {message_plural} [{details}].",
+                count,
+            )
+            % count,
+            message_type,
+        )
+
+    @admin.action(description="Synchronize data from Galaxy")
+    def synchronize_invocation(self, request, queryset):
+        sync_invocations = []
+        error_invocations = []
+        for invocation in queryset:
+            try:
+                invocation.synchronize()
+                sync_invocations.append(invocation)
+            except:  # noqa
+                error_invocations.append(invocation)
+        if sync_invocations:
+            self._get_message_invocation(
+                request,
+                sync_invocations,
+                "invocation was successfully synchronized",
+                "invocations were successfully synchronized",
+                messages.SUCCESS,
+            )
+        if error_invocations:
+            self._get_message_invocation(
+                request,
+                error_invocations,
+                "invocation could not be synchronized",
+                "invocations could not be synchronized",
+                messages.ERROR,
+            )
+
+    @admin.action(description="Update Output files")
+    def update_output_files(self, request, queryset):
+        updated_invocations = []
+        error_invocations = []
+        for invocation in queryset:
+            try:
+                invocation.update_output_files()
+                updated_invocations.append(invocation)
+            except:  # noqa
+                error_invocations.append(invocation)
+        if updated_invocations:
+            self._get_message_output_files(
+                request,
+                updated_invocations,
+                "output file from invocation(s) were successfully updated",
+                "output files from invocation(s) were successfully updated",
+                messages.SUCCESS,
+            )
+        if error_invocations:
+            self._get_message_output_files(
+                request,
+                error_invocations,
+                "output file from invocation(s) could not be updated",
+                "output files from invocation(s) could not be updated",
+                messages.ERROR,
+            )
+
+    def get_number_output_files(self, obj):
+        count = obj.output_files.count()
+        url = (
+            reverse("admin:django_to_galaxy_galaxyoutputfile_changelist")
+            + "?"
+            + urlencode({"invocation__id": f"{obj.id}"})
+        )
+        return format_html('<a href="{}">{}</a>', url, count)
+
+    get_number_output_files.short_description = "Output files"

django_to_galaxy/admin/tag.py

@@ -0,0 +1,17 @@
+from django.contrib import admin
+
+from django_to_galaxy.models.galaxy_element import Tag
+
+from .galaxy_element import GalaxyElementAdmin
+
+
+@admin.register(Tag)
+class TagAdmin(GalaxyElementAdmin):
+    list_display = (
+        "id",
+        "label",
+    )
+    readonly_fields = (
+        "id",
+        "label",
+    )

django_to_galaxy/admin/utils.py

@@ -0,0 +1,116 @@
+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()
+
+            # Remove existing inputs
+            WorkflowInput.objects.filter(workflow=wf).delete()
+
+            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