def test_cbsd_not_unregistered_when_coordinates_change_less_than_10_m(
self):
builder = CbsdAPIDataBuilder()\
.with_single_step_enabled(True) \
.with_capabilities() \
.with_frequency_preferences() \
.with_desired_state() \
.with_serial_number(self.serial_number) \
.with_full_installation_param() \
.with_cbsd_category("a")
self.given_single_step_cbsd_provisioned(builder)
with self.while_cbsd_is_active():
filters = get_filters_for_request_type('deregistration',
self.serial_number)
update_request = EnodebdUpdateCbsdRequest(
serial_number=self.serial_number,
installation_param=InstallationParam(
antenna_gain=DoubleValue(value=15),
latitude_deg=DoubleValue(value=10.500001),
longitude_deg=DoubleValue(value=11.5000001),
indoor_deployment=BoolValue(value=True),
height_type=StringValue(value="agl"),
height_m=DoubleValue(value=12.5),
),
cbsd_category="a",
)
self.when_cbsd_is_updated_by_enodebd(update_request)
cbsd = self.when_cbsd_is_fetched(self.serial_number)
self.then_cbsd_is(cbsd, builder.payload)
self.then_message_is_never_sent(filters)
def set_compliancy_left(self, compliancy) -> None:
"""Set left arm stiff or compliant."""
request = JointsCommand(commands=[
JointCommand(id=name, compliant=BoolValue(value=compliancy))
for name in self.left_arm
])
self.stub.SendJointsCommands(request)
def build_enodebd_update_cbsd_request(
serial_number: str,
latitude_deg: str,
longitude_deg: str,
indoor_deployment: str,
antenna_height: str,
antenna_height_type: str,
cbsd_category: str,
) -> EnodebdUpdateCbsdRequest:
# cbsd category and antenna height type should be converted to lowercase
# for the gRPC call
antenna_height_type = antenna_height_type.lower()
cbsd_category = cbsd_category.lower()
# lat and long values are part of tr181 specification, but they are kept in device config
# transformed and eventually kept within the device config as strings representing degrees
latitude_deg_float = float(latitude_deg)
longitude_deg_float = float(longitude_deg)
indoor_deployment_bool = _indoortobool(indoor_deployment)
antenna_height_float = float(antenna_height)
installation_param = InstallationParam(
latitude_deg=DoubleValue(value=latitude_deg_float),
longitude_deg=DoubleValue(value=longitude_deg_float),
indoor_deployment=BoolValue(value=indoor_deployment_bool),
height_m=DoubleValue(value=antenna_height_float),
height_type=StringValue(value=antenna_height_type),
)
return EnodebdUpdateCbsdRequest(
serial_number=serial_number,
installation_param=installation_param,
cbsd_category=cbsd_category,
)
def build_config(self, use_defaults=False):
# SLICING SPEC
slicing_specs = [tfma.SlicingSpec()]
if self.slices:
slicing_specs.extend([tfma.SlicingSpec(feature_keys=e)
for e in self.slices])
# MODEL SPEC
metric_labels = sorted(list(set(self.metrics.keys())))
model_specs = [tfma.ModelSpec(signature_name='zen_eval',
label_keys=self.output_mapping)]
# METRIC SPEC
baseline = [tfma.MetricConfig(class_name='ExampleCount')]
metrics_specs = []
for i, key in enumerate(metric_labels):
metrics = baseline.copy()
metrics.extend([tfma.MetricConfig(class_name=to_camel_case(m))
for m in self.metrics[key]])
metrics_specs.append(tfma.MetricsSpec(
output_names=[key],
metrics=metrics))
return tfma.EvalConfig(
model_specs=model_specs,
slicing_specs=slicing_specs,
metrics_specs=metrics_specs,
options=tfma.Options(
include_default_metrics=BoolValue(value=use_defaults)))
async def Check(self, stream: Stream[Request, Reply]) -> None:
request = await stream.recv_message()
assert request is not None
number_is_prime = await self._loop.run_in_executor(
self._executor, is_prime, request.number)
reply = Reply(is_prime=BoolValue(value=number_is_prime))
await stream.send_message(reply)
def test_tracer_end_traced_span_do_post(m_thread, tracer):
tracer.memory.current_span_id = 'test_span_id'
tracer._post_spans_to_stackdriver_api = True
tracer.stackdriver_trace_client = MagicMock()
tracer.stackdriver_trace_client.span_path.return_value = 'test_span_name'
tracer._delete_current_span = MagicMock()
tracer.end_traced_span(exclude_from_posting=False)
tracer.logger.debug.assert_called_with("Closing span test_span_id")
tracer.stackdriver_trace_client.span_path.assert_called_with(
'test_project_name', 'test_trace_id', 'test_span_id')
expected_span_info = {
'name': 'test_span_name',
'span_id': 'test_span_id',
'display_name': 'test_truncated_str',
'start_time': 'test_start_time',
'end_time': 'test_timestamp',
'parent_span_id': 'test_parent_span_id',
'same_process_as_parent_span': BoolValue(value=False),
'child_span_count': Int32Value(value=0)
}
m_thread.assert_called_with(target=post_span,
args=(
tracer.stackdriver_trace_client,
expected_span_info,
))
assert tracer._delete_current_span.called
def build_config(self):
# SLICING SPEC
slicing_specs = [tfma.SlicingSpec()]
if self.slices:
slicing_specs.extend(
[tfma.SlicingSpec(feature_keys=e) for e in self.slices])
# MODEL SPEC
model_specs = [
tfma.ModelSpec(label_key=self.label_key,
prediction_key=self.prediction_key)
]
# METRIC SPEC
baseline = [tfma.MetricConfig(class_name='ExampleCount')]
for key in self.metrics:
baseline.append(tfma.MetricConfig(class_name=to_camel_case(key)))
metrics_specs = [tfma.MetricsSpec(metrics=baseline)]
return tfma.EvalConfig(
model_specs=model_specs,
slicing_specs=slicing_specs,
metrics_specs=metrics_specs,
options=tfma.Options(include_default_metrics=BoolValue(
value=False)))
def given_single_step_cbsd_provisioned(self,
builder: CbsdAPIDataBuilder) -> int:
self.when_cbsd_is_created(builder.payload)
update_request = EnodebdUpdateCbsdRequest(
serial_number=self.serial_number,
installation_param=InstallationParam(
antenna_gain=DoubleValue(value=15),
latitude_deg=DoubleValue(value=10.5),
longitude_deg=DoubleValue(value=11.5),
indoor_deployment=BoolValue(value=True),
height_type=StringValue(value="agl"),
height_m=DoubleValue(value=12.5),
),
cbsd_category="a",
)
self.when_cbsd_is_updated_by_enodebd(update_request)
cbsd = self.when_cbsd_is_fetched(builder.payload["serial_number"])
self.then_cbsd_is(
cbsd,
builder.with_state(UNREGISTERED).with_is_active(False).
with_full_installation_param().with_cbsd_category("a").payload,
)
state = self.when_cbsd_asks_for_state()
self.then_state_is(state, get_empty_state())
cbsd = self._check_cbsd_successfully_provisioned(builder)
return cbsd['id']
def set_ir_colormap_async(self, colormap, min_temp, max_temp, auto_scale,
**kwargs):
"""Async version of set_ir_colormap()"""
scale = compositor_pb2.IrColorMap.ScalingPair(min=min_temp,
max=max_temp)
auto = BoolValue(value=auto_scale)
ir_colormap = compositor_pb2.IrColorMap(colormap=colormap,
scale=scale,
auto_scale=auto)
request = compositor_pb2.SetIrColormapRequest(map=ir_colormap)
return self.call_async(self._stub.SetIrColormap, request,
self._return_response,
self._compositor_error_from_response, **kwargs)
def build_enodebd_update_request(
self,
indoor_deployment=False,
cbsd_category="a") -> EnodebdUpdateCbsdRequest:
return EnodebdUpdateCbsdRequest(
serial_number=self.payload["serial_number"],
installation_param=InstallationParam(
latitude_deg=DoubleValue(value=10.5),
longitude_deg=DoubleValue(value=11.5),
indoor_deployment=BoolValue(value=indoor_deployment),
height_type=StringValue(value="agl"),
height_m=DoubleValue(value=12.5),
),
cbsd_category=cbsd_category,
)
def end_traced_span(self, exclude_from_posting=False):
"""
End a span and collect details about the span, then post it to the API.
Arguments:
exclude_from_posting (bool): exclude this particular trace from being posted
"""
self.logger.debug(f'Closing span {self.memory.current_span_id}')
if self._post_spans_to_stackdriver_api and not exclude_from_posting:
span_values = self.current_span['values']
end_timestamp = get_timestamp()
if self._post_spans_to_stackdriver_api:
name = self.stackdriver_trace_client.span_path(
self.project_name, span_values[B3_TRACE_ID],
span_values[B3_SPAN_ID])
else:
name = f'{self.project_name}/{span_values[B3_TRACE_ID]}/{span_values[B3_SPAN_ID]}'
span_info = {
'name':
name,
'span_id':
span_values[B3_SPAN_ID],
'display_name':
truncate_str(self.current_span['display_name'],
limit=SPAN_DISPLAY_NAME_BYTE_LIMIT),
'start_time':
self.current_span['start_timestamp'],
'end_time':
end_timestamp,
'parent_span_id':
span_values[B3_PARENT_SPAN_ID],
'same_process_as_parent_span':
BoolValue(value=False),
'child_span_count':
Int32Value(value=self.current_span['child_span_count'])
}
post_to_api_job = Thread(target=post_span,
args=(self.stackdriver_trace_client,
span_info))
post_to_api_job.start()
self._delete_current_span()
def optimize_anchoring(opt_info, client):
"""
Sends an RPC to the robot which optimizes the anchoring and links it to the position of the
fiducial in the blueprint.
:param opt_info: info needed for the optimization.
:param client: the map processing client.
:return: the response to the process_anchoring rpc.
"""
initial_hint = map_processing_pb2.AnchoringHint()
object_hint = initial_hint.world_objects.add()
object_hint.object_anchor.id = str(opt_info.fiducial_id)
object_hint.object_anchor.seed_tform_object.CopyFrom(
opt_info.get_fiducial_origin())
return client.process_anchoring(
params=map_processing_pb2.ProcessAnchoringRequest.Params(
optimize_existing_anchoring=BoolValue(value=False)),
modify_anchoring_on_server=False,
stream_intermediate_results=False,
initial_hint=initial_hint)
def set_ir_colormap(self, colormap, min_temp, max_temp, auto_scale,
**kwargs):
"""Set IR colormap to use on Spot CAM
Args:
colormap (bosdyn.api.spot_cam.compositor_pb2.IrColorMap.ColorMap): IR display colormap
min_temp (Float): minimum temperature on the temperature scale
max_temp (Float): maximum temperature on the temperature scale
auto_scale (Boolean): Auto-scale the color map. This is the most human-understandable
option. min_temp and max_temp are ignored if this is set to True
kwargs: extra arguments for controlling RPC details.
"""
scale = compositor_pb2.IrColorMap.ScalingPair(min=min_temp,
max=max_temp)
auto = BoolValue(value=auto_scale)
ir_colormap = compositor_pb2.IrColorMap(colormap=colormap,
scale=scale,
auto_scale=auto)
request = compositor_pb2.SetIrColormapRequest(map=ir_colormap)
return self.call(self._stub.SetIrColormap, request,
self._return_response,
self._compositor_error_from_response, **kwargs)
def test_enodebd_update_cbsd(self) -> None:
builder = CbsdAPIDataBuilder() \
.with_capabilities() \
.with_frequency_preferences() \
.with_desired_state() \
.with_antenna_gain(15) \
.with_serial_number(self.serial_number) \
.with_cbsd_category("b")
self.when_cbsd_is_created(builder.payload)
cbsd = self.when_cbsd_is_fetched(self.serial_number)
self.then_cbsd_is(
cbsd,
builder.with_indoor_deployment(False).with_is_active(
False).with_state(UNREGISTERED).payload,
)
req = EnodebdUpdateCbsdRequest(
serial_number=self.serial_number,
cbsd_category="a",
installation_param=InstallationParam(
latitude_deg=DoubleValue(value=10.5),
longitude_deg=DoubleValue(value=11.5),
height_m=DoubleValue(value=12.5),
height_type=StringValue(value="agl"),
indoor_deployment=BoolValue(value=True),
antenna_gain=DoubleValue(value=15),
),
)
self.when_cbsd_is_updated_by_enodebd(req)
self.then_logs_are({"serial_number": self.serial_number},
["EnodebdUpdateCbsd"])
cbsd = self.when_cbsd_is_fetched(self.serial_number)
self.then_cbsd_is(
cbsd,
builder.with_cbsd_category(
"a").with_full_installation_param().payload)
def translate_to_trace_proto(span_data):
"""Translates the opencensus spans to ocagent proto spans.
:type span_data: :class:`~opencensus.trace.span_data.SpanData`
:param span_data: SpanData tuples to convert to protobuf spans
:rtype: :class:`~opencensus.proto.trace.Span`
:returns: Protobuf format span.
"""
if not span_data:
return None
pb_span = trace_pb2.Span(
name=trace_pb2.TruncatableString(value=span_data.name),
kind=span_data.span_kind,
trace_id=hex_str_to_bytes_str(span_data.context.trace_id),
span_id=hex_str_to_bytes_str(span_data.span_id),
parent_span_id=hex_str_to_bytes_str(span_data.parent_span_id)
if span_data.parent_span_id is not None else None,
start_time=proto_ts_from_datetime_str(span_data.start_time),
end_time=proto_ts_from_datetime_str(span_data.end_time),
status=trace_pb2.Status(code=span_data.status.code,
message=span_data.status.message)
if span_data.status is not None else None,
same_process_as_parent_span=BoolValue(
value=span_data.same_process_as_parent_span)
if span_data.same_process_as_parent_span is not None else None,
child_span_count=UInt32Value(value=span_data.child_span_count)
if span_data.child_span_count is not None else None)
# attributes
if span_data.attributes is not None:
for attribute_key, attribute_value \
in span_data.attributes.items():
add_proto_attribute_value(pb_span.attributes, attribute_key,
attribute_value)
# time events
if span_data.time_events is not None:
for span_data_event in span_data.time_events:
if span_data_event.message_event is not None:
pb_event = pb_span.time_events.time_event.add()
pb_event.time.FromJsonString(span_data_event.timestamp)
set_proto_message_event(pb_event.message_event,
span_data_event.message_event)
elif span_data_event.annotation is not None:
pb_event = pb_span.time_events.time_event.add()
pb_event.time.FromJsonString(span_data_event.timestamp)
set_proto_annotation(pb_event.annotation,
span_data_event.annotation)
# links
if span_data.links is not None:
for link in span_data.links:
pb_link = pb_span.links.link.add(
trace_id=hex_str_to_bytes_str(link.trace_id),
span_id=hex_str_to_bytes_str(link.span_id),
type=link.type)
if link.attributes is not None and \
link.attributes.attributes is not None:
for attribute_key, attribute_value \
in link.attributes.attributes.items():
add_proto_attribute_value(pb_link.attributes,
attribute_key, attribute_value)
# tracestate
if span_data.context.tracestate is not None:
for (key, value) in span_data.context.tracestate.items():
pb_span.tracestate.entries.add(key=key, value=value)
return pb_span
def testGetTrainingRunDetails(self):
client = Mock()
options = [['data_split_column', 'column_name_1'],
['data_split_eval_fraction', 0.3], ['data_split_method', 1],
['distance_type',
1], ['early_stop', BoolValue(value=False)],
['initial_learn_rate', 0.1],
['input_label_columns', ['column1', 'column2']],
['kmeans_initialization_column', 'column_name_2'],
['kmeans_initialization_method', 1],
['l1_regularization',
DoubleValue(value=0.5)],
['l2_regularization',
DoubleValue(value=0.6)],
['label_class_weights', [0.2, 0.3]], ['learn_rate', 0.7],
['learn_rate_strategy', 1], ['loss_type', 1],
['max_iterations', 20],
['min_relative_progress',
DoubleValue(value=0.4)], ['model_uri', 'model.uri.string'],
['num_clusters', 7], ['optimization_strategy', 1],
['warm_start', BoolValue(value=True)]]
mocked_options = []
for option in options:
option_mock = Mock()
option_mock.name = option[0]
mocked_options.append([option_mock, option[1]])
training_options = Mock()
training_options.ListFields = Mock(return_value=mocked_options)
training_run = Mock(training_options=training_options,
results=['result', 'result', 'result'])
model = Mock(training_runs=[training_run])
client.get_model = Mock(return_value=model)
bigquery = BigQueryService(client)
expected = {
'details': {
'actual_iterations':
3,
'data_split_column':
'column_name_1',
'data_split_eval_fraction':
0.3,
'data_split_method':
Model.DataSplitMethod(1).name,
'distance_type':
Model.DistanceType(1).name,
'early_stop':
'False',
'initial_learn_rate':
0.1,
'input_label_columns':
"['column1', 'column2']",
'kmeans_initialization_column':
'column_name_2',
'kmeans_initialization_method':
Model.KmeansEnums.KmeansInitializationMethod(1).name,
'l1_regularization':
0.5,
'l2_regularization':
0.6,
'label_class_weights':
'[0.2, 0.3]',
'learn_rate':
0.7,
'learn_rate_strategy':
Model.LearnRateStrategy(1).name,
'loss_type':
Model.LossType(1).name,
'max_iterations':
20,
'min_relative_progress':
0.4,
'model_uri':
'model.uri.string',
'num_clusters':
7,
'optimization_strategy':
Model.OptimizationStrategy(1).name,
'warm_start':
'True'
}
}
result = bigquery.get_training_run_details('some_model_id', 0)
self.assertEqual(expected, result)
def Probe(self, request, context):
return csi_pb2.ProbeResponse(ready=BoolValue(value=True))
def __init__(self): # pylint: disable=R0912,R0915
"""
Returns a new instance of config_pb2.AgentConfig when a new AgentConfig() is created.
If 'HT_CONFIG_FILE' is specified in the environment data would be loaded from that file.
If not, data would be loaded from 'DEFAULT_AGENT_CONFIG' on 'default.py'
"""
config_dict = DEFAULT_AGENT_CONFIG
custom_config = {}
file_dict = _read_from_file()
if file_dict is not None:
config_dict = merge_config(config_dict, file_dict)
env_dict = load_config_from_env()
config_dict = merge_config(config_dict, env_dict)
self.custom_config = _apply_custom_config_options(
custom_config, config_dict)
# transform(to not break old support) like zipkin != proto def of ZIPKIN
_transform_values(config_dict)
logger.info("Config init complete - config state: %s", config_dict)
# Create protobuf Reporting object
reporting = jf.Parse(jf.MessageToJson(config_pb2.Reporting()),
config_pb2.Reporting)
reporting.endpoint = config_dict['reporting']['endpoint']
reporting.secure = config_dict['reporting']['secure']
reporting.token = config_dict['reporting']['token']
# Set trace_reporter_type
if config_dict['reporting']['trace_reporter_type'] == 'OTLP':
reporting.trace_reporter_type = config_pb2.TraceReporterType.OTLP
elif config_dict['reporting']['trace_reporter_type'] == 'ZIPKIN':
reporting.trace_reporter_type = config_pb2.TraceReporterType.ZIPKIN
else:
# Default to ZIPKIN
reporting.trace_reporter_type = config_pb2.TraceReporterType.OTLP
# Create DataCapture Message components
rpc_body = config_pb2.Message(
request=BoolValue(
value=config_dict['data_capture']['rpc_body']['request']),
response=BoolValue(
value=config_dict['data_capture']['rpc_body']['response']))
rpc_metadata = config_pb2.Message(
request=BoolValue(
value=config_dict['data_capture']['rpc_metadata']['request']),
response=BoolValue(
value=config_dict['data_capture']['rpc_metadata']['response']))
http_body = config_pb2.Message(
request=BoolValue(
value=config_dict['data_capture']['http_body']['request']),
response=BoolValue(
value=config_dict['data_capture']['http_body']['response']))
http_headers = config_pb2.Message(
request=BoolValue(
value=config_dict['data_capture']['http_headers']['request']),
response=BoolValue(
value=config_dict['data_capture']['http_headers']['response']))
# Create Protobuf DataCapture object
data_capture = jf.Parse(jf.MessageToJson(config_pb2.DataCapture()),
config_pb2.DataCapture)
data_capture.http_headers = http_headers
data_capture.http_body = http_body
data_capture.rpc_metadata = rpc_metadata
data_capture.rpc_body = rpc_body
data_capture.body_max_size_bytes = config_dict['data_capture'][
'body_max_size_bytes']
# Create Protobuf AgentConfig object
self.agent_config: config_pb2.AgentConfig = jf.Parse(
jf.MessageToJson(config_pb2.AgentConfig()), config_pb2.AgentConfig)
self.agent_config.service_name = config_dict['service_name']
self.agent_config.reporting = reporting
self.agent_config.data_capture = data_capture
tmp_propagation_formats = []
if 'TRACECONTEXT' in config_dict['propagation_formats']:
tmp_propagation_formats.append(
config_pb2.PropagationFormat.TRACECONTEXT)
tmp_propagation_formats = list(set(tmp_propagation_formats))
if 'B3' in config_dict['propagation_formats']:
tmp_propagation_formats.append(config_pb2.PropagationFormat.B3)
tmp_propagation_formats = list(set(tmp_propagation_formats))
if not tmp_propagation_formats:
# Default to TRACECONTEXT
tmp_propagation_formats.append(
config_pb2.PropagationFormat.TRACECONTEXT)
self.agent_config.propagation_formats = tmp_propagation_formats
self.agent_config.enabled = config_dict['enabled']
self.agent_config.resource_attributes = config_dict[
'resource_attributes']
