def test_get_doc(self): _setup() def getdocl(obj, name, encoding=None): global directive from schedula.ext.dispatcher.documenter import DispatcherDocumenter inst = DispatcherDocumenter(directive, name) inst.objpath = [name] inst.object = obj ds = inst.get_doc(encoding) # for testing, concat them and strip the empty line at the end. res = sum(ds, [])[:-1] return res # objects without docstring dsp_local = sh.Dispatcher() self.assertEqual(getdocl(dsp_local, 'dsp_local'), []) dsp_local = sh.Dispatcher(description='Description') res = getdocl(dsp_local, 'dsp_local') self.assertEqual(res, ['Description']) dsp_local.__doc__ = 'First line\n\nOther\n lines' res = getdocl(dsp_local, 'dsp_local') self.assertEqual(res, ['First line', '', 'Other', ' lines'])
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 setUp(self): import functools 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.DispatchPipe(ss_dsp, 'func', ['e', 'a'], ['c', 'd', 'b']) sub_disfun = sh.add_args(functools.partial(ss_dsp_func, 5)) s_dsp = sh.Dispatcher() s_dsp.add_data('a', 1) s_dsp.add_data('d', 4) s_dsp.add_function('sub_dispatch', sub_disfun, ['d', 'a'], ['b', 'c', sh.SINK]) dispatch = sh.SubDispatch(s_dsp, ['b', 'c', 'a'], output_type='list') self.dsp = dsp = sh.Dispatcher() dsp.add_data('input', default_value={'a': 3}) dsp.add_function('dispatch', dispatch, ['input'], [sh.SINK, 'h', 'i'], inp_weight={'input': 4}, out_weight={ 'h': 3, 'i': 6 }) dsp.add_function('fun', lambda: None, None, ['j']) dsp.add_dispatcher(s_dsp, inputs=('a', ), outputs=('b', 'c'), include_defaults=True)
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 thermal(): """ Defines the gear box thermal sub model. .. dispatcher:: d >>> d = thermal() :return: The gear box thermal sub model. :rtype: schedula.Dispatcher """ d = sh.Dispatcher(name='Gear box thermal sub model', description='Calculates temperature, efficiency, ' 'torque loss of gear box') from ..defaults import dfl d.add_data(data_id='gear_box_temperature_references', default_value=dfl.values.gear_box_temperature_references) d.add_function(function=calculate_gear_box_torque_in, inputs=[ 'gear_box_torque_out', 'gear_box_speed_in', 'gear_box_speed_out', 'gear_box_temperature', 'gear_box_efficiency_parameters_cold_hot', 'gear_box_temperature_references' ], outputs=['gear_box_torque_in<0>']) d.add_function(function=correct_gear_box_torque_in, inputs=[ 'gear_box_torque_out', 'gear_box_torque_in<0>', 'gear', 'gear_box_ratios' ], outputs=['gear_box_torque_in']) d.add_function( function=calculate_gear_box_efficiency, inputs=[ 'gear_box_power_out', 'gear_box_speed_in', 'gear_box_torque_out', 'gear_box_torque_in' ], outputs=['gear_box_efficiency'], ) d.add_function( function=calculate_gear_box_heat, inputs=['gear_box_efficiency', 'gear_box_power_out', 'delta_time'], outputs=['gear_box_heat']) d.add_function(function=calculate_gear_box_temperature, inputs=[ 'gear_box_heat', 'gear_box_temperature', 'equivalent_gear_box_heat_capacity', 'thermostat_temperature' ], outputs=['gear_box_temperature']) return d
def test_invalid(self, case): reference, formula, inputs = case with self.assertRaises(sh.DispatcherError): dsp = sh.Dispatcher(raises=True) cell = Cell(reference, formula).compile() assert cell.add(dsp) dsp(inputs)
def __init__(self, dsp=None, nodes=None, match=None): self._deque = collections.deque() self.match = match self.dsp = dsp or sh.Dispatcher(raises=lambda e: not isinstance( e, (NotImplementedError, RangeValueError, InvalidRangeError))) self.nodes = nodes or {} self.missing_operands = set()
def _range2parts(inputs, outputs): dsp = sh.Dispatcher() dsp.add_data(data_id='cr', default_value='1') dsp.add_data(data_id='cc', default_value='1') dsp.add_function('relative2absolute', _sum, ['cr', 'rr1'], ['r1']) dsp.add_function('relative2absolute', _sum, ['cc', 'rc1'], ['n1']) dsp.add_function('relative2absolute', _sum, ['cr', 'rr2'], ['r2']) dsp.add_function('relative2absolute', _sum, ['cc', 'rc2'], ['n2']) dsp.add_function(function=_index2col, inputs=['n1'], outputs=['c1']) dsp.add_function(function=_index2col, inputs=['n2'], outputs=['c2']) dsp.add_function(function=_col2index, inputs=['c1'], outputs=['n1']) dsp.add_function(function=_col2index, inputs=['c2'], outputs=['n2']) dsp.add_function(function=sh.bypass, inputs=['c1'], outputs=['c2']) dsp.add_function(function=sh.bypass, inputs=['r1'], outputs=['r2']) dsp.add_function(function=lambda x, y: x[y], inputs=['external_links', 'excel_id'], outputs=['excel']) dsp.add_function(function=sh.bypass, weight=1, inputs=['excel_id'], outputs=['excel']) dsp.add_data(data_id='excel', filters=(str.upper, )) dsp.add_data(data_id='sheet', default_value='', filters=(str.upper, )) dsp.add_data(data_id='ref', filters=(str.upper, )) dsp.add_data(data_id='name', filters=(str.upper, )) dsp.add_data(data_id='n1', default_value=0, initial_dist=100) dsp.add_data(data_id='r1', default_value='0', initial_dist=100) dsp.add_data(data_id='c2', default_value=_maxcol(), initial_dist=100) dsp.add_data(data_id='r2', default_value=_maxrow(), initial_dist=100) dsp.add_function(None, _build_ref, ['c1', 'r1', 'c2', 'r2'], ['ref']) dsp.add_function(None, _build_id, ['ref', 'sheet', 'excel'], ['name']) func = sh.DispatchPipe(dsp, '', inputs, outputs) func.output_type = 'all' return func
def test_output(self, case): reference, formula, inputs, result = case dsp = sh.Dispatcher() cell = Cell(reference, formula).compile() assert cell.add(dsp) output = str(dsp(inputs)[cell.output]) self.assertEqual(result, output, '{} != {}'.format(result, output))
def __init__(self, dsp=None, nodes=None, match=None): self._deque = collections.deque() self.match = match self.dsp = dsp or sh.Dispatcher(raises=lambda ex: not isinstance( ex, (FormulaError, RangeValueError))) self.nodes = nodes or {} self.missing_operands = set()
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 _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 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 torque_converter(): """ Defines the torque converter model. .. dispatcher:: d >>> d = torque_converter() :return: The torque converter model. :rtype: schedula.Dispatcher """ d = sh.Dispatcher(name='Torque_converter', description='Models the torque converter.') from ..defaults import dfl d.add_data(data_id='calibration_tc_speed_threshold', default_value=dfl.values.calibration_tc_speed_threshold) d.add_data(data_id='stop_velocity', default_value=dfl.values.stop_velocity) d.add_data(data_id='lock_up_tc_limits', default_value=dfl.values.lock_up_tc_limits) d.add_function(function=identify_torque_converter_speeds_delta, inputs=[ 'engine_speeds_out', 'engine_speeds_out_hot', 'cold_start_speeds_delta' ], outputs=['torque_converter_speeds_delta']) d.add_function(function=calibrate_torque_converter_model, inputs=[ 'times', 'lock_up_tc_limits', 'calibration_tc_speed_threshold', 'stop_velocity', 'torque_converter_speeds_delta', 'accelerations', 'velocities', 'gear_box_speeds_in', 'gears' ], outputs=['torque_converter_model']) d.add_function(function=predict_torque_converter_speeds_delta, inputs=[ 'times', 'lock_up_tc_limits', 'torque_converter_model', 'accelerations', 'velocities', 'gear_box_speeds_in', 'gears' ], outputs=['torque_converter_speeds_delta']) from . import define_k_factor_curve d.add_function(function=define_k_factor_curve, inputs=['stand_still_torque_ratio', 'lockup_speed_ratio'], outputs=['k_factor_curve']) d.add_function(function=default_tc_k_factor_curve, outputs=['k_factor_curve'], weight=2) return d
def test_impure(self, case): reference, formula, dt = case dsp = sh.Dispatcher() cell = Cell(reference, formula).compile() assert cell.add(dsp) out = str(dsp()[cell.output]) time.sleep(dt) self.assertNotEqual(out, str(dsp()[cell.output]))
def wltp_cycle(): """ Defines the wltp cycle model. .. dispatcher:: d >>> d = wltp_cycle() :return: The wltp cycle model. :rtype: schedula.Dispatcher """ d = sh.Dispatcher( name='WLTP cycle model', description='Returns the theoretical times, velocities, and gears of ' 'WLTP.') from ..defaults import dfl d.add_data(data_id='initial_temperature', default_value=dfl.values.initial_temperature_WLTP, description='Initial temperature of the test cell [°C].') d.add_data(data_id='max_time', default_value=dfl.values.max_time_WLTP, description='Maximum time [s].', initial_dist=5) d.add_data(data_id='wltp_base_model', default_value=copy.deepcopy(dfl.values.wltp_base_model)) d.add_function(function=define_wltp_base_model, inputs=['wltp_base_model'], outputs=['base_model']) d.add_dispatcher( dsp=calculate_wltp_velocities(), inputs=('times', 'base_model', 'velocities', 'speed_velocity_ratios', 'inertial_factor', 'downscale_phases', 'climbing_force', 'downscale_factor', 'downscale_factor_threshold', 'vehicle_mass', 'unladen_mass', 'road_loads', 'engine_max_power', 'engine_speed_at_max_power', 'max_velocity', 'wltp_class', 'max_speed_velocity_ratio'), outputs=('velocities', )) d.add_function(function=sh.add_args(wltp_gears), inputs=[ 'gear_box_type', 'full_load_curve', 'velocities', 'accelerations', 'motive_powers', 'speed_velocity_ratios', 'idle_engine_speed', 'engine_speed_at_max_power', 'engine_max_power', 'engine_max_speed', 'base_model' ], outputs=['gears'], input_domain=lambda *args: args[0] == 'manual', weight=10) return d
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, 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_2 = dsp dsp = sh.Dispatcher() def f(a=0): return a dsp.add_func(f, outputs=['c'], weight=1) 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_3 = 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 test_load_map(self): sh.save_map(self.dsp, self.tmp) dsp = sh.Dispatcher(default_values=self.dsp.default_values) sh.load_map(dsp, self.tmp) self.assertEqual(dsp.dmap.degree(self.fun_id), self.dsp.dmap.degree(self.fun_id)) self.assertEqual(dsp.dmap.nodes[self.fun_id]['function'](1), 2) self.assertEqual(dsp.dispatch()['b'], 6)
def setUp(self): dsp = sh.Dispatcher() dsp.add_function('max', max, inputs=['a', 'b'], outputs=['c']) dsp.add_function('min', 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, 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_2 = dsp dsp = sh.Dispatcher() def f(a=0): return a dsp.add_function('f', f, outputs=['c'], weight=1) dsp.add_data('a', 0) dsp.add_function('f', f, ['a'], outputs=['d']) def g(x, y=0): return x + y dsp.add_data('y', 0) dsp.add_function('g', g, ['x', 'y'], outputs=['z']) self.dsp_3 = dsp
def hex2dec2bin2oct(function_id): dsp = sh.Dispatcher() for k in ('HEX', 'OCT', 'BIN'): dsp.add_data(k, filters=[_parseX]) dsp.add_function( function_id='HEX2DEC', function=_x2dec, inputs=['HEX'], outputs=['DEC'] ) dsp.add_function( function_id='OCT2DEC', function=functools.partial(_x2dec, base=8), inputs=['OCT'], outputs=['DEC'] ) dsp.add_function( function_id='BIN2DEC', function=functools.partial(_x2dec, base=2), inputs=['BIN'], outputs=['DEC'] ) dsp.add_function( function_id='DEC2HEX', function=_dec2x, inputs=['DEC', 'places'], outputs=['HEX'] ) dsp.add_function( function_id='DEC2OCT', function=functools.partial(_dec2x, base=8), inputs=['DEC', 'places'], outputs=['OCT'] ) dsp.add_function( function_id='DEC2BIN', function=functools.partial(_dec2x, base=2), inputs=['DEC', 'places'], outputs=['BIN'] ) i, o = function_id.split('2') _func = sh.DispatchPipe(dsp, function_id, [i, 'places'], [o]) def func(x, places=None): return _func(x, places) return func
def setUp(self): sub_dsp = sh.Dispatcher() def fun(a): return a + 1, a - 1 sub_dsp.add_function('fun', fun, ['a'], ['b', 'c']) dispatch = sh.SubDispatch(sub_dsp, ['a', 'b', 'c']) dispatch_dict = sh.SubDispatch(sub_dsp, ['c'], output_type='dict') dispatch_list = sh.SubDispatch(sub_dsp, ['a', 'c'], output_type='list') dispatch_val = sh.SubDispatch(sub_dsp, ['c'], output_type='list') dsp = sh.Dispatcher() dsp.add_function('dispatch', dispatch, ['d'], ['e']) dsp.add_function('dispatch_dict', dispatch_dict, ['d'], ['f']) dsp.add_function('dispatch_list', dispatch_list, ['d'], ['g']) dsp.add_function('dispatch_val', dispatch_val, ['d'], ['h']) self.dsp = dsp
def setUp(self): dsp = sh.Dispatcher() dsp.add_data('a', default_value=5) def f(a): return a + 1 self.fun_id = dsp.add_function(function=f, inputs=['a'], outputs=['b']) self.dsp = dsp self.tmp = tempfile.mkstemp()[1]
def _selector(name, data_in, data_out, setting): d = sh.Dispatcher(name='%s selector' % name, description='Select the calibrated %s.' % name) errors, setting = [], setting or {} _sort_models = setting.pop('sort_models', sort_models) if 'weights' in setting: _weights = sh.map_list(setting.get('names', setting['targets']), *setting.pop('weights')) else: _weights = None _get_best_model = functools.partial(setting.pop('get_best_model', get_best_model), models_wo_err=setting.pop( 'models_wo_err', None), selector_id=d.name) d.add_data(data_id='selector_settings', default_value={}) node_ids = ['error_settings', 'best_model_settings'] d.add_function(function=functools.partial(define_selector_settings, node_ids=node_ids), inputs=['selector_settings'], outputs=node_ids) for i in data_in: e = 'error/%s' % i errors.append(e) d.add_function(function=_errors(name, i, data_out, setting), inputs=['error_settings', i] + [k for k in data_out if k != i], outputs=[e]) d.add_function(function_id='sort_models', function=functools.partial(_sort_models, weights=_weights), inputs=errors, outputs=['rank']) d.add_function(function_id='get_best_model', function=_get_best_model, inputs=['rank', 'best_model_settings'], outputs=['model', 'errors']) return sh.SubDispatch(d, outputs=['model', 'errors'], output_type='list')
def manual_gear(): """ Defines the manual gear shifting model. .. dispatcher:: d >>> d = manual_gear() :return: The manual gear shifting model. :rtype: schedula.Dispatcher """ dsp = sh.Dispatcher(name='manual gear shifting model', description='Models the manual gear shifting.') dsp.add_function(function=calculate_engine_max_speed_95, inputs=[ 'full_load_speeds', 'idle_engine_speed', 'engine_max_speed', 'full_load_curve', 'engine_max_power' ], outputs=['engine_max_speed_95']) dsp.add_function(function=define_MGS_and_MVL, inputs=[ 'full_load_curve', 'road_loads', 'velocity_speed_ratios', 'engine_max_speed_95', 'idle_engine_speed', 'engine_speed_at_max_power' ], outputs=['MGS', 'MVL']) dsp.add_function(function=correct_gear_v4, inputs=[ 'cycle_type', 'velocity_speed_ratios', 'MVL', 'idle_engine_speed', 'full_load_curve', 'engine_speed_at_max_power' ], outputs=['correct_gear']) dsp.add_function(function=prediction_gears_gsm_v1, inputs=[ 'correct_gear', 'MGS', 'times', 'velocities', 'accelerations', 'motive_powers' ], outputs=['gears']) return dsp
def cold_start(): """ Defines the engine cold start model. .. dispatcher:: d >>> d = cold_start() :return: The engine start/stop model. :rtype: schedula.Dispatcher """ d = sh.Dispatcher(name='cold_start', description='Models the engine cold start strategy.') d.add_function(function=identify_cold_start_speeds_phases, inputs=[ 'engine_coolant_temperatures', 'engine_thermostat_temperature', 'on_idle' ], outputs=['cold_start_speeds_phases']) d.add_function(function=identify_cold_start_speeds_delta, inputs=[ 'cold_start_speeds_phases', 'engine_speeds_out', 'engine_speeds_out_hot' ], outputs=['cold_start_speeds_delta']) d.add_function(function=calibrate_cold_start_speed_model, inputs=[ 'cold_start_speeds_phases', 'cold_start_speeds_delta', 'idle_engine_speed', 'on_engine', 'engine_coolant_temperatures', 'engine_speeds_out_hot' ], outputs=['cold_start_speed_model']) d.add_function(function=calculate_cold_start_speeds_delta, inputs=[ 'cold_start_speed_model', 'on_engine', 'engine_coolant_temperatures', 'engine_speeds_out_hot', 'idle_engine_speed' ], outputs=['cold_start_speeds_delta']) return d
def _range2parts(): dsp = sh.Dispatcher() dsp.add_data(data_id='cr', default_value='1') dsp.add_data(data_id='cc', default_value='1') dsp.add_function('relative2absolute', _sum, ['cr', 'rr1'], ['r1']) dsp.add_function('relative2absolute', _sum, ['cc', 'rc1'], ['n1']) dsp.add_function('relative2absolute', _sum, ['cr', 'rr2'], ['r2']) dsp.add_function('relative2absolute', _sum, ['cc', 'rc2'], ['n2']) dsp.add_function(function=_index2col, inputs=['n1'], outputs=['c1']) dsp.add_function(function=_index2col, inputs=['n2'], outputs=['c2']) dsp.add_function(function=_col2index, inputs=['c1'], outputs=['n1']) dsp.add_function(function=_col2index, inputs=['c2'], outputs=['n2']) dsp.add_function(function=sh_utl.bypass, inputs=['c1'], outputs=['c2']) dsp.add_function(function=sh_utl.bypass, inputs=['r1'], outputs=['r2']) dsp.add_function(function=lambda x, y: x[y], inputs=['external_links', 'excel_id'], outputs=['excel']) dsp.add_function(function=sh_utl.bypass, weight=1, inputs=['excel_id'], outputs=['excel']) dsp.add_data(data_id='excel', filters=(str.upper, )) dsp.add_data(data_id='sheet', default_value='', filters=(str.upper, )) dsp.add_data(data_id='ref', filters=(str.upper, )) dsp.add_data(data_id='name', filters=(str.upper, )) dsp.add_data(data_id='n1', default_value=0, initial_dist=100) dsp.add_data(data_id='r1', default_value='0', initial_dist=100) dsp.add_data(data_id='n2', default_value=maxsize, initial_dist=100) dsp.add_data(data_id='r2', default_value='%s' % maxsize, initial_dist=100) dsp.add_function(None, _build_ref, ['c1', 'r1', 'c2', 'r2'], ['ref']) dsp.add_function(None, _build_id, ['ref', 'sheet', 'excel'], ['name']) def wrap_dispatch(func): def wrapper(inputs, *args, **kwargs): if 'excel_id' in inputs: inputs = inputs.copy() inputs.pop('excel', None) elif 'excel' not in inputs: inputs = inputs.copy() inputs['excel'] = '' return func(inputs, *args, **kwargs) return functools.update_wrapper(wrapper, func) dsp.dispatch = wrap_dispatch(dsp.dispatch) return sh_utl.SubDispatch(dsp)
def test_format_signature(self): _setup() def formatsig(name, obj, args, retann): global directive from schedula.ext.dispatcher.documenter import DispatcherDocumenter inst = DispatcherDocumenter(directive, name) inst.fullname = name inst.doc_as_attr = False # for class objtype inst.object = obj inst.objpath = [name] inst.args = args inst.retann = retann res = inst.format_signature() return res # no signatures for dispatchers dsp = sh.Dispatcher() self.assertEqual(formatsig('dsp', dsp, None, None), '')
def crypto(): dsp = sh.Dispatcher() dsp.add_function(function=sh.bypass, inputs=['data', 'meta'], outputs=['data2encrypt']) dsp.add_function(function=encrypt_data, inputs=['encrypt_inputs', 'data2encrypt', 'path_keys'], outputs=['encrypted_data']) dsp.add_function(function=define_ta_id, inputs=['vehicle_family_id', 'data', 'report'], outputs=['ta_id']) dsp.add_function( function=extract_dice_report, inputs=['encrypt_inputs', 'vehicle_family_id', 'start_time', 'report'], outputs=['dice_report']) dsp.add_function(function=save_data, inputs=[ 'output_folder', 'timestamp', 'ta_id', 'dice_report', 'encrypted_data' ], outputs=['ta_file']) dsp.add_function(function=load_data, inputs=['ta_file'], outputs=['ta_id', 'dice_report', 'encrypted_data']) dsp.add_data('passwords', None) dsp.add_function(function=decrypt_data, inputs=['encrypted_data', 'path_keys', 'passwords'], outputs=['data2encrypt']) dsp.add_function(function=sh.bypass, inputs=['data2encrypt'], outputs=['data', 'meta']) return dsp
def run_plan(): """ Defines the plan model. .. dispatcher:: d >>> d = run_plan() :return: The plan model. :rtype: Dispatcher """ d = sh.Dispatcher(name='run_plan', description='Processes a vehicle plan.') d.add_data(data_id='engineering_mode', default_value=False) d.add_data(data_id='use_selector', default_value=False) d.add_data(data_id='soft_validation', default_value=False) d.add_function(function=sh.add_args(schema.validate_plan), inputs=[ 'run_plan', 'data', 'engineering_mode', 'soft_validation', 'use_selector' ], outputs=['validated_plan'], input_domain=check_first_arg) d.add_function(function=default_start_time, outputs=['start_time']) d.add_function(function=default_timestamp, inputs=['start_time'], outputs=['timestamp']) from .plan import make_simulation_plan d.add_function(function=make_simulation_plan, inputs=['validated_plan', 'timestamp', 'variation', 'flag'], outputs=['summary']) return sh.SubDispatch(d)