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.',