Added handling of parameters in module creator code

Author: tmtabor

gp/modules.py

@@ -88,27 +88,32 @@ def validate(self):
                 raise ValueError(attr + " is not set")
 
         # Validate name
-        invalid_chars = set(string.punctuation.replace("_", "").replace(".", ""))
+        invalid_chars = GPTaskSpec.invalid_chars()
         if any(char in invalid_chars for char in self.name):
             raise ValueError("module name includes invalid characters: " + self.name)
 
         # Validate LSID
         self._valid_lsid()
 
         # Validate categories
-        if not self._all_strings(self.categories):
+        if not self.all_strings(self.categories):
             raise TypeError("categories contains non-string value: " + str(self.categories))
 
         # Validate file formats
-        if not self._all_strings(self.file_format):
+        if not self.all_strings(self.file_format):
             raise TypeError("file_format contains non-string value: " + str(self.file_format))
 
         # Validate support files
-        if not self._all_strings(self.support_files):
+        if not self.all_strings(self.support_files):
             raise TypeError("support_files contains non-string value: " + str(self.support_files))
 
-        # Validate parameters
-        # TODO: Implement
+        # Validate parameter list
+        if not self._all_params(self.parameters):
+            raise TypeError("parameters contains non-GPParamSpec value: " + str(self.parameters))
+
+        # Validate individual parameters
+        for param in self.parameters:
+            param.validate()
 
         # Return that everything validates
         return True
@@ -164,7 +169,7 @@ def write_manifest(self, module_directory=""):
 
         # Write initial attributes
         manifest_file.write("JVMLevel=\n")
-        manifest_file.write("LSID=" + self._escape_colons(self.lsid) + "\n")
+        manifest_file.write("LSID=" + self.manifest_escape(self.lsid) + "\n")
         manifest_file.write("author=" + self._author_line() + "\n")
         manifest_file.write("categories=" + ';'.join(self.categories) + "\n")
         manifest_file.write("commandLine=" + self.command_line + "\n")
@@ -177,7 +182,8 @@ def write_manifest(self, module_directory=""):
         manifest_file.write("os=" + str(self.os.value) + "\n")
 
         # Write parameter attributes
-        # TODO: Implement
+        for index, param in enumerate(self.parameters):
+            manifest_file.write(param.manifest_repr(index+1))
 
         # Write footer attributes
         manifest_file.write("privacy=" + str(self.privacy.value) + "\n")
@@ -222,20 +228,26 @@ def _task_type(self):
             return ""
 
     @staticmethod
-    def _escape_colons(string):
+    def manifest_escape(string):
         """
-        Escape colon characters for inclusion in manifest file
+        Escape colon and equals characters for inclusion in manifest file
         :param string:
         :return: string
         """
-        return string.replace(':', '\:')
+        return string.replace(':', '\:').replace('=', '\=')
 
     @staticmethod
-    def _all_strings(arr):
+    def all_strings(arr):
         if not isinstance([], list):
             raise TypeError("non-list value found where list is expected")
         return all(isinstance(x, str) for x in arr)
 
+    @staticmethod
+    def _all_params(arr):
+        if not isinstance([], list):
+            raise TypeError("non-list value found for parameters")
+        return all(isinstance(x, GPParamSpec) for x in arr)
+
     def _valid_lsid(self):
         if not isinstance(self.lsid, str):
             raise TypeError("lsid is not a string, string expected: " + str(self.lsid))
@@ -245,3 +257,156 @@ def _valid_lsid(self):
 
         if self.lsid.split(':')[0].lower() != 'urn':
             raise ValueError("lsid does not begin with urn: " + str(self.lsid))
+
+    @staticmethod
+    def invalid_chars():
+        """
+        Returns a set of characters which are not valid in module or parameter names
+        :return:
+        """
+        return set(string.punctuation.replace("_", "").replace(".", "") + string.whitespace)
+
+
+class Type(Enum):
+    FILE = "FILE"
+    TEXT = "TEXT"
+    INTEGER = "Integer"
+    FLOATING_POINT = "Floating Point"
+    DIRECTORY = "DIRECTORY"
+    PASSWORD = "PASSWORD"
+
+
+class JavaType(Enum):
+    FILE = "java.io.File"
+    TEXT = "java.lang.String"
+    INTEGER = "java.lang.Integer"
+    FLOATING_POINT = "java.lang.Float"
+    DIRECTORY = "DIRECTORY"
+    PASSWORD = "PASSWORD"
+
+
+class Optional(Enum):
+    REQUIRED = ""
+    OPTIONAL = "on"
+
+
+class GPParamSpec:
+    """
+    Specification needed to create a parameter for a new GenePattern module
+    """
+    def __init__(self, name=None, description="", optional=Optional.REQUIRED,
+                 type=Type.TEXT, choices={}, value="", default_value="",
+                 file_format=[], min_values=0, max_values=1,
+                 flag="", prefix_when_specified=False):
+
+        self.name = name
+        self.description = description
+        self.optional = optional
+
+        self.type = type
+        self.choices = choices
+        self.value = value
+        self.default_value = default_value
+
+        self.file_format = file_format
+        self.min_values = min_values
+        self.max_values = max_values
+
+        self.flag = flag
+        self.prefix_when_specified = prefix_when_specified
+
+    def validate(self):
+        # Check all values for None, only max_values is allowed to be None
+        for attr in self.__dict__:
+            if self.__dict__[attr] is None and attr != "max_values":
+                raise ValueError(attr + " is not set")
+
+        # Validate name
+        invalid_chars = GPTaskSpec.invalid_chars()
+        if any(char in invalid_chars for char in self.name):
+            raise ValueError("parameter name includes invalid characters: " + self.name)
+
+        # Validate min_values
+        if not isinstance(self.min_values, int):
+            raise ValueError("min_values not an int in: " + self.name)
+
+        # Validate max_values
+        if not isinstance(self.max_values, int) and self.max_values is not None and self.max_values != float("inf"):
+            raise ValueError("max_values not an int, None or infinity in: " + self.name)
+
+        # Validate file formats
+        if not GPTaskSpec.all_strings(self.file_format):
+            raise TypeError("file_format contains non-string value in parameter: " + self.name)
+
+        # Validate choices dict
+        if not isinstance(self.choices, dict):
+            raise TypeError("choices is not dict in parameter: " + self.name)
+
+        # Return that everything validates
+        return True
+
+    def manifest_repr(self, p_num):
+        """
+        Builds a manifest string representation of the parameters and returns it
+        :param p_num: int
+        :return: string
+        """
+        # Build the parameter prefix
+        prefix = "p" + str(p_num) + "_"
+
+        # Generate the manifest string
+        manifest = prefix + "MODE=" + ("IN" if self.type == Type.FILE else "") + "\n"
+        manifest += prefix + "TYPE=" + str(self.type.value) + "\n"
+        if self.type == Type.FILE and len(self.choices) > 0:
+            manifest += prefix + "choices=" + self._choices() + "\n"
+        manifest += prefix + "default_value=" + self.default_value + "\n"
+        manifest += prefix + "description=" + GPTaskSpec.manifest_escape(self.description) + "\n"
+        manifest += prefix + "fileFormat=" + ';'.join(self.file_format) + "\n"
+        manifest += prefix + "flag=" + self.flag + "\n"
+        manifest += prefix + "name=" + self.name + "\n"
+        manifest += prefix + "numValues=" + self._num_values() + "\n"
+        manifest += prefix + "optional=" + str(self.optional.value) + "\n"
+        manifest += prefix + "prefix=" + (self.flag if self.prefix_when_specified else "") + "\n"
+        manifest += prefix + "prefix_when_specified=" + (self.flag if self.prefix_when_specified else "") + "\n"
+        manifest += prefix + "type=" + self._java_type() + "\n"
+        manifest += prefix + "value=" + (self._choices() if self.type != Type.FILE and len(self.choices) > 0 else "") + "\n"
+
+        # Return the manifest string
+        return manifest
+
+    def _choices(self):
+        """
+        Generate a string of choices as key/value pairs
+        :return: string
+        """
+        # Generate key/value strings
+        pairs = []
+        for key, value in self.choices.items():
+            pairs.append(str(value) + "=" + str(key))
+
+        # Assemble into overall string and escape
+        return GPTaskSpec.manifest_escape(";".join(pairs))
+
+    def _num_values(self):
+        """
+        Generate a valid num_values string based off min_values and max_values
+        :return: string
+        """
+        # Add min_values to string
+        num_values = str(self.min_values) if self.min_values else "0"
+
+        # Handle infinite max_values or finite max_values
+        if self.max_values is None or self.max_values == float("inf"):
+            num_values += "+"
+        else:
+            num_values += ".." + str(self.max_values)
+
+        # Return the num_values string
+        return num_values
+
+    def _java_type(self):
+        """
+        Translates GenePattern type string to Java type string
+        :return: string
+        """
+        return JavaType[self.type.name].value