def _get_log_operations_from_value(self, value: Val, step: Optional[float], timestamp: float) -> List[Operation]: values = [ LogFloats.ValueType(val, step=step, ts=timestamp) for val in value.values ] return [ LogFloats(self._path, chunk) for chunk in split_to_chunks(values, 100) ]
def test_log_with_timestamp(self): value_step_and_expected = [ (13, 5.3, LogFloats.ValueType(13, None, 5.3)), (15.3, 10, LogFloats.ValueType(15.3, None, 10)), ] for value, ts, expected in value_step_and_expected: processor = MagicMock() exp, path, wait = ( self._create_run(processor), self._random_path(), self._random_wait(), ) var = FloatSeries(exp, path) var.log(value, timestamp=ts, wait=wait) processor.enqueue_operation.assert_called_once_with( LogFloats(path, [expected]), wait )
def visit_log_floats(self, op: LogFloats) -> None: self._process_modify_op( _DataType.FLOAT_SERIES, op, self._log_modifier( LogFloats, ClearFloatLog, lambda op1, op2: LogFloats(op1.path, op1.values + op2.values), ), )
def test_assign(self): value = FloatSeriesVal([17, 3.6], min=0, max=100, unit="%") expected = [ LogFloats.ValueType(17, None, self._now()), LogFloats.ValueType(3.6, None, self._now()), ] processor = MagicMock() exp, path, wait = ( self._create_run(processor), self._random_path(), self._random_wait(), ) var = FloatSeries(exp, path) var.assign(value, wait=wait) self.assertEqual(3, processor.enqueue_operation.call_count) processor.enqueue_operation.assert_has_calls( [ call(ConfigFloatSeries(path, min=0, max=100, unit="%"), False), call(ClearFloatLog(path), False), call(LogFloats(path, expected), wait), ] )
def send_hardware_metric_reports(self, experiment, metrics, metric_reports): operations = [] metrics_by_name = {metric.name: metric for metric in metrics} for report in metric_reports: metric = metrics_by_name.get(report.metric.name) gauges_count = len(metric.gauges) for gauge_name, metric_values in groupby( report.values, lambda value: value.gauge_name): metric_values = list(metric_values) path = parse_path( self._get_attribute_name_for_metric( metric.resource_type, gauge_name, gauges_count)) operations.append( LogFloats( path, [ LogFloats.ValueType( value.value, step=None, ts=value.timestamp) for value in metric_values ], )) self._execute_operations(experiment, operations)
def test_limit_exceed_legacy(self, swagger_client_factory): # given swagger_client = self._get_swagger_client_mock(swagger_client_factory) backend = HostedNeptuneBackend(credentials) container_uuid = str(uuid.uuid4()) # when: error = MagicMock() error.json.return_value = {"title": "Monitoring hours not left"} swagger_client.api.executeOperations.side_effect = HTTPUnprocessableEntity( response=error ) # then: for container_type in self.container_types: with self.subTest(msg=f"For type {container_type.value}"): with self.assertRaises(NeptuneLimitExceedException): backend.execute_operations( container_id=container_uuid, container_type=container_type, operations=[ LogFloats(["float1"], [LogFloats.ValueType(1, 2, 3)]), ], )
def test_get_float_series_values(self): # given for container_id, container_type in self.ids_with_types: with self.subTest(f"For containerType: {container_type}"): self.backend.execute_operations( container_id, container_type, [ LogFloats( ["x"], [ LogFloats.ValueType(5, None, time()), LogFloats.ValueType(3, None, time()), ], ) ], ) self.backend.execute_operations( container_id, container_type, [ LogFloats( ["x"], [ LogFloats.ValueType(2, None, time()), LogFloats.ValueType(9, None, time()), ], ) ], ) # when ret = self.backend.get_float_series_values(container_id, container_type, path=["x"], limit=100, offset=0) # then self.assertEqual( FloatSeriesValues( 4, [ FloatPointValue( timestampMillis=42342, step=0, value=5), FloatPointValue( timestampMillis=42342, step=1, value=3), FloatPointValue( timestampMillis=42342, step=2, value=2), FloatPointValue( timestampMillis=42342, step=3, value=9), ], ), ret, )
def test_log_with_step(self): value_step_and_expected = [ (13, 5.3, LogFloats.ValueType(13, 5.3, self._now())), (15.3, 10, LogFloats.ValueType(15.3, 10, self._now())), ([13], 5.3, LogFloats.ValueType(13, 5.3, self._now())), ((13,), 5.3, LogFloats.ValueType(13, 5.3, self._now())), ({13}, 5.3, LogFloats.ValueType(13, 5.3, self._now())), ] for value, step, expected in value_step_and_expected: processor = MagicMock() exp, path, wait = ( self._create_run(processor), self._random_path(), self._random_wait(), ) var = FloatSeries(exp, path) var.log(value, step=step, wait=wait) processor.enqueue_operation.assert_called_once_with( LogFloats(path, [expected]), wait )
def test_get_float_series_attribute(self): # given for container_id, container_type in self.ids_with_types: with self.subTest(f"For containerType: {container_type}"): self.backend.execute_operations( container_id, container_type, [ LogFloats( ["x"], [ LogFloats.ValueType(5, None, time()), LogFloats.ValueType(3, None, time()), ], ) ], ) self.backend.execute_operations( container_id, container_type, [ LogFloats( ["x"], [ LogFloats.ValueType(2, None, time()), LogFloats.ValueType(9, None, time()), ], ) ], ) # when ret = self.backend.get_float_series_attribute( container_id, container_type, ["x"]) # then self.assertEqual(FloatSeriesAttribute(9), ret)
def test_series(self): # given processor = OperationsPreprocessor() # when processor.process([ LogFloats(["a"], [FLog(1, 2, 3)]), ConfigFloatSeries(["a"], min=7, max=70, unit="%"), DeleteAttribute(["a"]), LogStrings(["a"], [SLog("111", 3, 4)]), DeleteAttribute(["b"]), LogStrings(["b"], [SLog("222", None, 6)]), LogFloats(["c"], [FLog(1, 2, 3)]), LogFloats(["c"], [FLog(10, 20, 30), FLog(100, 200, 300)]), LogStrings(["d"], [SLog("4", 111, 222)]), ClearFloatLog(["e"]), LogImages(["f"], [ILog("1", 2, 3)]), LogImages( ["f"], [ILog("10", 20, 30), FLog("100", 200, 300)]), LogImages(["f"], [ILog("1", 2, 3)]), LogImages( ["f"], [ILog("10", 20, 30), FLog("100", 200, 300)]), ClearImageLog(["f"]), LogImages( ["f"], [ILog("3", 20, 30), FLog("4", 200, 300)]), LogImages(["f"], [ILog("5", 2, 3)]), LogImages( ["f"], [ILog("8", 20, 30), FLog("1000", 200, 300)]), LogImages( ["g"], [ILog("10", 20, 30), FLog("100", 200, 300)]), ClearImageLog(["g"]), AssignString(["h"], "44"), LogFloats(["h"], [FLog(10, 20, 30), FLog(100, 200, 300)]), LogFloats(["i"], [FLog(1, 2, 3)]), ConfigFloatSeries(["i"], min=7, max=70, unit="%"), ClearFloatLog(["i"]), LogFloats(["i"], [FLog(10, 20, 30), FLog(100, 200, 300)]), ]) # then self.assertEqual( processor.get_operations(), [ LogFloats(["a"], [FLog(1, 2, 3)]), DeleteAttribute(["a"]), LogStrings(["a"], [FLog("111", 3, 4)]), DeleteAttribute(["b"]), LogStrings(["b"], [SLog("222", None, 6)]), LogFloats( ["c"], [FLog(1, 2, 3), FLog(10, 20, 30), FLog(100, 200, 300)]), LogStrings(["d"], [SLog("4", 111, 222)]), ClearFloatLog(["e"]), ClearImageLog(["f"]), LogImages( ["f"], [ ILog("3", 20, 30), FLog("4", 200, 300), ILog("5", 2, 3), ILog("8", 20, 30), FLog("1000", 200, 300), ], ), ClearImageLog(["g"]), AssignString(["h"], "44"), ClearFloatLog(["i"]), LogFloats(["i"], [FLog(10, 20, 30), FLog(100, 200, 300)]), ConfigFloatSeries(["i"], min=7, max=70, unit="%"), ], ) self.assertEqual( processor.get_errors(), [ MetadataInconsistency( "Cannot perform LogFloats operation on h: Attribute is not a Float Series" ) ], )
def test_execute_operations(self, upload_mock, swagger_client_factory): # given swagger_client = self._get_swagger_client_mock(swagger_client_factory) backend = HostedNeptuneBackend(credentials) container_uuid = str(uuid.uuid4()) response_error = MagicMock() response_error.errorDescription = "error1" swagger_client.api.executeOperations().response().result = [response_error] swagger_client.api.executeOperations.reset_mock() upload_mock.return_value = [FileUploadError("file1", "error2")] some_text = "Some streamed text" some_binary = b"Some streamed binary" for container_type in self.container_types: with self.subTest(msg=f"For type {container_type.value}"): upload_mock.reset_mock() swagger_client_factory.reset_mock() # when result = backend.execute_operations( container_id=container_uuid, container_type=container_type, operations=[ UploadFile( path=["some", "files", "some_file"], ext="", file_path="path_to_file", ), UploadFileContent( path=["some", "files", "some_text_stream"], ext="txt", file_content=base64_encode(some_text.encode("utf-8")), ), UploadFileContent( path=["some", "files", "some_binary_stream"], ext="bin", file_content=base64_encode(some_binary), ), LogFloats(["images", "img1"], [LogFloats.ValueType(1, 2, 3)]), AssignString(["properties", "name"], "some text"), UploadFile( path=["some", "other", "file.txt"], ext="txt", file_path="other/file/path.txt", ), ], ) # then swagger_client.api.executeOperations.assert_called_once_with( **{ "experimentId": str(container_uuid), "operations": [ { "path": "images/img1", "logFloats": { "entries": [ { "value": 1, "step": 2, "timestampMilliseconds": 3000, } ] }, }, { "path": "properties/name", "assignString": {"value": "some text"}, }, ], **DEFAULT_REQUEST_KWARGS, } ) upload_mock.assert_has_calls( [ call( swagger_client=backend.leaderboard_client, container_id=container_uuid, attribute="some/other/file.txt", source="other/file/path.txt", ext="txt", multipart_config=backend._client_config.multipart_config, ), call( swagger_client=backend.leaderboard_client, container_id=container_uuid, attribute="some/files/some_file", source="path_to_file", ext="", multipart_config=backend._client_config.multipart_config, ), call( swagger_client=backend.leaderboard_client, container_id=container_uuid, attribute="some/files/some_text_stream", source=some_text.encode("utf-8"), ext="txt", multipart_config=backend._client_config.multipart_config, ), call( swagger_client=backend.leaderboard_client, container_id=container_uuid, attribute="some/files/some_binary_stream", source=some_binary, ext="bin", multipart_config=backend._client_config.multipart_config, ), ], any_order=True, ) self.assertEqual( ( 6, [ FileUploadError("file1", "error2"), FileUploadError("file1", "error2"), FileUploadError("file1", "error2"), FileUploadError("file1", "error2"), MetadataInconsistency("error1"), ], ), result, )
def test_log(self): value_and_expected = [ (13, [LogFloats.ValueType(13, None, self._now())]), (15.3, [LogFloats.ValueType(15.3, None, self._now())]), ( [1, 9, 7], [ LogFloats.ValueType(1, None, self._now()), LogFloats.ValueType(9, None, self._now()), LogFloats.ValueType(7, None, self._now()), ], ), ( (1, 9, 7), [ LogFloats.ValueType(1, None, self._now()), LogFloats.ValueType(9, None, self._now()), LogFloats.ValueType(7, None, self._now()), ], ), ( {1, 9, 7}, [ LogFloats.ValueType(1, None, self._now()), LogFloats.ValueType(9, None, self._now()), LogFloats.ValueType(7, None, self._now()), ], ), ] for value, expected in value_and_expected: processor = MagicMock() exp, path, wait = ( self._create_run(processor), self._random_path(), self._random_wait(), ) var = FloatSeries(exp, path) var.log(value, wait=wait) processor.enqueue_operation.assert_called_once_with( LogFloats(path, expected), wait )