def _helper_offset_data_format(filepath: str, delta: 'Point') -> dict: if not Path(filepath).is_file(): calibration_data = { "default": { "offset": [delta.x, delta.y, delta.z], "lastModified": utc_now() } } else: calibration_data = io.read_cal_file(filepath) calibration_data['default']['offset'] = [delta.x, delta.y, delta.z] calibration_data['default']['lastModified'] =\ utc_now() return calibration_data
def test_json_datetime_encoder(): fake_time = utc_now() original = {'mock_hash': {'tipLength': 25.0, 'lastModified': fake_time}} encoded = json.dumps(original, cls=ed.DateTimeEncoder) decoded = json.loads(encoded, cls=ed.DateTimeDecoder) assert decoded == original
async def set_system_time(new_time_dt: datetime, loop: asyncio.AbstractEventLoop = None) -> datetime: """ Set the system time unless system time is already being synchronized using an RTC or NTPsync. Raise error with message, if any. :return: current date read. """ if not IS_ROBOT: raise errors.SystemSetTimeException( msg="Not supported on dev server.", definition=CommonErrorDef.NOT_IMPLEMENTED) status = await _time_status(loop) if status.get('LocalRTC') is True or status.get('NTPSynchronized') is True: # TODO: Update this to handle RTC sync correctly once we introduce RTC raise errors.SystemTimeAlreadySynchronized( 'Cannot set system time; already synchronized with NTP or RTC') else: new_time_dt = new_time_dt.astimezone(tz=timezone.utc) new_time_str = new_time_dt.strftime("%Y-%m-%d %H:%M:%S") log.info(f'Setting time to {new_time_str} UTC') _, err = await _set_time(new_time_str) if err: raise errors.SystemSetTimeException(err) return utc_now()
async def create_access_token() -> access.AccessTokenResponse: token = secrets.token_urlsafe(nbytes=8) # TODO Store the token return access.AccessTokenResponse( data=access.ResponseDataModel.create( attributes=access.AccessTokenInfo( token=token, createdAt=utc_now()), resource_id=token, ))
def test_load_malformed_calibration(ot_config_tempdir): pathway = config.get_opentrons_path( 'robot_calibration_dir') / 'deck_calibration.json' data = { 'atsadasitude': [[1, 0, 1], [0, 1, -.5], [0, 0, 1]], 'last_modified': utc_now(), 'tiprack': 'hash', 'statu': [1, 2, 3], } io.save_to_file(pathway, data) obj = robot_calibration.load_attitude_matrix() assert np.allclose(obj.attitude, [[1, 0, 0], [0, 1, 0], [0, 0, 1]])
def test_load_calibration(ot_config_tempdir): pathway = config.get_opentrons_path( 'robot_calibration_dir') / 'deck_calibration.json' data = { 'attitude': [[1, 0, 1], [0, 1, -.5], [0, 0, 1]], 'pipette_calibrated_with': 'fake', 'last_modified': utc_now(), 'tiprack': 'hash' } io.save_to_file(pathway, data) obj = robot_calibration.load_attitude_matrix() transform = [[1, 0, 1], [0, 1, -.5], [0, 0, 1]] assert np.allclose(obj.attitude, transform)
def save_robot_deck_attitude(transform: local_types.AttitudeMatrix, pip_id: typing.Optional[str], lw_hash: typing.Optional[str]): robot_dir = config.get_opentrons_path('robot_calibration_dir') robot_dir.mkdir(parents=True, exist_ok=True) gantry_path = robot_dir / 'deck_calibration.json' gantry_dict: 'DeckCalibrationData' = { 'attitude': transform, 'pipette_calibrated_with': pip_id, 'last_modified': utc_now(), 'tiprack': lw_hash } io.save_to_file(gantry_path, gantry_dict)
async def on_protocol_event(self, cmd: typing.Any): """worker listener callback""" # These are broker notifications from Session object. topic = cmd.get('topic') if topic == Session.TOPIC: payload = cmd.get('payload') if isinstance(payload, dict): self.current_state = payload.get('state') elif hasattr(payload, 'state'): self.current_state = payload.state else: dollar_val = cmd.get('$') event_name = cmd.get('name') event = None if dollar_val == 'before': # text may be a format string using the payload vals as kwargs text = deep_get(cmd, ('payload', 'text',), "") if text: text = text.format(**cmd.get('payload', {})) event = models.ProtocolSessionEvent( source=models.EventSource.protocol_event, event=f'{event_name}.start', commandId=self._id_maker.create_id(), params={'text': text}, timestamp=utc_now(), ) elif dollar_val == 'after': result = deep_get(cmd, ('payload', 'return',)) event = models.ProtocolSessionEvent( source=models.EventSource.protocol_event, event=f'{event_name}.end', commandId=self._id_maker.use_last_id(), timestamp=utc_now(), result=result, ) if event: self._events.append(event)
def save_pipette_calibration(offset: 'Point', pip_id: str, mount: Mount, tiprack_hash: str, tiprack_uri: str): pip_dir = config.get_opentrons_path( 'pipette_calibration_dir') / mount.name.lower() pip_dir.mkdir(parents=True, exist_ok=True) offset_path = pip_dir / f'{pip_id}.json' offset_dict: 'PipetteCalibrationData' = { 'offset': [offset.x, offset.y, offset.z], 'tiprack': tiprack_hash, 'uri': tiprack_uri, 'last_modified': utc_now(), } io.save_to_file(offset_path, offset_dict) _add_to_pipette_offset_index_file(pip_id, mount)
def test_load_tip_length_calibration_v1(robot): lw = containers_load(robot, 'opentrons_96_tiprack_10ul', '1') hash = lw.properties['labware_hash'] tip_length_data = {'tipLength': 19.99, 'lastModified': utc_now()} tip_length_cal = {hash: tip_length_data} pip_id = 'fake_id' modify.save_tip_length_calibration(pip_id=pip_id, tip_length_cal=tip_length_cal) result = load_tip_length_calibration(pip_id, lw.wells('A1')) assert result == tip_length_data delete.clear_tip_length_calibration() # clean up
def test_load_pipette_offset(ot_config_tempdir): pip_id = 'fakePip' mount = Mount.LEFT pip_dir = config.get_opentrons_path('pipette_calibration_dir') / 'left' pip_dir.mkdir(parents=True, exist_ok=True) pathway = pip_dir / 'fakePip.json' data = { 'offset': [1, 2, 3], 'tiprack': 'hash', 'uri': 'opentrons/opentrons_96_tiprack_10ul/1', 'last_modified': utc_now() } io.save_to_file(pathway, data) obj = robot_calibration.load_pipette_offset(pip_id, mount) offset = [1, 2, 3] assert np.allclose(obj.offset, offset)
def add(self, support_file: UploadFile): """Add a support file to protocol temp directory""" temp_dir = Path(self._meta.directory.name) path = temp_dir / support_file.filename if path.exists(): raise ProtocolAlreadyExistsException( f"File {support_file.filename} already exists" ) file_meta = save_upload(directory=temp_dir, upload_file=support_file) self._meta = replace( self._meta, support_files=self._meta.support_files + [file_meta], last_modified_at=utc_now() )
def test_create_tip_length_calibration_data(monkeypatch): fake_time = utc_now() monkeypatch.setattr(modify, 'utc_now', lambda: fake_time) monkeypatch.setattr( helpers, 'hash_labware_def', mock_hash_labware) tip_length = 22.0 parent = '' expected_data = { MOCK_HASH: { 'tipLength': tip_length, 'lastModified': fake_time } } result = modify.create_tip_length_data( minimalLabwareDef, parent, tip_length) assert result == expected_data
def test_schema_shape(monkeypatch, clear_calibration): fake_time = utc_now() time_string = fake_time.isoformat() from_iso = datetime.datetime.fromisoformat(time_string) class fake_datetime: @classmethod def fromisoformat(cls, obj): return from_iso @classmethod def isoformat(cls): return time_string mock = Mock(spec=fake_datetime) mock.__class__ = datetime.datetime test_labware = labware.Labware(minimalLabwareDef, Location(Point(0, 0, 0), 'deck')) monkeypatch.setattr( helpers, 'hash_labware_def', mock_hash_labware ) expected = {"default": {"offset": [1, 1, 1], "lastModified": fake_time}} def fake_helper_data(path, delta): return expected monkeypatch.setattr( modify, '_helper_offset_data_format', fake_helper_data ) labware.save_calibration(test_labware, Point(1, 1, 1)) with open(path(MOCK_HASH)) as f: result = json.load(f, cls=ed.DateTimeDecoder) assert result == expected
def create_tip_length_data(definition: 'LabwareDefinition', parent: str, length: float) -> 'PipTipLengthCalibration': """ Function to correctly format tip length data. :param definition: full labware definition :param parent: the slot associated with the tiprack [not yet implemented, so it is always an empty string] :param length: the tip length to save """ # TODO(lc, 07-14-2020) since we're trying not to utilize # a labware object for these functions, the is tiprack # check should happen outside of this function. # assert labware._is_tiprack, \ # 'cannot save tip length for non-tiprack labware' labware_hash = helpers.hash_labware_def(definition) tip_length_data: 'TipLengthCalibration' = { 'tipLength': length, 'lastModified': utc_now() } data = {labware_hash + parent: tip_length_data} return data
async def get_system_time(loop: asyncio.AbstractEventLoop = None) -> datetime: """ :return: Just the system time as a UTC datetime object. """ return utc_now()
def __enter__(self): self.start = utc_now() return self
def __exit__(self, exc_type, exc_val, exc_tb): self.end = utc_now()