tiramisu/tiramisu/autolib.py

# Copyright (C) 2012-2013 Team tiramisu (see AUTHORS for all contributors)
#
# 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 2 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, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
# The original `Config` design model is unproudly borrowed from
# the rough gus of pypy: pypy: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"enables us to carry out a calculation and return an option's value"
from tiramisu.error import PropertiesOptionError, ConfigError
from tiramisu.i18n import _
# ____________________________________________________________
# automatic Option object
#def special_owner_factory(name, owner, value,
#                          callback, callback_params=None, config=None):
#    # in case of an 'auto' and a 'fill' without a value,
#    # we have to carry out a calculation
#    return calc_factory(name, callback, callback_params, config)


def carry_out_calculation(name, config, callback, callback_params, index=None):
    "a function that carries out a calculation for an option's value"
    #callback, callback_params = option.getcallback()
    #if callback_params is None:
    #    callback_params = {}
    tcparams = {}
    one_is_multi = False
    len_multi = 0

    for key, values in callback_params.items():
        for value in values:
            if type(value) == tuple:
                path, check_disabled = value
                if config is None:
                    if check_disabled:
                        continue
                    raise ConfigError(_('no config specified but needed'))
                try:
                    opt_value = config._getattr(path, force_permissive=True)
                    opt = config.unwrap_from_path(path, force_permissive=True)
                except PropertiesOptionError, err:
                    if check_disabled:
                        continue
                    raise ConfigError(_('unable to carry out a calculation, '
                                        'option {0} has properties: {1} for: '
                                        '{2}').format(path, err.proptype,
                                                      name))
                is_multi = opt.impl_is_multi()
                if is_multi:
                    if opt_value is not None:
                        len_value = len(opt_value)
                        if len_multi != 0 and len_multi != len_value:
                            raise ConfigError(_('unable to carry out a '
                                              'calculation, option values with'
                                              ' multi types must have same '
                                              'length for: {0}').format(name))
                        len_multi = len_value
                    one_is_multi = True
                tcparams.setdefault(key, []).append((opt_value, is_multi))
            else:
                tcparams.setdefault(key, []).append((value, False))

    if one_is_multi:
        ret = []
        if index:
            range_ = [index]
        else:
            range_ = range(len_multi)
        for incr in range_:
            tcp = {}
            params = []
            for key, couples in tcparams.items():
                for couple in couples:
                    value, ismulti = couple
                    if ismulti and value is not None:
                        if key == '':
                            params.append(value[incr])
                        else:
                            if len(value) > incr:
                                tcp[key] = value[incr]
                            else:
                                tcp[key] = ''
                    else:
                        if key == '':
                            params.append(value)
                        else:
                            tcp[key] = value
            calc = calculate(name, callback, params, tcp)
            if index:
                ret = calc
            else:
                if isinstance(calc, list):
                    ret.extend(calc)
                else:
                    ret.append(calc)

        return ret
    else:
        tcp = {}
        params = []
        for key, couples in tcparams.items():
            for couple in couples:
                if key == '':
                    value = couple[0]
                    params.append(value)
                else:
                    tcp[key] = couple[0]
        return calculate(name, callback, params, tcp)


def calculate(name, callback, params, tcparams):
    """wrapper that launches the 'callback'

    :param callback: callback name
    :param params: in the callback's arity, the unnamed parameters
    :param tcparams: in the callback's arity, the named parameters

    """
    return callback(*params, **tcparams)