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 MiltipleParameters(object):
    def __init__(self, types, required):
        self.types = types
        self.index = None
        self.required = required
        self.__name__ = "MiltipleParameters"
    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()))
        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)

class MiltipleAction(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        try:
            required = _copy.copy(values[0][2])
            for val in values:
                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!")
        setattr(namespace, self.dest, values)

class MiltipleAppendAction(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        try:
            required = _copy.copy(values[0][2])
            for val in values:
                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!")
        items = _copy.copy(_ensure_value(namespace, self.dest, []))
        items.append(values)
        setattr(namespace, self.dest, items)        
        
class Parameter(object):
    """
    """
    
    def __init__(self, name, help, flag, default=None, type=types.StringType, choices=None, 
                 required=False, action="store", sub_parameters=[], group="default", display_name=None):

        self.name = name
        self.flag = flag
        self.help = help
        self.action = action
        self.nargs = None
        self.sub_parameters = sub_parameters
        self.group = group
        if display_name == None:
            self.display_name = name
        else: self.display_name = display_name
        
        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 = {}, [], [], []
            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)
                if sub_param.required: sub_param_required.append(sub_param.flag)
            self.type = MiltipleParameters(sub_param_hash, sub_param_required)
            if self.action == "append":
                self.action = MiltipleAppendAction
            else:
                self.action = MiltipleAction
            self.help += " | Format: " + " ".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.required = str(required).lower() in ("yes", "y", "true",  "t", "1")
        self.choices = choices
        if self.choices:
            self.choices = choices.split("|")
                        
        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__
    
    def __str__(self):
        return self.name + ": " + str(self.flag) + " | " + self.help + " (default=" + \
               str(self.default) + ", required=" + str(self.required) + ", flag=" + self.flag + ")"