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)
