Merge pull request #15 from illusional/add-array-types

Adds CommandInputArraySchema and can check array types

Author: mr-c

cwlgen/__init__.py

@@ -13,7 +13,7 @@
 from .version import __version__
 
 from .utils import literal, literal_presenter
-from .elements import Parameter, CWL_VERSIONS, DEF_VERSION, CWL_SHEBANG
+from .elements import Parameter, CommandInputArraySchema, CWL_VERSIONS, DEF_VERSION, CWL_SHEBANG
 from .workflow import Workflow, File
 from .import_cwl import parse_cwl
 

cwlgen/elements.py

@@ -22,8 +22,9 @@ def parse_param_type(param_type):
     Parses the parameter type as one of the required types:
     :: https://www.commonwl.org/v1.0/CommandLineTool.html#CommandInputParameter
 
-
-    :param param_type:
+    :param param_type: a CWL type that is _validated_
+    :type param_type: CWLType | CommandInputRecordSchema | CommandInputEnumSchema | CommandInputArraySchema | string |
+       array<CWLType | CommandInputRecordSchema | CommandInputEnumSchema | CommandInputArraySchema | string>
     :return: CWLType | CommandInputRecordSchema | CommandInputEnumSchema | CommandInputArraySchema | string |
        array<CWLType | CommandInputRecordSchema | CommandInputEnumSchema | CommandInputArraySchema | string>
     """
@@ -34,12 +35,25 @@ def parse_param_type(param_type):
         if optional:
             _LOGGER.debug("Detected {param_type} to be optional".format(param_type=param_type))
         cwltype = param_type[:-1] if optional else param_type
+
+        # check for arrays
+        if len(cwltype) > 2 and cwltype[-2:] == "[]":
+            array_type = CommandInputArraySchema(items=cwltype[:-2])
+            # How to make arrays optional input: https://www.biostars.org/p/233562/#234089
+            return [DEF_TYPE, array_type] if optional else array_type
+
         if cwltype not in CWL_TYPE:
             _LOGGER.warning("The type '{param_type}' is not a valid CWLType, expected one of: {types}"
                             .format(param_type=param_type, types=", ".join(str(x) for x in CWL_TYPE)))
             _LOGGER.warning("type is set to {}.".format(DEF_TYPE))
             return DEF_TYPE
         return param_type
+
+    elif isinstance(param_type, list):
+        return [parse_param_type(p) for p in param_type]
+
+    elif isinstance(param_type, CommandInputArraySchema):
+        return param_type   # validate if required
     else:
         _LOGGER.warning("Unable to detect type of param '{param_type}".format(param_type=param_type))
         return DEF_TYPE
@@ -85,12 +99,54 @@ def get_dict(self):
         :return: dictionnary of the object
         :rtype: DICT
         '''
-        dict_param = {k: v for k, v in vars(self).items() if v is not None and v is not False}
-        if dict_param['type'] != 'File':
-            # Remove what is only for File
-            for key in ['format', 'secondaryFiles', 'streamable']:
-                try:
-                    del(dict_param[key])
-                except KeyError:
-                    pass
+        manual = ["type"]
+        dict_param = {k: v for k, v in vars(self).items() if v is not None and v is not False and k not in manual}
+
+        should_have_file_related_keys = False
+
+        if isinstance(self.type, str):
+            dict_param["type"] = self.type
+            should_have_file_related_keys = self.type == "File"
+
+        elif isinstance(self.type, CommandInputArraySchema):
+            dict_param["type"] = self.type.get_dict()
+            should_have_file_related_keys = self.type.type == "File"
+
+        keys_to_remove = [k for k in ['format', 'secondaryFiles', 'streamable'] if k in dict_param]
+
+        if not should_have_file_related_keys:
+            for key in keys_to_remove:
+                del(dict_param[key])
         return dict_param
+
+
+class CommandInputArraySchema(object):
+    '''
+    Based on the parameter set out in the CWL spec:
+    https://www.commonwl.org/v1.0/CommandLineTool.html#CommandInputArraySchema
+    '''
+
+    def __init__(self, items=None, label=None, input_binding=None):
+        '''
+        :param items: Defines the type of the array elements.
+        :type: `CWLType | CommandInputRecordSchema | CommandInputEnumSchema | CommandInputArraySchema | string | array<CWLType | CommandInputRecordSchema | CommandInputEnumSchema | CommandInputArraySchema | string>`
+        :param label: A short, human-readable label of this object.
+        :type label: STRING
+        :param input_binding:
+        :type input_binding: CommandLineBinding
+        '''
+        self.type = "array"
+        self.items = parse_param_type(items)
+        self.label = label
+        self.inputBinding = input_binding
+
+    def get_dict(self):
+        '''
+        Transform the object to a [DICT] to write CWL.
+
+        :return: dictionnary of the object
+        :rtype: DICT
+        '''
+        dict_binding = {k: v for k, v in vars(self).items() if v is not None}
+        return dict_binding
+

doc/source/classes.rst

@@ -94,6 +94,15 @@ CommandOutputBinding
     :special-members:
     :exclude-members: __weakref__
 
+CommandInputArraySchema
+"""""""""""""""""""""""
+
+.. autoclass:: cwlgen.CommandInputArraySchema
+    :members:
+    :private-members:
+    :special-members:
+    :exclude-members: __weakref__
+
 .. _requirements:
 
 Requirements
@@ -137,7 +146,7 @@ CWLToolParser
     :private-members:
     :special-members:
     :exclude-members: __weakref_
-_
+
 InputsParser
 """"""""""""
 

test/test_unit_cwlgen.py

@@ -80,6 +80,10 @@ def setUp(self):
         self.param = cwlgen.Parameter('an_id', param_type='File', label='a_label',\
                                      doc='a_doc', param_format='a_format',\
                                      streamable=True, secondary_files='sec_files')
+        self.nonfile_param = cwlgen.Parameter('non-file', param_type="string", label="a string",
+                                              streamable=True, secondary_files=[".txt"], doc="documentation here")
+
+        self.array_param = cwlgen.Parameter('an array', param_type='string[]', label="an array of strings")
 
     def test_init(self):
         self.assertEqual(self.param.id, 'an_id')
@@ -99,6 +103,21 @@ def test_get_dict(self):
         self.assertEqual(dict_test['secondaryFiles'], 'sec_files')
         self.assertTrue(dict_test['streamable'])
 
+    def test_nonfile_get_dict(self):
+        dict_test = self.nonfile_param.get_dict()
+        self.assertEqual(dict_test['type'], 'string')
+        self.assertEqual(dict_test['doc'], self.nonfile_param.doc)
+        self.assertNotIn('secondaryFiles', dict_test)
+        self.assertNotIn('streamable', dict_test)
+        self.assertNotIn('format', dict_test)
+
+    def test_array(self):
+        dict_test = self.array_param.get_dict()
+        td = dict_test['type']
+        self.assertIsInstance(td, dict)
+        self.assertEqual(td['type'], 'array')
+        self.assertEqual(td['items'], self.array_param.type.items)
+
 
 class TestCommandInputParameter(unittest.TestCase):
 

test/test_unit_typing.py

@@ -1,5 +1,5 @@
 import unittest
-from cwlgen.elements import parse_param_type, NON_NULL_CWL_TYPE, CWL_TYPE, DEF_TYPE
+from cwlgen.elements import parse_param_type, NON_NULL_CWL_TYPE, CWL_TYPE, DEF_TYPE, CommandInputArraySchema
 import logging
 
 
@@ -10,12 +10,53 @@ def test_types(self):
             self.assertEqual(parse_param_type(cwl_type), cwl_type)
 
     def test_incorrect_type(self):
-        for cwl_type in NON_NULL_CWL_TYPE:
-            should_be_def_type = parse_param_type(cwl_type.upper())
-            self.assertNotEqual(should_be_def_type, cwl_type)
-            self.assertEqual(should_be_def_type, DEF_TYPE)
+        invalid_type = "invalid"
+        should_be_def_type = parse_param_type(invalid_type)
+        self.assertNotEqual(should_be_def_type, invalid_type)
+        self.assertEqual(should_be_def_type, DEF_TYPE)
 
     def test_optional_string(self):
         for cwl_type in NON_NULL_CWL_TYPE:
             optional_type = cwl_type + "?"
             self.assertEqual(parse_param_type(optional_type), optional_type)
+
+    def test_typed_array(self):
+        array_string_type = "string[]"
+        q = parse_param_type(array_string_type)
+        self.assertIsInstance(q, CommandInputArraySchema)
+        self.assertEqual(q.items, "string")
+
+    def test_incorrectly_typed_array(self):
+        array_string_type = "invalid[]"
+        q = parse_param_type(array_string_type)
+        self.assertIsInstance(q, CommandInputArraySchema)
+        self.assertNotEqual(q.items, "invalid")
+        self.assertEqual(q.items, DEF_TYPE)
+
+    def test_optionally_typed_array(self):
+        array_string_type = "string?[]"
+        q = parse_param_type(array_string_type)
+        self.assertIsInstance(q, CommandInputArraySchema)
+        self.assertEqual(q.items, "string?")
+
+    def test_optional_typed_array(self):
+        optional_array_string_type = "string[]?"
+        q = parse_param_type(optional_array_string_type)
+        self.assertIsInstance(q, list)
+        self.assertEqual(len(q), 2)
+        null_idx = q.index(DEF_TYPE)
+        array_type = q[1 - null_idx]
+        self.assertIsInstance(array_type, CommandInputArraySchema)
+        self.assertEqual(array_type.items, "string")
+
+    def test_command_input_array_schema(self):
+        ar = CommandInputArraySchema(items="string")
+        self.assertIsInstance(ar, CommandInputArraySchema)
+        self.assertEqual(parse_param_type(ar), ar)
+        self.assertEqual(ar.items, "string")
+
+    def test_optional_type_input_array_schema(self):
+        ar = CommandInputArraySchema(items="string?")
+        self.assertIsInstance(ar, CommandInputArraySchema)
+        self.assertEqual(parse_param_type(ar), ar)
+        self.assertEqual(ar.items, "string?")