def _prepare_for_dict(key, value): """Convert an element in SimulatorSetup to be a serializable dict""" if key == 'attached_instruments' and value: return {mount.name.lower(): data for (mount, data) in value.items()} if key == 'config' and value: return robot_configs.config_to_save(value)[1] return value
def test_dictify_roundtrip(): new_settings = copy.deepcopy(dummy_settings) new_settings['tip_probe']['dimensions']\ = robot_configs._default_probe_dimensions() new_settings['tip_probe']['center']\ = robot_configs._default_probe_center() built_config = robot_configs.build_config(dummy_cal, dummy_settings) new_cal, new_config = robot_configs.config_to_save(built_config) assert new_cal == dummy_cal assert new_config == new_settings new_config = robot_configs.build_config(new_cal, new_config) assert new_config == built_config
def test_update_instrument_config(fixture): from opentrons.trackers.pose_tracker import change_base from numpy import array import json robot = fixture.robot inst = fixture.instrument inst_offset = robot.config.instrument_offset[inst.mount][inst.type] cfg = update_instrument_config(instrument=inst, measured_center=(0.0, 0.0, 105.0)) new_tip_length = cfg.tip_length[inst.name] new_instrument_offset = cfg.instrument_offset[inst.mount][inst.type] assert new_tip_length == 55.0 assert new_instrument_offset == tuple(array(inst_offset) + (5.0, 5.0, 0.0)) assert tuple(change_base( robot.poses, src=inst, dst=inst.instrument_mover)) == (5.0, 5.0, 0), \ "Expected instrument position to update relative to mover in pose tree" filename = CONFIG['robot_settings_file'] _, expected = robot_configs.config_to_save( robot_configs.build_config([[]], {})) expected['instrument_offset']['right']['single'] = [5.0, 5.0, 0.0] expected['tip_length']['Pipette'] = 55.0 with open(filename, 'r') as file: actual = json.load(file) # from pprint import pprint # print('=------> <------=') # print("Expected:") # pprint(expected) # print() # print("Actual:") # pprint(actual) # print() assert actual == expected
}, deserializer=lambda json_dict: { top_types.Mount[mount_name.upper()]: pipette_info for mount_name, pipette_info in json_dict.items() }), Dict[types.Axis, bool]: SerDes( serializer=lambda axisdict: {ax.name: engaged for ax, engaged in axisdict.items()}, deserializer=lambda namedict: {types.Axis[ax.upper()]: engaged for ax, engaged in namedict.items()}), robot_configs.robot_config: SerDes( serializer=lambda config: list(robot_configs.config_to_save(config)), deserializer=lambda clist: robot_configs.build_config(*clist)), List[types.Axis]: SerDes( serializer=lambda axlist: [ax.name for ax in axlist], deserializer=lambda namelist: [types.Axis[name] for name in namelist]), } def _build_serializable_method(method_name, method): # noqa(C901) """ Build the method to actually server over jsonrpc. To serve over jsonrpc, we need to have an interface that is fully json-serializable. Since serving over jsonrpc is a secondary task of the hardware controller, we don't want to make all the hc methods json serializable because that would take away from the readability of rich
(Mount, Mount.LEFT, 'LEFT'), (Axis, Axis.A, 'A'), (CriticalPoint, CriticalPoint.NOZZLE, 'NOZZLE'), (Point, Point(1, 2, 3), [1, 2, 3]), (Dict[Mount, str], { Mount.LEFT: 'way hay' }, { 'LEFT': 'way hay' }), (Dict[Axis, bool], { Axis.X: True }, { 'X': True }), (robot_configs.robot_config, robot_configs.load(), list(robot_configs.config_to_save(robot_configs.load()))), (Dict[Mount, Pipette.DictType], { Mount.LEFT: { 'asdasd': 2, 'asda': False } }, { 'LEFT': { 'asdasd': 2, 'asda': False } }), (List[Axis], [Axis.X, Axis.A], ['X', 'A']), (Optional[CriticalPoint], None, None), (Optional[CriticalPoint], CriticalPoint.NOZZLE, 'NOZZLE'), ])