def test_function(self):
fun = sh.SubDispatchFunction(self.dsp_1, 'F', ['a', 'b'], ['a'])
self.assertEqual(fun.__name__, 'F')
# noinspection PyCallingNonCallable
self.assertEqual(fun(2, 1), 1)
self.assertRaises(sh.DispatcherError, fun, 3, -1)
fun = sh.SubDispatchFunction(self.dsp_2, 'F', ['b', 'a', 'e', 'h'],
['c', 'd'])
# noinspection PyCallingNonCallable
self.assertEqual(fun(1, 2, 0, 0), [3, 2])
self.assertEqual(fun(b=1, a=2, e=0, h=0), [3, 2])
self.assertEqual(fun(1, 2, 0), [4, 3])
self.assertEqual(fun(1, 2, e=0), [4, 3])
self.assertEqual(fun(1, 2, 0, c=3), [3, 2])
self.assertEqual(fun(1, 2, 0, **{'!i': 3}), [4, 6])
self.assertRaises(ValueError, sh.SubDispatchFunction, self.dsp_2, 'F',
['a', 'c'], ['d'])
self.assertRaises(TypeError, fun, 2, 1, 2, 5, 6)
self.assertRaises(TypeError, fun, 2, 1, a=2, b=2)
self.assertRaises(TypeError, fun, 2, 1, g=0)
self.assertRaises(TypeError, fun)
fun = sh.SubDispatchFunction(self.dsp_3, outputs=['d'])
self.assertEqual(fun(), 0)
self.assertEqual(fun(a=4), 4)
self.assertEqual(fun(d=5), 5)
self.assertEqual(fun(a=3, d=7), 7)
self.assertRaises(TypeError, fun, 2)
self.assertRaises(TypeError, fun, c=2)
fun = sh.SubDispatchFunction(self.dsp_3, outputs=['c'])
self.assertEqual(fun(), 0)
self.assertEqual(fun(c=5), 5)
self.assertRaises(TypeError, fun, 2)
self.assertRaises(TypeError, fun, a=2)
self.assertRaises(TypeError, fun, a=2, c=7)
self.assertRaises(TypeError, fun, d=2)
fun = sh.SubDispatchFunction(self.dsp_3,
inputs=['y', 'x'],
outputs=['z'])
self.assertEqual(fun(x=3), 3)
self.assertRaises(TypeError, fun, 2)
self.assertRaises(TypeError, fun, y=4)
self.assertRaises(TypeError, fun, a=2)
def _errors(name, data_id, data_out, setting):
d = sh.Dispatcher(
name='%s-%s errors' % (name, data_id),
description='Calculates the error of calibrated model.',
)
setting = setting.copy()
d.add_data(data_id='models', default_value=setting.pop('models', []))
select_data = functools.partial(sh.selector, allow_miss=True)
d.add_function(function_id='select_models',
function=setting.pop('select_models', select_data),
inputs=['models', data_id],
outputs=['calibrated_models'])
d.add_data(data_id='data_in', default_value=data_id)
d.add_data(data_id='error_settings', default_value={})
err = _error(name, setting)
for o in data_out:
d.add_function(function=functools.partial(
sh.map_list, ['calibrated_models', 'data']),
inputs=['calibrated_models', o],
outputs=['input/%s' % o])
d.add_function(function=err,
inputs=['input/%s' % o, 'error_settings'],
outputs=['error/%s' % o])
i = ['error_settings', data_id] + [k for k in data_out if k != data_id]
func = sh.SubDispatchFunction(dsp=d, function_id=d.name, inputs=i)
return func
def write_outputs():
"""
Defines a module to write on files the outputs of the CO2MPAS model.
.. dispatcher:: d
>>> d = write_outputs()
:return:
The write outputs module.
:rtype: SubDispatchFunction
"""
d = sh.Dispatcher(
name='write_outputs',
description='Writes on files the outputs of the CO2MPAS model.'
)
d.add_function(
function=convert2df,
inputs=['output_data', 'start_time', 'main_flags'],
outputs=['dfs']
)
d.add_function(
function=excel.write_to_excel,
inputs=['dfs', 'output_file_name', 'template_file_name']
)
inp = ['output_file_name', 'template_file_name', 'output_data',
'start_time', 'main_flags']
return sh.SubDispatchFunction(d, d.name, inp)
def report():
"""
Defines and returns a function that produces a vehicle report from CO2MPAS
outputs.
.. dispatcher:: d
>>> d = report()
:return:
The reporting model.
:rtype: SubDispatchFunction
"""
# Initialize a dispatcher.
d = sh.Dispatcher(
name='make_report',
description='Produces a vehicle report from CO2MPAS outputs.')
d.add_function(function=get_report_output_data,
inputs=['output_data'],
outputs=['report'])
d.add_function(function=extract_summary,
inputs=['report', 'vehicle_name'],
outputs=['summary'])
inputs = ['output_data', 'vehicle_name']
outputs = ['report', 'summary']
return sh.SubDispatchFunction(d, d.name, inputs, outputs)
def selector(*data, pred_cyl_ids=('nedc_h', 'nedc_l', 'wltp_h', 'wltp_l')):
"""
Defines the models' selector model.
.. dispatcher:: d
>>> d = selector()
:return:
The models' selector model.
:rtype: SubDispatchFunction
"""
data = data or ('wltp_h', 'wltp_l')
d = sh.Dispatcher(name='Models selector',
description='Select the calibrated models.')
d.add_function(function=functools.partial(sh.map_list, data),
inputs=data,
outputs=['CO2MPAS_results'])
d.add_data(data_id='models', function=combine_outputs, wait_inputs=True)
d.add_data(data_id='scores', function=combine_outputs, wait_inputs=True)
setting = sub_models()
d.add_data(data_id='selector_settings', default_value={})
m = list(setting)
d.add_function(function=functools.partial(split_selector_settings, m),
inputs=['selector_settings'],
outputs=['selector_settings/%s' % k for k in m])
for k, v in setting.items():
v['names'] = v.get('names', v['targets'])
v['dsp'] = v.pop('define_sub_model', define_sub_model)(v.pop('d'), **v)
v['metrics'] = sh.map_list(v['names'], *v['metrics'])
d.add_function(function=v.pop('model_selector', _selector)(k, data,
data, v),
function_id='%s selector' % k,
inputs=['CO2MPAS_results',
'selector_settings/%s' % k],
outputs=['models', 'scores'])
pred_mdl_ids = ['models_%s' % k for k in pred_cyl_ids]
d.add_function(function=functools.partial(split_prediction_models,
cycle_ids=pred_cyl_ids),
inputs=['scores', 'models', 'default_models'],
outputs=['selections'] + pred_mdl_ids)
func = sh.SubDispatchFunction(
dsp=d,
function_id='models_selector',
inputs=('selector_settings', 'default_models') + data,
outputs=['selections'] + pred_mdl_ids)
return func
def setUp(self):
ss_dsp = sh.Dispatcher()
fun = lambda a: (a + 1, 5, a - 1)
dom = lambda kw: True
c = '|!"£$%&/()=?^*+éè[]#¶ù§çò@:;-_.,<>'
ss_dsp.add_function(function=fun,
inputs=['a'],
outputs=['b', sh.SINK, c],
input_domain=dom,
weight=1)
def raise_fun(a):
raise ValueError('Error')
ss_dsp.add_function(function=raise_fun, inputs=['a'], outputs=['b'])
sdspfunc = sh.SubDispatchFunction(ss_dsp, 'SubDispatchFunction', ['a'],
['b', c])
sdsppipe = sh.SubDispatchPipe(ss_dsp, 'SubDispatchPipe', ['a'],
['b', c])
spipe = sh.DispatchPipe(ss_dsp, 'DispatchPipe', ['a'], [c])
sdsp = sh.SubDispatch(ss_dsp, ['b', c], output_type='list')
s_dsp = sh.Dispatcher()
s_dsp.add_function(None, sdspfunc, ['a'], ['b', 'c'], weight=2)
s_dsp.add_function(None,
sdsppipe, ['a'], ['b', 'c'],
out_weight={'c': 5})
s_dsp.add_function(None, spipe, ['a'], ['b'], weight=2)
s_dsp.add_function('SubDispatch', sdsp, ['d'], ['e', 'f'])
dsp = sh.Dispatcher()
dsp.add_data('A', default_value=[0] * 1000)
dsp.add_data('D', default_value={'a': 3})
dsp.add_dispatcher(dsp=s_dsp,
inputs={
'A': 'a',
'D': 'd'
},
outputs={
'b': 'B',
'c': 'C',
'e': 'E',
'f': 'F'
},
inp_weight={'A': 3})
self.sol = dsp.dispatch()
self.dsp = dsp
dsp = sh.Dispatcher()
dsp.add_function(function=sh.bypass, inputs=['a'], outputs=[sh.PLOT])
self.dsp_plot = dsp
def write_ta_output():
func = sh.SubDispatchFunction(crypto(),
'write_ta_output',
inputs=[
'encrypt_inputs', 'path_keys',
'vehicle_family_id', 'start_time',
'timestamp', 'data', 'meta', 'report',
'output_folder'
],
outputs=['ta_file'])
return func
def define_decrypt_function(path_keys, passwords=None):
dsp = crypto()
sol = dsp({'path_keys': path_keys, 'passwords': passwords})
dsp = dsp.shrink_dsp(inputs=['ta_file'] + sorted(sol),
outputs=['ta_id', 'dice_report', 'data', 'meta'])
for k, v in sol.items():
if k in dsp.nodes:
dsp.add_data(k, v)
func = sh.SubDispatchFunction(dsp, 'decrypt', ['ta_file'],
['ta_id', 'dice_report', 'data', 'meta'])
func.output_type = 'all'
return func
def mdl_selector(name, package=None):
"""
Defines a model selector for a specific model.
:param name:
Model name.
:type name: str
:param package:
Package name.
:type package: str
:return:
Model selector.
:rtype: schedula.utils.blue.BlueDispatcher
"""
import importlib
mdl = importlib.import_module(name, package)
dsp = sh.BlueDispatcher(name='%s selector' % mdl.name,
description='Select the calibrated %s.' % mdl.name)
err_func = sh.SubDispatch(_mdl_error(mdl),
outputs=['errors', 'status'],
output_type='list')
for data_id in calibration_cycles:
mdl_err, mdl_err_name = _mdl_errors(mdl, data_id, err_func)
dsp.add_func(sh.SubDispatchFunction(
mdl_err,
function_id=mdl_err_name,
inputs=[data_id] + [k
for k in calibration_cycles if k != data_id]),
outputs=['error/%s' % data_id])
# noinspection PyTypeChecker
dsp.add_function(function=functools.partial(sort_models,
weights=getattr(
mdl, 'weights', None)),
inputs=list(map('error/{}'.format, calibration_cycles)),
outputs=['rank'])
dsp.add_func(format_score, outputs=['score'])
dsp.add_func(functools.partial(select_best_model,
selector_id='%s selector' % mdl.name),
outputs=['model'])
return dsp
def setUp(self):
ss_dsp = sh.Dispatcher()
def fun(a, c):
"""
:param a:
Nice a.
:type a: float
:param c:
Nice c.
:type c: float
:return:
Something.
:rtype: tuple
"""
return a + 1, c, a - 1
ss_dsp.add_function('fun', fun, ['a', 'e'], ['b', 'c', 'd'])
ss_dsp_func = sh.SubDispatchFunction(
ss_dsp, 'func', ['e', 'a'], ['c', 'd', 'b'])
sub_disfun = sh.partial(ss_dsp_func, 5)
s_dsp = sh.Dispatcher()
s_dsp.add_function(
'sub_dispatch', sub_disfun, ['a'], ['b', 'c', sh.SINK]
)
dispatch = sh.SubDispatch(s_dsp, ['b', 'c', 'a'], output_type='list')
dsp = sh.Dispatcher()
dsp.add_data('input', default_value={'a': 3})
dsp.add_function('dispatch', dispatch, ['input'], [sh.SINK, 'h', 'i'])
self.sol = dsp.dispatch(inputs={'f': 'new'})
self.dsp = dsp
self.fun = fun
self.sub_dispatch = sub_disfun
self.s_dsp = s_dsp
self.ss_dsp = ss_dsp
self.ss_dsp_func = ss_dsp_func
def _transform_gear_box_ratios(gear_box_inputs, type_cols):
from co2mpas.core.model.physical import dsp
inputs = [
"final_drive_ratio",
"gear_box_ratios",
"tyre_code",
"gear_box_type",
"n_gears",
]
outputs = ["speed_velocity_ratios"]
dsp = dsp.register().shrink_dsp(inputs=inputs, outputs=outputs)
func = sh.SubDispatchFunction(dsp, inputs=inputs, outputs=outputs)
frames = []
for k, v in gear_box_inputs.items():
ndv_dict = func(
final_drive_ratio=gear_box_inputs[k]["final_drive_ratios"][0],
gear_box_ratios=dict(enumerate(gear_box_inputs[k]["gear_box_ratios"], 1)),
tyre_code=gear_box_inputs[k]["tyre_code"],
gear_box_type="manual",
n_gears=len(gear_box_inputs[k]["gear_box_ratios"]),
)
ndv_dict.pop(0, None)
gears, ndv = zip(*ndv_dict.items())
gear_box_ratios_dict = {"vehicle": k, "gear": gears, "ndv": ndv}
df = pd.DataFrame.from_dict(gear_box_ratios_dict)
frames.append(df)
gear_box_ratios_df = pd.concat(frames, ignore_index=True)
gear_box_ratios_df = gear_box_ratios_df[["vehicle", "gear", "ndv"]]
gear_box_ratios_df = gear_box_ratios_df.astype(type_cols)
return gear_box_ratios_df
def setUp(self):
ss_dsp = sh.Dispatcher(name='Ciao.')
def fun(b, c, d=0):
"""
Fun description.
:param b:
Second param.
:param int c:
Third param.
:return:
Out param.
:rtype: float
"""
return b + c + d
def dom(a, *args):
"""
:param a:
First param.
"""
return a
ss_dsp.add_function(function=sh.add_args(fun),
inputs=['a', 'b', 'c', 'd'],
outputs=['e'],
input_domain=dom)
ss_dsp.add_function(function=sh.bypass, inputs=['e'], outputs=['f'])
ss_dsp.add_function(function=sh.replicate_value,
inputs=['f'],
outputs=['g', 'h'])
sdspfunc = sh.SubDispatchFunction(ss_dsp, 'SubDispatchFunction',
['a', 'b', 'c', 'd'], ['g', 'h'])
sdsp = sh.SubDispatch(ss_dsp, ['e', 'f'], output_type='list')
def fun1():
""""""
return
sdspfunci = sh.SubDispatchFunction(ss_dsp, 'SubDispatchFunction',
['a', 'b', 'c', 'd'])
s_dsp = sh.Dispatcher(name='Sub-Dispatcher')
s_dsp.add_function('3', sdspfunc, ['a', 'b', 'c', 'd'], ['g', 'h'])
s_dsp.add_function('8', sdspfunci, ['a', 'b', 'c', 'd'], ['o'])
s_dsp.add_function('2', sdsp, ['I'], ['e', 'f'])
s_dsp.add_function('4', max, ['e', 'f', 'l'], ['i'])
s_dsp.add_function('5', inputs=['i'], outputs=['n'])
s_dsp.add_function('6', fun1)
s_dsp.add_function('7',
sh.bypass,
inputs=['p'],
input_domain=sh.add_args(lambda p: None))
s_dsp.add_data('i', description='max.')
self.dsp = dsp = sh.Dispatcher()
dsp.add_dispatcher(
dsp_id='1',
dsp=s_dsp,
inputs=('n', 'd', 'I', 'l', {
'm': ('b', 'c'),
('a', 'a1'): 'a'
}),
outputs=['g', 'i', {
'f': ('h', 'f')
}, {
('e', 'h'): ('e', 'e1')
}])
def calculate_wltp_velocities():
"""
Defines the wltp cycle model.
.. dispatcher:: d
>>> d = calculate_wltp_velocities()
:return:
The wltp cycle model.
:rtype: schedula.Dispatcher
"""
d = sh.Dispatcher(
name='WLTP velocities model',
description='Returns the theoretical velocities of WLTP.')
d.add_function(
function=get_dfl,
inputs=['base_model'],
outputs=['resistance_coeffs_regression_curves', 'wltc_data'])
d.add_function(
function=wltp_exp.calc_default_resistance_coeffs,
inputs=['vehicle_mass', 'resistance_coeffs_regression_curves'],
outputs=['road_loads'],
weight=15)
d.add_function(function=calculate_max_speed_velocity_ratio,
inputs=['speed_velocity_ratios'],
outputs=['max_speed_velocity_ratio'])
d.add_function(
function=calculate_max_velocity,
inputs=['engine_speed_at_max_power', 'max_speed_velocity_ratio'],
outputs=['max_velocity'])
d.add_function(function=calculate_wltp_class,
inputs=[
'wltc_data', 'engine_max_power', 'unladen_mass',
'max_velocity'
],
outputs=['wltp_class'])
d.add_function(function=get_class_data,
inputs=['wltc_data', 'wltp_class'],
outputs=['class_data'])
d.add_function(function=get_class_velocities,
inputs=['class_data', 'times'],
outputs=['class_velocities'],
weight=25)
from ..vehicle import vehicle
func = sh.SubDispatchFunction(dsp=vehicle(),
function_id='calculate_class_powers',
inputs=[
'vehicle_mass', 'velocities',
'climbing_force', 'road_loads',
'inertial_factor', 'times'
],
outputs=['motive_powers'])
d.add_function(function=func,
inputs=[
'vehicle_mass', 'class_velocities', 'climbing_force',
'road_loads', 'inertial_factor', 'times'
],
outputs=['class_powers'])
from ..defaults import dfl
d.add_data(data_id='downscale_factor_threshold',
default_value=dfl.values.downscale_factor_threshold)
d.add_function(function=calculate_downscale_factor,
inputs=[
'class_data', 'downscale_factor_threshold',
'max_velocity', 'engine_max_power', 'class_powers',
'times'
],
outputs=['downscale_factor'])
d.add_function(function=get_downscale_phases,
inputs=['class_data'],
outputs=['downscale_phases'])
d.add_function(function=wltp_velocities,
inputs=[
'downscale_factor', 'class_velocities',
'downscale_phases', 'times'
],
outputs=['velocities'])
return d
def setUp(self):
ss_dsp = sh.Dispatcher(name='ss_dsp')
fun = lambda a: (a + 1, 5, a - 1)
dom = lambda kw: True
ss_dsp.add_function(function=fun,
inputs=['a'],
outputs=['b', 'd', 'c'],
input_domain=dom,
weight=1)
sdspfunc = sh.SubDispatchFunction(ss_dsp, 'SubDispatchFunction', ['a'],
['b', 'c'])
sdsppipe = sh.SubDispatchPipe(ss_dsp, 'SubDispatchPipe', ['a'],
['b', 'c'])
sdsp = sh.SubDispatch(ss_dsp, ['b', 'c'], output_type='list')
s_dsp = sh.Dispatcher(name='s_dsp')
s_dsp.add_function(None, sdspfunc, ['a'], ['b', 'c'])
s_dsp.add_function(None, sdsppipe, ['a'], ['g'])
s_dsp.add_function('SubDispatch', sdsp, ['d'], ['e', 'f'])
dsp = sh.Dispatcher(name='model')
dsp.add_data('A', default_value=0)
dsp.add_data('D', default_value={'a': 3})
dsp.add_dispatcher(dsp=s_dsp,
inputs={
'A': 'a',
'D': 'd'
},
outputs={
'b': 'B',
'c': 'C',
'e': 'E',
'f': 'F',
'g': 'G'
},
inp_weight={'A': 3})
self.dsp = dsp
self.sol = sol = dsp.dispatch()
sites = set()
webmap = dsp.web(node_data=('+set_value', ), run=True, sites=sites)
self.site = sites.pop()
self.url = '%s/' % self.site.url
rules = webmap.rules()
self.io = io = []
for rule in rules.values():
n = rule.split('/')[1:]
if not n:
continue
s, k = sol.get_node(*n, node_attr='sol')
k = k[-1]
try:
v = s.workflow.node[k]
except KeyError:
continue
if 'results' not in v:
continue
inputs = s._wf_pred[k] # List of the function's arguments.
inputs = sh.bypass(
*[inputs[k]['value'] for k in s.nodes[k]['inputs']])
io.append((rule, inputs, v['results']))
self.sol1 = sol = dsp.dispatch({'A': 1})
self.io1 = io = []
for rule in rules.values():
n = rule.split('/')[1:]
if not n:
continue
s, k = sol.get_node(*n, node_attr='sol')
k = k[-1]
try:
v = s.workflow.node[k]
except KeyError:
continue
if 'results' not in v:
continue
inputs = s._wf_pred[k] # List of the function's arguments.
inputs = sh.bypass(
*[inputs[k]['value'] for k in s.nodes[k]['inputs']])
io.append((rule, inputs, v['results']))
def setUp(self):
dsp_1 = sh.BlueDispatcher(raises='')
dsp_1.add_function('max', max, inputs=['a', 'b'], outputs=['c'])
dsp_1.add_function('min',
min,
inputs=['c', 'b'],
outputs=['a'],
input_domain=lambda c, b: c * b > 0)
dsp_1.add_data('a', wildcard=True)
self.dsp_1 = dsp_1.register()
dsp = sh.Dispatcher(raises='')
def f(a, b):
if b is None:
return a, sh.NONE
return a + b, a - b
dsp.add_function('f', f, inputs=['a', 'b'], outputs=['c', sh.SINK])
dsp.add_function('f', f, inputs=['c', 'b'], outputs=[sh.SINK, 'd'])
self.dsp_2 = dsp
dsp = sh.Dispatcher(raises='')
dsp.add_function('f',
f,
inputs=['a', 'b'],
outputs=['c', 'd'],
out_weight={'d': 100})
dsp.add_dispatcher(dsp=dsp_1.register(),
inputs={
'a': 'a',
'b': 'b'
},
outputs={'c': 'd'})
self.dsp_3 = dsp
dsp = sh.Dispatcher(raises='')
dsp.add_function(function=sh.SubDispatchFunction(
self.dsp_3, 'f', ['b', 'a'], ['c', 'd']),
inputs=['b', 'a'],
outputs=['c', 'd'],
out_weight={'d': 100})
dsp.add_dispatcher(dsp=dsp_1.register(),
inputs={
'a': 'a',
'b': 'b'
},
outputs={'c': 'd'})
self.dsp_4 = dsp
dsp = sh.Dispatcher(raises='')
def f(a, b, c=0, f=0):
return a + b + c + f, a - b + c + f
dsp.add_data('h', 1)
dsp.add_function('f',
f,
inputs=['a', 'b', 'e', 'h'],
outputs=['c', sh.SINK])
dsp.add_data('i', 0, 10)
dsp.add_data('c', 100, 120)
dsp.add_function('f',
f,
inputs=['c', 'b', 'i'],
outputs=[sh.SINK, 'd'])
self.dsp_5 = dsp
def setUp(self):
dsp = sh.Dispatcher()
dsp.add_function(function=max, inputs=['a', 'b'], outputs=['c'])
dsp.add_function(function=min,
inputs=['c', 'b'],
outputs=['a'],
input_domain=lambda c, b: c * b > 0)
self.dsp_1 = dsp
dsp = sh.Dispatcher()
def f(a, b):
if b is None:
return a, sh.NONE
return a + b, a - b
dsp.add_function(function=f, inputs=['a', 'b'], outputs=['c', sh.SINK])
dsp.add_function(function=f, inputs=['c', 'b'], outputs=[sh.SINK, 'd'])
self.dsp_2 = dsp
dsp = sh.Dispatcher()
dsp.add_function(function=f,
inputs=['a', 'b'],
outputs=['c', 'd'],
out_weight={'d': 100})
dsp.add_dispatcher(dsp=self.dsp_1.copy(),
inputs={
'a': 'a',
'b': 'b'
},
outputs={'c': 'd'})
self.dsp_3 = dsp
dsp = sh.Dispatcher()
dsp.add_function(function=sh.SubDispatchFunction(
self.dsp_3, 'f', ['b', 'a'], ['c', 'd']),
inputs=['b', 'a'],
outputs=['c', 'd'],
out_weight={'d': 100})
dsp.add_dispatcher(dsp=self.dsp_1.copy(),
inputs={
'a': 'a',
'b': 'b'
},
outputs={'c': 'd'})
self.dsp_4 = dsp
dsp = sh.Dispatcher()
def f(a, b, c=0, f=0):
return a + b + c + f, a - b + c + f
dsp.add_data('h', 1)
dsp.add_function(function=f,
inputs=['a', 'b', 'e', 'h'],
outputs=['c', sh.SINK])
dsp.add_data('i', 0, 10)
dsp.add_data('c', 100, 120)
dsp.add_function(function=f,
inputs=['c', 'b', 'i'],
outputs=[sh.SINK, 'd'])
self.dsp_5 = dsp
dsp = sh.Dispatcher()
def f(a=0):
return a
dsp.add_func(f, outputs=['c'])
dsp.add_func(f,
inputs_kwargs=True,
outputs=['d'],
inputs_defaults=True)
def g(x, y=0):
return x + y
dsp.add_func(g,
outputs=['z'],
inputs_kwargs=True,
inputs_defaults=True)
self.dsp_6 = dsp
'timestamp'
],
outputs=['output_file_name'],
input_domain=check_first_arg_false)
if _dice is not None:
dsp.add_data('co2mpas_version', __version__)
_out, _inp = ['output_file_name', 'output_file'], [
'excel_input', 'base', 'start_time', 'excel_output', 'output_folder',
'report', 'encryption_keys', 'meta', 'sign_key', 'dice', 'timestamp',
'co2mpas_version'
]
# noinspection PyProtectedMember,PyTypeChecker
dsp.add_function(function=sh.Blueprint(
sh.SubDispatchFunction(_dice, inputs=_inp,
outputs=_out))._set_cls(sh.add_args),
function_id='write_ta_output',
description='Write ta output file.',
inputs=['type_approval_mode', 'input_file'] + _inp[1:],
outputs=_out,
input_domain=check_first_arg)
else:
dsp.add_data('base', description='Base data.')
dsp.add_data('excel_input', description='Excel input file.')
dsp.add_data('encryption_keys', description='Encryption keys for TA mode.')
dsp.add_data('meta', description='Meta data.')
dsp.add_data('sign_key', description='User signature key for TA mode.')
@sh.add_function(dsp)
def save_output_file(output_file, output_file_name):
ext=('.dill', )))
dsp.add_function(function=parse_excel_file,
inputs=['input_file_name', 'input_file'],
outputs=['raw_data'],
input_domain=check_file_format)
if _dice is not None:
_out, _inp = ['base', 'meta', 'dice'], [
'input_file_name', 'input_file', 'encryption_keys',
'encryption_keys_passwords'
]
# noinspection PyProtectedMember
dsp.add_function(function=sh.Blueprint(
sh.SubDispatchFunction(_dice,
function_id='load_ta_file',
inputs=_inp[1:],
outputs=_out))._set_cls(sh.add_args),
description='Load inputs from .co2mpas.ta file.',
inputs=_inp,
outputs=['raw_data'],
filters=[functools.partial(sh.map_list, [_out])],
input_domain=functools.partial(check_file_format,
ext=('.co2mpas.ta', )))
_out, _inp = ['data', 'dice'], ['input_file_name', 'input_file']
# noinspection PyProtectedMember
dsp.add_function(function=sh.Blueprint(
sh.SubDispatchFunction(_dice, inputs=_inp[1:],
outputs=_out))._set_cls(sh.add_args),
function_id='load_co2mpas_file',
description='Load inputs from .co2mpas file.',
