def play_sound_async(self, sound, gain=1.0, **kwargs):
"""Async version of play_sound()"""
fv = FloatValue()
fv.value = gain
request = audio_pb2.PlaySoundRequest(sound=sound, gain=fv)
return self.call_async(self._stub.PlaySound, request, self._play_sound_from_response,
self._audio_error_from_response, **kwargs)
def sgds(
draw,
return_kwargs: bool = False
) -> Union[st.SearchStrategy[optimizer_pb2.SGD], st.SearchStrategy[Tuple[
optimizer_pb2.SGD, Dict]], ]:
"""Returns a SearchStrategy for an SGD plus maybe the kwargs."""
kwargs: Dict = {}
kwargs["learning_rate"] = draw(
st.floats(min_value=1e-4, max_value=1.0, allow_nan=False))
kwargs["nesterov_momentum"] = draw(st.booleans())
# nesterov momentum requires momentum > 0
min_momentum = 0.0 if not kwargs["nesterov_momentum"] else 0.1
kwargs["momentum"] = FloatValue(value=draw(
st.floats(min_value=min_momentum, max_value=10.0, allow_nan=False)))
kwargs["l2_weight_decay"] = FloatValue(
value=draw(st.floats(min_value=0.0, max_value=10.0, allow_nan=False)))
# initialise and return
all_fields_set(optimizer_pb2.SGD, kwargs)
sgd = optimizer_pb2.SGD(**kwargs)
if not return_kwargs:
return sgd
return sgd, kwargs
def adams(
draw,
return_kwargs: bool = False
) -> Union[st.SearchStrategy[optimizer_pb2.Adam], st.SearchStrategy[Tuple[
optimizer_pb2.Adam, Dict]], ]:
"""Returns a SearchStrategy for an Adam optimizer plus maybe the kwargs."""
kwargs: Dict = {}
kwargs["learning_rate"] = draw(
st.floats(min_value=1e-4, max_value=1.0, allow_nan=False))
kwargs["beta_1"] = FloatValue(
value=draw(st.floats(min_value=0.0, max_value=1.0, allow_nan=False)))
kwargs["beta_2"] = FloatValue(
value=draw(st.floats(min_value=0.0, max_value=1.0, allow_nan=False)))
kwargs["eps"] = FloatValue(
value=draw(st.floats(min_value=0.0, max_value=1e-3, allow_nan=False)))
kwargs["l2_weight_decay"] = FloatValue(
value=draw(st.floats(min_value=0.0, max_value=10.0, allow_nan=False)))
kwargs["amsgrad"] = draw(st.booleans())
# initialise and return
all_fields_set(optimizer_pb2.Adam, kwargs)
adam = optimizer_pb2.Adam(**kwargs)
if not return_kwargs:
return adam
return adam, kwargs
def set_ptz_velocity_async(self, ptz_desc, pan, tilt, zoom, **kwargs):
"""Async version of set_ptz_velocity()"""
p = FloatValue(value=pan)
t = FloatValue(value=tilt)
z = FloatValue(value=zoom)
ptz_velocity = ptz_pb2.PtzVelocity(ptz=ptz_desc, pan=p, tilt=t, zoom=z)
request = ptz_pb2.SetPtzVelocityRequest(velocity=ptz_velocity)
return self.call_async(self._stub.SetPtzVelocity, request,
self._set_ptz_velocity_from_response,
self._ptz_error_from_response, **kwargs)
def set_ptz_velocity(self, ptz_desc, pan, tilt, zoom, **kwargs):
"""Set velocity of the specified ptz in PTZ-space"""
p = FloatValue(value=pan)
t = FloatValue(value=tilt)
z = FloatValue(value=zoom)
ptz_velocity = ptz_pb2.PtzVelocity(ptz=ptz_desc, pan=p, tilt=t, zoom=z)
request = ptz_pb2.SetPtzVelocityRequest(velocity=ptz_velocity)
return self.call(self._stub.SetPtzVelocity, request,
self._set_ptz_velocity_from_response,
self._ptz_error_from_response, **kwargs)
def play_sound(self, sound, gain=None, **kwargs):
"""Play already uploaded sound with optional volume gain multiplier"""
if gain:
fv = FloatValue()
fv.value = gain
request = audio_pb2.PlaySoundRequest(sound=sound, gain=fv)
else:
request = audio_pb2.PlaySoundRequest(sound=sound)
return self.call(self._stub.PlaySound, request, self._play_sound_from_response,
self._audio_error_from_response, **kwargs)
def set_ptz_position(self, ptz_desc, pan, tilt, zoom, **kwargs):
"""Set position of the specified ptz in PTZ-space"""
p = FloatValue(value=pan)
t = FloatValue(value=tilt)
z = FloatValue(value=zoom)
ptz_position = ptz_pb2.PtzPosition(ptz=ptz_desc, pan=p, tilt=t, zoom=z)
request = ptz_pb2.SetPtzPositionRequest(position=ptz_position)
return self.call(self._stub.SetPtzPosition, request,
self._set_ptz_position_from_response,
self._ptz_error_from_response, **kwargs)
def set_ptz_position_async(self, ptz_desc, pan, tilt, zoom, **kwargs):
"""Async version of set_ptz_position()"""
p = FloatValue(value=pan)
t = FloatValue(value=tilt)
z = FloatValue(value=zoom)
ptz_position = ptz_pb2.PtzPosition(ptz=ptz_desc, pan=p, tilt=t, zoom=z)
request = ptz_pb2.SetPtzPositionRequest(position=ptz_position)
return self.call_async(self._stub.SetPtzPosition, request,
self._set_ptz_position_from_response,
self._ptz_error_from_response, **kwargs)
def test_image_properties_annotation_from_pb(self):
from google.cloud.proto.vision.v1 import image_annotator_pb2
from google.protobuf.wrappers_pb2 import FloatValue
from google.type.color_pb2 import Color
alpha = FloatValue(value=1.0)
color_pb = Color(red=1.0, green=2.0, blue=3.0, alpha=alpha)
color_info_pb = image_annotator_pb2.ColorInfo(color=color_pb,
score=1.0,
pixel_fraction=1.0)
dominant_colors = image_annotator_pb2.DominantColorsAnnotation(
colors=[color_info_pb])
image_properties_pb = image_annotator_pb2.ImageProperties(
dominant_colors=dominant_colors)
color_info = self._get_target_class()
image_properties = color_info.from_pb(image_properties_pb)
self.assertEqual(image_properties.colors[0].pixel_fraction, 1.0)
self.assertEqual(image_properties.colors[0].score, 1.0)
self.assertEqual(image_properties.colors[0].color.red, 1.0)
self.assertEqual(image_properties.colors[0].color.green, 2.0)
self.assertEqual(image_properties.colors[0].color.blue, 3.0)
self.assertEqual(image_properties.colors[0].color.alpha, 1.0)
def fully_connecteds(
draw, return_kwargs: bool = False, valid_only: bool = False
) -> Union[
st.SearchStrategy[fully_connected_pb2.FullyConnected],
st.SearchStrategy[Tuple[fully_connected_pb2.FullyConnected, Dict]],
]:
"""Returns a SearchStrategy for a FC layer plus maybe the kwargs."""
kwargs = {}
kwargs["num_hidden_layers"] = draw(st.integers(0, 3))
if valid_only and kwargs["num_hidden_layers"] == 0:
kwargs["hidden_size"] = None
kwargs["activation"] = activation_pb2.Activation(
identity=empty_pb2.Empty()
)
kwargs["dropout"] = None
else:
kwargs["hidden_size"] = draw(st.integers(1, 32))
kwargs["activation"] = draw(activations())
kwargs["dropout"] = FloatValue(
value=draw(
st.one_of(st.none(), st.floats(min_value=0.0, max_value=1.0))
)
)
all_fields_set(fully_connected_pb2.FullyConnected, kwargs)
fc = fully_connected_pb2.FullyConnected(**kwargs)
if not return_kwargs:
return fc
return fc, kwargs
def rnns(
draw,
return_kwargs: bool = False
) -> Union[st.SearchStrategy[rnn_pb2.RNN], st.SearchStrategy[Tuple[rnn_pb2.RNN,
Dict]]]:
"""Returns a SearchStrategy for RNN plus maybe the kwargs."""
kwargs = {}
to_ignore: List[str] = []
kwargs["rnn_type"] = draw(st.sampled_from(rnn_pb2.RNN.RNN_TYPE.values()))
kwargs["hidden_size"] = draw(st.integers(1, 32))
kwargs["num_layers"] = draw(st.integers(1, 4))
kwargs["bias"] = draw(st.booleans())
kwargs["bidirectional"] = draw(st.booleans())
if kwargs["rnn_type"] == rnn_pb2.RNN.RNN_TYPE.LSTM and kwargs["bias"]:
kwargs["forget_gate_bias"] = FloatValue(value=draw(
st.floats(min_value=-10.0, max_value=10.0, allow_nan=False)))
else:
to_ignore = ["forget_gate_bias"]
all_fields_set(rnn_pb2.RNN, kwargs, to_ignore)
rnn = rnn_pb2.RNN(**kwargs)
if not return_kwargs:
return rnn
return rnn, kwargs
def test_pb_rgb_color_no_alpha_data(self):
from google.protobuf.wrappers_pb2 import FloatValue
from google.type.color_pb2 import Color
alpha = FloatValue()
color_pb = Color(red=1.0, green=2.0, blue=3.0, alpha=alpha)
color_class = self._get_target_class()
color = color_class.from_pb(color_pb)
self.assertEqual(color.red, 1.0)
self.assertEqual(color.green, 2.0)
self.assertEqual(color.blue, 3.0)
self.assertEqual(color.alpha, 0.0)
def ctc_beam_decoders(
draw,
return_kwargs: bool = False,
alphabet_len: Optional[int] = None,
blank_index: Optional[int] = None,
) -> Union[
st.SearchStrategy[ctc_beam_decoder_pb2.CTCBeamDecoder],
st.SearchStrategy[Tuple[ctc_beam_decoder_pb2.CTCBeamDecoder, Dict]],
]:
"""Returns a SearchStrategy for CTCBeamDecoder plus maybe the kwargs."""
kwargs: Dict = {}
end = 100
if alphabet_len is not None:
end = max(0, alphabet_len - 1)
if blank_index is not None:
kwargs["blank_index"] = blank_index
else:
kwargs["blank_index"] = draw(st.integers(0, end))
kwargs["beam_width"] = draw(st.integers(1, 2048))
kwargs["prune_threshold"] = draw(st.floats(0.0, 1.0, allow_nan=False))
kwargs["language_model"] = draw(language_models())
if not isinstance(kwargs["language_model"], empty_pb2.Empty):
kwargs["lm_weight"] = FloatValue(
value=draw(st.floats(allow_nan=False, allow_infinity=False))
)
kwargs["separator_index"] = UInt32Value(
value=draw(
st.integers(0, end).filter(lambda v: v != kwargs["blank_index"])
)
)
kwargs["word_weight"] = draw(
st.floats(allow_nan=False, allow_infinity=False)
)
# initialise and return
all_fields_set(ctc_beam_decoder_pb2.CTCBeamDecoder, kwargs)
ctc_beam_decoder = ctc_beam_decoder_pb2.CTCBeamDecoder(**kwargs)
if not return_kwargs:
return ctc_beam_decoder
return ctc_beam_decoder, kwargs
def step_lrs(
draw,
return_kwargs: bool = False
) -> Union[st.SearchStrategy[lr_scheduler_pb2.StepLR], st.SearchStrategy[Tuple[
lr_scheduler_pb2.StepLR, Dict]], ]:
"""Returns a SearchStrategy for an StepLR plus maybe the kwargs."""
kwargs: Dict = {}
kwargs["step_size"] = draw(st.integers(1, 30))
kwargs["gamma"] = FloatValue(
value=draw(st.floats(min_value=0.1, max_value=1.0, allow_nan=False)))
# initialise and return
all_fields_set(lr_scheduler_pb2.StepLR, kwargs)
step_lr = lr_scheduler_pb2.StepLR(**kwargs)
if not return_kwargs:
return step_lr
return step_lr, kwargs
def cosine_annealing_lrs(
draw,
return_kwargs: bool = False
) -> Union[st.SearchStrategy[lr_scheduler_pb2.CosineAnnealingLR], st.
SearchStrategy[Tuple[lr_scheduler_pb2.CosineAnnealingLR, Dict]], ]:
"""Returns a SearchStrategy for an CosineAnnealingLR plus maybe the
kwargs. """
kwargs: Dict = {}
kwargs["t_max"] = draw(st.integers(1, 30))
kwargs["eta_min"] = FloatValue(
value=draw(st.floats(min_value=1e-9, max_value=1e-3, allow_nan=False)))
# initialise and return
all_fields_set(lr_scheduler_pb2.CosineAnnealingLR, kwargs)
cosine_annealing_lr = lr_scheduler_pb2.CosineAnnealingLR(**kwargs)
if not return_kwargs:
return cosine_annealing_lr
return cosine_annealing_lr, kwargs
def get_pose(self):
"""
Handle reproduction of right arm movements on the left arm.
Read right arm joints state and apply the modified commands on the left arm.
Callback for the class thread.
"""
request = JointsStateRequest(
ids=self.right_arm, requested_fields=[JointField.PRESENT_POSITION])
while self.alive:
state = self.stub.GetJointsState(request)
left_pos = [-pos.present_position.value for pos in state.states]
for i, pos in enumerate(left_pos):
if (i == 0 or i == 3 or i == 5):
left_pos[i] = -pos
command = JointsCommand(commands=[
JointCommand(id=name, goal_position=FloatValue(value=pos))
for name, pos in zip(self.left_arm, left_pos)
])
self.stub.SendJointsCommands(command)
time.sleep(0.01)
def make_optional_float(value: Optional[float] = None) -> FloatValue:
return FloatValue(value=value) if value is not None else None
log = Logger(name='SetConfig')
camera_id = 0
"""
Loading CameraConfig protobuf from a json file
"""
with open('camera_config.json', 'r') as f:
try:
set_config = Parse(f.read(), CameraConfig())
log.info('CameraConfig:\n{}', set_config)
except Exception as ex:
log.critical('Unable to camera settings. \n{}', ex)
"""
Another way to create a CameraConfig message
"""
set_config = CameraConfig(
sampling=SamplingSettings(frequency=FloatValue(value=5.0)),
image=ImageSettings(
resolution=Resolution(width=720, height=540),
color_space=ColorSpace(value=ColorSpaces.Value('GRAY'))))
msg = Message()
msg.reply_to = subscription
msg.topic = 'CameraGateway.{}.SetConfig'.format(camera_id)
msg.pack(set_config)
channel.publish(msg)
while True:
msg = channel.consume()
if msg.status.code == StatusCode.OK:
log.info('Configuration applied on camera \'{}\'.', camera_id)
else:
def gsd(self, value: float):
self.stac_item.gsd.CopyFrom(FloatValue(value=value))
def off_nadir(self, value: float):
if not self.stac_item.HasField("view"):
self.stac_item.view.CopyFrom(
View(off_nadir=FloatValue(value=value)))
else:
self.stac_item.view.off_nadir.CopyFrom(FloatValue(value=value))
def cloud_cover(self, value: float):
if not self.stac_item.HasField("eo"):
self.stac_item.eo.CopyFrom(Eo(cloud_cover=FloatValue(value=value)))
else:
self.stac_item.eo.cloud_cover.CopyFrom(FloatValue(value=value))
