parameter.py

#
# Copyright (C) 2012 INRA
# 
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

import types
import datetime
import argparse
from argparse import _ensure_value
import copy as _copy
# import custom types
from workflows.types import *


class MultipleParameters(object):
    def __init__(self, types, required, choices, excludes, default, actions):
        self.types = types
        self.choices = choices
        self.excludes = excludes
        self.default = default
        self.actions = actions
        self.index = None
        self.required = required
        self.__name__ = "MultipleParameters"
        
    def __call__(self, arg):
        parts = arg.split("=")
        if not self.types.has_key(parts[0]):
            raise argparse.ArgumentTypeError(parts[0] + " is an invalid flag! Available ones are: "+", ".join(self.types.keys()))
        if self.choices[parts[0]] != None:
            if parts[1] not in self.choices[parts[0]]:
                raise argparse.ArgumentTypeError("argument " + parts[0] + ": invalid choice: '" + parts[1] + "' (choose from " + ", ".join(self.choices[parts[0]]) + "))")
        
        if self.types[parts[0]] == types.BooleanType:
            return (parts[0], not self.default[parts[0]], self.required, self.excludes)
        else:
            try:
                value = self.types[parts[0]](parts[1])
            except:
                raise argparse.ArgumentTypeError("invalid " + self.types[parts[0]].__name__ + " value: '" + parts[1] + "' for sub parameter '" + parts[0] + "'")
        
            self.index = parts[0]
            return (parts[0], value, self.required, self.excludes, self.actions)

class MiltipleAction(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        # what is commun within required and excludes
        exclusif_required = {}
        for exclude_group in values[0][3]:
            exclusif_required[exclude_group] = False
            for param in values[0][3][exclude_group]:
                if param in values[0][2]:
                    exclusif_required[exclude_group] = True
        given_params = []
        # first check for required parameters
        try:
            required = _copy.copy(values[0][2])
            # delete required that are exclusive
            for group in exclusif_required:
                if exclusif_required[group]:
                    for val in values[0][3][group]:
                        if val in required:
                            del required[required.index(val)]
            for val in values:
                given_params.append(val[0])
                if val[0] in required:
                    del required[required.index(val[0])]
        except: pass
        if len(required) == 1: parser.error(", ".join(required) + " is a required parameter!")
        elif len(required) > 1: parser.error(", ".join(required) + " are required parameters!")
        # then for exclude ones    
        for exclude_group in values[0][3]:
            found = None
            for param in values[0][3][exclude_group]:
                if param in given_params and found != None:
                    parser.error("argument '" + found + "': not allowed with argument '" + param + "'")
                    break
                elif param in given_params: found = param
        
        # check for required exclusive if one of them is in
        if len(exclusif_required.keys()) > 0:
            for group in exclusif_required:
                if exclusif_required[group]:
                    rfound = False
                    for param in values[0][3][group]:
                        if param in given_params: rfound = True
            if not rfound: parser.error("one of the arguments: " + ", ".join(values[0][3][group]) + " is required")
        
        # if ok add the value
        final_hash, final_values = {}, []
        for value in values:
            if values[0][4][value[0]] == "append" and final_hash.has_key(value[0]):
                final_hash[value[0]].append(value[1])
            elif values[0][4][value[0]] == "append":
                final_hash[value[0]]= [value[1]]
            else:
                final_hash[value[0]]= value[1]
        for param in final_hash:
            final_values.append((param, final_hash[param]))
        setattr(namespace, self.dest, final_values)

class MiltipleAppendAction(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        # what is commun within required and excludes
        exclusif_required = {}
        for exclude_group in values[0][3]:
            exclusif_required[exclude_group] = False
            for param in values[0][3][exclude_group]:
                if param in values[0][2]:
                    exclusif_required[exclude_group] = True
        given_params = []
        # first check for required parameters
        try:
            required = _copy.copy(values[0][2])
            # delete required that are exclusive
            for group in exclusif_required:
                if exclusif_required[group]:
                    for val in values[0][3][group]:
                        if val in required:
                            del required[required.index(val)]
            for val in values:
                given_params.append(val[0])
                if val[0] in required:
                    del required[required.index(val[0])]
        except: pass
        if len(required) == 1: parser.error(", ".join(required) + " is a required parameter!")
        elif len(required) > 1: parser.error(", ".join(required) + " are required parameters!")
        # then for exclude ones    
        for exclude_group in values[0][3]:
            found = None
            for param in values[0][3][exclude_group]:
                if param in given_params and found != None:
                    parser.error("argument '" + found + "': not allowed with argument '" + param + "'")
                    break
                elif param in given_params: found = param
        
        # check for required exclusive if one of them is in
        if len(exclusif_required.keys()) > 0:
            for group in exclusif_required:
                if exclusif_required[group]:
                    rfound = False
                    for param in values[0][3][group]:
                        if param in given_params: rfound = True
            if not rfound: parser.error("one of the arguments: " + ", ".join(values[0][3][group]) + " is required")
        # if ok add the value
        items = _copy.copy(_ensure_value(namespace, self.dest, []))
        final_hash, final_values = {}, []
        for value in values:
            if values[0][4][value[0]] == "append" and final_hash.has_key(value[0]):
                final_hash[value[0]].append(value[1])
            elif values[0][4][value[0]] == "append":
                final_hash[value[0]]= [value[1]]
            else:
                final_hash[value[0]]= value[1]
        for param in final_hash:
            final_values.append((param, final_hash[param]))
        items.append(final_values)
        setattr(namespace, self.dest, items)        


class AbstractParameter(object):
    
    def __init__(self, name, help, default=None, type=types.StringType, choices=None, required=False,
                 flag=None, action="store", sub_parameters=None, group="default", display_name=None):

        self.name = name
        self.help = help
        self.action = action
        self.nargs = None
        if sub_parameters:
            self.sub_parameters = sub_parameters
        else: self.sub_parameters = []
        self.group = group
        if flag == None:
            self.flag = "--"+name.replace("_", "-")
        else: self.flag = flag
        if display_name == None: 
            self.display_name = name.replace("_", " ").title()
        else: self.display_name = display_name
        self.required = str(required).lower() in ("yes", "y", "true",  "t", "1")
        self.choices = choices
        
        if len(self.sub_parameters) > 0:
            self.nargs = "+"
        if type == "date":
            self.type = date
        elif type == "multiple":
            sub_param_hash, sub_param_types, sub_param_names, sub_param_required, sub_param_choices, sub_param_excludes = {}, [], [], [], {}, {}
            sub_param_default, sub_param_actions = {}, {}
            for sub_param in self.sub_parameters:
                try: sub_type = sub_param.type
                except: sub_type = types.StringType
                sub_param_hash[sub_param.flag] = sub_type
                sub_param_names.append(sub_param.flag)
                sub_param_types.append(sub_type)
                sub_param_choices[sub_param.flag] = sub_param.choices
                sub_param_default[sub_param.flag] = sub_param.default
                sub_param_actions[sub_param.flag] = sub_param.action
                if sub_param.group.startswith("exclude-"):
                    if sub_param.group in sub_param_excludes.keys():
                        sub_param_excludes[sub_param.group].append(sub_param.flag)
                    else:
                        sub_param_excludes[sub_param.group] = [sub_param.flag]
                if sub_param.required: sub_param_required.append(sub_param.flag)
            self.type = MultipleParameters(sub_param_hash, sub_param_required, sub_param_choices, sub_param_excludes, sub_param_default, sub_param_actions)
            if self.action == "append":
                self.action = MiltipleAppendAction
            else:
                self.action = MiltipleAction
            self.help += " (" + " ".join([cname + "=<" + ctype.__name__.upper() + ">" for ctype, cname in zip(sub_param_types, sub_param_names)]) + ")"
        elif isinstance(type, types.FunctionType):
            self.type = type
        else:
            try: self.type = eval(type)
            except: self.type = types.StringType
                        
        self.default = default
        if type == "date" and not self.default:
            today = datetime.date.today()
            self.default = today.strftime('%d/%m/%Y')
        elif self.type == types.BooleanType :
            if self.default: self.default = str(self.default).lower() in ("true",  "t", "1")
            else: self.default = True
        elif self.action == "append" or self.action == MiltipleAppendAction:
            self.default = []
        elif type == "multiple":
            self.default = {}
            for param in self.sub_parameters:
                self.default[param.name] = param.default
    
    def export_to_argparse(self):
        if self.type == types.BooleanType and str(self.default).lower() in ("false",  "f", "0"):
            return {"help": self.help, "required": self.required, "dest": self.name, 
                    "default": False, "action": "store_true"}
        elif self.type == types.BooleanType:
            return {"help": self.help, "required": self.required, "dest": self.name, 
                    "default": True, "action": "store_false"}
        elif self.nargs > 1:
            return {"type": self.type, "help": self.help, "required": self.required,
                    "dest": self.name, "default": self.default,
                    "action": self.action, "choices": self.choices, "nargs": "+"}
        else:
            return {"type": self.type, "help": self.help, "required": self.required,
                    "dest": self.name, "default": self.default,
                    "action": self.action, "choices": self.choices}
    
    def get_type(self):
        return self.type.__name__
    
    
class AbstractFile(object):
    def __init__(self, file_format="any"):
        self.file_format = file_format
        self.parent_component_nameid = None


class MultiParameter(dict, AbstractParameter):
    
    def __init__(self, name, help, required=False, flag=None, group="default", display_name=None):
        AbstractParameter.__init__(self, name, help, required=required, flag=flag, group=group, display_name=display_name)
        return dict.__init__(self, {})


class MultiParameterList(list, AbstractParameter):
    
    def __init__(self, name, help, required=False, flag=None, group="default", display_name=None):
        AbstractParameter.__init__(self, name, help, required=required, flag=flag, group=group, display_name=display_name)
        return list.__init__(self, [])
    

class Parameter(str, AbstractParameter):
    
    def __new__(self, name, help, default="", type=types.StringType, choices=None, required=False,
                flag=None, sub_parameters=None, group="default", display_name=None):
        return str.__new__(self, default)
    
    def __init__(self, name, help, default="", type=types.StringType, choices=None, required=False,
                 flag=None, sub_parameters=None, group="default", display_name=None):
        AbstractParameter.__init__(self, name, help, flag=flag, type=type, choices=choices, required=required, 
                                   action="store", sub_parameters=sub_parameters, group=group, display_name=display_name)
        

class InputFile(Parameter, AbstractFile):
    
    def __new__(self, name, help, file_format="any", default="", type=types.StringType, choices=None, 
                required=False, flag=None, group="default", display_name=None):
        return str.__new__(self, default)
    
    def __init__(self, name, help, file_format="any", default="", type=types.StringType, choices=None, 
                required=False, flag=None, group="default", display_name=None):
        AbstractFile.__init__(self, file_format)
        Parameter.__init__(self, name, help, flag=flag, type=type, choices=choices, 
                           required=required, group=group, display_name=display_name)
    

class OutputFile(Parameter, AbstractFile):
    
    def __new__(self, name, help, file_format="any", default="", type=types.StringType, choices=None, 
                required=False, flag=None, group="default", display_name=None):
        return str.__new__(self, default)
    
    def __init__(self, name, help, file_format="any", default="", type=types.StringType, choices=None, 
                required=False, flag=None, group="default", display_name=None):
        AbstractFile.__init__(self, file_format)
        Parameter.__init__(self, name, help, flag=flag, type=type, choices=choices, 
                           required=required, group=group, display_name=display_name)

        
class ParameterList(list, AbstractParameter):
    
    def __init__(self, name, help, default=[], type=types.StringType, choices=None, required=False,
                 flag=None, sub_parameters=None, group="default", display_name=None):
        AbstractParameter.__init__(self, name, help, flag=flag, type=type, choices=choices, required=required, 
                                   action="append", sub_parameters=sub_parameters, group=group, display_name=display_name)
        if default.__class__.__name__ == "str":
            return list.__init__(self, [default])
        elif default.__class__.__name__ == "list":
            return list.__init__(self, default)
        

class InputFileList(ParameterList, AbstractFile):
    
    def __init__(self, name, help, file_format="any", default=[], type=types.StringType, choices=None, 
                 required=False, flag=None, group="default", display_name=None):
        AbstractFile.__init__(self, file_format)
        ParameterList.__init__(self, name, help, flag=flag, type=type, choices=choices, 
                               required=required, group=group, display_name=display_name)
        if default.__class__.__name__ == "str":
            return list.__init__(self, [default])
        elif default.__class__.__name__ == "list":
            return list.__init__(self, default)


class OutputFileList(ParameterList, AbstractFile):
    
    def __init__(self, name, help, file_format="any", default=[], type=types.StringType, 
                 choices=None, required=False, flag=None, group="default", display_name=None):
        AbstractFile.__init__(self, file_format)
        ParameterList.__init__(self, name, help, flag=flag, type=type, choices=choices, 
                               required=required, group=group, display_name=display_name)
        if default.__class__.__name__ == "str":
            return list.__init__(self, [default])
        elif default.__class__.__name__ == "list":
            return list.__init__(self, default)