Scottx611x/td api

refinery/tool_manager/management/commands/generate_tool_definitions.py

@@ -3,12 +3,10 @@
 
 from django.core.management.base import BaseCommand, CommandError
 
-from bioblend.galaxy.client import ConnectionError
-
-from core.models import WorkflowEngine
 from tool_manager.models import ToolDefinition
 from ...utils import (ANNOTATION_ERROR_MESSAGE,
                       create_tool_definition,
+                      get_workflow_list,
                       validate_tool_annotation,
                       validate_workflow_step_annotation)
 
@@ -27,138 +25,108 @@ def handle(self, **options):
         Workflows.
         """
         sys.stdout.write("Generating ToolDefinitions\n")
-        workflow_engines = WorkflowEngine.objects.all()
-        sys.stdout.write("{} workflow engines found.\n".format(
-            workflow_engines.count())
-        )
 
-        for engine in workflow_engines:
-            sys.stdout.write(
-                "Generating ToolDefinitions from workflow engine {}\n"
-                .format(engine.name)
-            )
+        workflow_list = get_workflow_list()
+
+        # Validate workflow annotation data, and try to create a
+        # ToolDefinition if validation passes.
 
-            galaxy_connection = engine.instance.galaxy_connection()
+        for workflow in workflow_list:
+            workflow["tool_type"] = ToolDefinition.WORKFLOW
             try:
-                workflow_list = galaxy_connection.workflows.get_workflows()
-            except ConnectionError as e:
+                workflow["annotation"] = json.loads(
+                    workflow["annotation"]
+                )
+            except ValueError as e:
                 raise CommandError(
-                    "Unable to retrieve workflows from '{}'. "
-                    "Skipping ToolDefinition generation: {}".format(
-                        engine.instance.base_url, e)
+                    "Workflow: {}'s annotation is not "
+                    "valid JSON: {}".format(workflow["name"], e)
                 )
 
-            # Validate workflow annotation data, and try to create a
-            # ToolDefinition if validation passes.
+            # Include `parameters` and `output_files` as keys in our
+            # workflow annotation
+            workflow["annotation"]["parameters"] = []
+            workflow["annotation"]["output_files"] = []
 
-            for workflow in workflow_list:
-                workflow_data = galaxy_connection.workflows.show_workflow(
-                    workflow["id"]
-                )
-                workflow_data["tool_type"] = ToolDefinition.WORKFLOW
-                try:
-                    workflow_data["annotation"] = json.loads(
-                        workflow_data["annotation"]
-                    )
-                except ValueError as e:
-                    raise CommandError(
-                        "Workflow: {}'s annotation is not "
-                        "valid JSON: {}".format(workflow_data["name"], e)
-                    )
-
-                # Include `parameters` and `output_files` as keys in our
-                # workflow annotation
-                workflow_data["annotation"]["parameters"] = []
-                workflow_data["annotation"]["output_files"] = []
+            # Iterate through the workflow's step's annotations and
+            # append to the `parameters` and `output_files` lists from
+            # above so they are included in the validation of this
+            # workflow's annotation data
+            for step_index in workflow["steps"]:
+                step = workflow["steps"][step_index]
 
-                # Iterate through the workflow's step's annotations and
-                # append to the `parameters` and `output_files` lists from
-                # above so they are included in the validation of this
-                # workflow's annotation data
-                for step_index in workflow_data["steps"]:
-                    step = workflow_data["steps"][step_index]
-                    # Check if any annotation provided, and try to convert
-                    # to python dict if so
-                    if step["annotation"]:
-                        try:
-                            step_annotation = json.loads(step["annotation"])
-                        except ValueError as e:
-                            raise CommandError(
-                                "Workflow: {}'s Step: {}'s annotation data"
-                                " is not valid JSON: {}".format(
-                                    workflow_data["name"], step_index, e
-                                )
+                if step["annotation"]:
+                    try:
+                        step_annotation = json.loads(step["annotation"])
+                    except ValueError as e:
+                        raise CommandError(
+                            "Workflow: {}'s Step: {}'s annotation data"
+                            " is not valid JSON: {}".format(
+                                workflow["name"],
+                                step_index,
+                                e
                             )
-                        try:
-                            validate_workflow_step_annotation(
-                                step_annotation
+                        )
+                    try:
+                        validate_workflow_step_annotation(
+                            step_annotation
+                        )
+                    except RuntimeError as e:
+                        raise CommandError(
+                            "{} {}".format(ANNOTATION_ERROR_MESSAGE, e)
                             )
-                        except RuntimeError as e:
+                    try:
+                        parameters = step_annotation["parameters"]
+                    except KeyError:
+                        # `parameters` aren't required for each workflow step
+                        pass
+
+                    for parameter in parameters:
+                        # Check User-defined parameters in
+                        # annotation data against the available
+                        # parameters of the Workflow step's
+                        # `tool_inputs`
+                        if parameter["name"] not in step["tool_inputs"]:
                             raise CommandError(
-                                "{} {}".format(ANNOTATION_ERROR_MESSAGE, e)
+                                "{} is not a valid parameter for {}".
+                                format(
+                                    parameter["name"],
+                                    step["tool_id"]
                                 )
-                        try:
-                            parameters = step_annotation["parameters"]
-                        except KeyError:
-                            # Since we've already validated the Workflow
-                            # step's annotation, and a Step Annotation
-                            # doesn't necessarily need to have
-                            # `parameters` we can pass here without
-                            # raising an exception
-                            pass
-                        else:
-                            for parameter in parameters:
-                                # Check User-defined parameters in
-                                # annotation data against the available
-                                # parameters of the Workflow step's
-                                # `tool_inputs`
-                                if (not parameter["name"] in
-                                        step["tool_inputs"]):
-                                    raise RuntimeError(
-                                        "{} is not a valid parameter for {}".
-                                        format(
-                                            parameter["name"],
-                                            step["tool_id"]
-                                        )
-                                    )
-                                else:
-                                    parameter["galaxy_workflow_step"] = int(
-                                        step_index
-                                    )
-                                    workflow_data["annotation"]["parameters"]\
-                                        .append(parameter)
-                        try:
-                            output_files = step_annotation["output_files"]
-                        except KeyError:
-                            # Since we've already validated the Workflow
-                            # step's annotation, and a Step Annotation
-                            # doesn't necessarily need to have
-                            # `output_files` we can pass here without
-                            # raising an exception
-                            pass
+                            )
                         else:
-                            for output_file in output_files:
-                                workflow_data["annotation"]["output_files"]\
-                                    .append(output_file)
-                try:
-                    validate_tool_annotation(workflow_data)
-                except RuntimeError as e:
-                    raise CommandError(e)
-                except Exception as e:
-                    raise CommandError(
-                        "Something unexpected happened: {}".format(e)
-                    )
-                try:
-                    create_tool_definition(workflow_data)
-                except Exception as e:
-                    raise CommandError(
-                        "Creation of ToolDefinition failed. Database "
-                        "rolled back to its state before this "
-                        "ToolDefinition's attempted creation: {}".format(e)
-                    )
-                else:
-                    sys.stdout.write(
-                        "\nGenerated ToolDefinition for: {}\n".format(
-                            workflow_data["name"]
+                            parameter["galaxy_workflow_step"] = int(
+                                step_index
+                            )
+                            workflow["annotation"]["parameters"]\
+                                .append(parameter)
+                    try:
+                        output_files = step_annotation["output_files"]
+                    except KeyError:
+                        # `ouput_files` aren't required for each workflow step
+                        pass
+
+                    for output_file in output_files:
+                        workflow["annotation"]["output_files"].append(
+                            output_file
                         )
-                    )
+            try:
+                validate_tool_annotation(workflow)
+            except RuntimeError as e:
+                raise CommandError(e)
+            except Exception as e:
+                raise CommandError(
+                    "Something unexpected happened: {}".format(e)
+                )
+            try:
+                create_tool_definition(workflow)
+            except Exception as e:
+                raise CommandError(
+                    "Creation of ToolDefinition failed. Database "
+                    "rolled back to its state before this "
+                    "ToolDefinition's attempted creation: {}".format(e)
+                )
+
+            sys.stdout.write("\nGenerated ToolDefinition for: {}\n".format(
+                    workflow["name"]
+                ))

refinery/tool_manager/models.py

@@ -146,7 +146,7 @@ def __str__(self):
 
 
 @receiver(pre_delete, sender=ToolDefinition)
-def _tooldefinition_pre_delete(sender, instance, *args, **kwargs):
+def delete_parameters_and_output_files(sender, instance, *args, **kwargs):
     """
     Delete related parameter and output_file objects upon ToolDefinition
     deletion
@@ -161,7 +161,7 @@ def _tooldefinition_pre_delete(sender, instance, *args, **kwargs):
 
 
 @receiver(post_delete, sender=ToolDefinition)
-def _tooldefinition_post_delete(sender, instance, *args, **kwargs):
+def delete_file_relationship(sender, instance, *args, **kwargs):
     """
     Delete related (topmost) FileRelationship object after ToolDefinition
     deletion.
@@ -170,7 +170,8 @@ def _tooldefinition_post_delete(sender, instance, *args, **kwargs):
 
 
 @receiver(pre_delete, sender=FileRelationship)
-def _filerelationship_pre_delete(sender, instance, *args, **kwargs):
+def delete_input_files_and_file_relationships(sender, instance, *args,
+                                              **kwargs):
     """
     Delete all related nested file_relationships in a recursive manner.
 

refinery/tool_manager/schemas/FileRelationship.json

@@ -26,7 +26,7 @@
     },
     "file_relationship": {
       "oneOf": [
-          {"$ref": "FileRelationship.json#"},
+          {"type": "object", "$ref": "FileRelationship.json#"},
           {"type": "object", "additionalProperties": false, "properties": {}}
         ]
       }

refinery/tool_manager/schemas/OutputFile.json

@@ -13,7 +13,7 @@
     "description": {
       "type": "string"
     },
-    "file_type": {
+    "filetype": {
       "type": "object",
       "$ref": "FileType.json#"
     }

refinery/tool_manager/serializers.py

@@ -14,7 +14,8 @@ class Meta:
 
 class ParameterSerializer(serializers.ModelSerializer):
     galaxy_workflow_step = serializers.SerializerMethodField(
-        method_name="_get_galaxy_workflow_step", required=False,
+        method_name="_get_galaxy_workflow_step",
+        required=False,
         allow_null=False
     )
 
@@ -49,8 +50,11 @@ class Meta:
 class FileRelationshipSerializer(serializers.ModelSerializer):
     # RecursiveField allows for the exposure of all self-referential nested
     # ManyToMany relations in the serialized response data
-    file_relationship = RecursiveField(required=False, allow_null=True,
-                                       many=True)
+    file_relationship = RecursiveField(
+        required=False,
+        allow_null=True,
+        many=True
+    )
     input_files = InputFileSerializer(many=True)
 
     class Meta: