def update(self, local_address: typing.Optional[Address] = None, int_address: typing.Optional[Address] = None, phone: typing.Optional[Phone] = None, fax: typing.Optional[Phone] = None, email: typing.Optional[str] = None, entity_type: typing.Optional[int] = None, trading_name: typing.Optional[str] = None, company_number: typing.Optional[str] = None, auth_info: typing.Optional[str] = None) -> bool: resp = self._app.stub.ContactUpdate( contact_pb2.ContactUpdateRequest( id=self.id, new_local_address=local_address.to_pb() if local_address else None, new_internationalised_address=int_address.to_pb() if int_address else None, new_phone=phone.to_pb() if phone else None, new_fax=fax.to_pb() if fax else None, new_email=StringValue( value=email) if email and email != self.email else None, new_entity_type=entity_type if entity_type and entity_type != self.entity_type else None, new_trading_name=StringValue(value=trading_name) if trading_name and trading_name != self.trading_name else None, new_company_number=StringValue( value=company_number) if company_number and company_number != self.company_number else None, new_auth_info=StringValue(value=auth_info) if auth_info and auth_info != self.auth_info else None, registry_name=self.registry_name)) return resp.pending
def scan( self, table_name: str, table_namespace: str = "default", start_row: Optional[str] = None, stop_row: Optional[str] = None, prefix: Optional[str] = None, columns: Optional[Mapping[str, List[str]]] = None, min_time: Optional[int] = None, max_time: Optional[int] = None, max_versions: Optional[int] = None ) -> Iterator[Result]: if start_row is not None: _start_row = StringValue(value=start_row) else: _start_row = None if stop_row is not None: _stop_row = StringValue(value=stop_row) else: _stop_row = None if prefix is not None: _prefix = StringValue(value=prefix) else: _prefix = None if min_time is not None: _min_time = Int64Value(value=min_time) else: _min_time = None if max_time is not None: _max_time = Int64Value(value=max_time) else: _max_time = None if columns is not None: _columns = self._convert_columns(columns) else: _columns = [] if max_versions is not None: _max_versions = Int32Value(value=max_versions) else: _max_versions = None query = ScanRequest( table=Table(name=table_name, namespace=table_namespace), start_row=_start_row, stop_row=_stop_row, prefix=_prefix, columns=_columns, min_time=_min_time, max_time=_max_time, max_versions=_max_versions ) return self._client.Scan(query)
def create_contact( self, contact_id: str, local_address: Address, int_address: typing.Optional[Address], phone: typing.Optional[Phone], fax: typing.Optional[Phone], email: str, entity_type: int, trading_name: typing.Optional[str], company_number: typing.Optional[str], auth_info: str, registry_name: str, ) -> typing.Tuple[str, bool, datetime.datetime]: resp = self.stub.ContactCreate( contact_pb2.ContactCreateRequest( id=contact_id, local_address=local_address.to_pb() if local_address else None, internationalised_address=int_address.to_pb() if int_address else None, phone=phone.to_pb() if phone else None, fax=fax.to_pb() if fax else None, email=email, entity_type=entity_type, trading_name=StringValue( value=trading_name) if trading_name else None, company_number=StringValue( value=company_number) if company_number else None, auth_info=auth_info, registry_name=registry_name)) return resp.id, resp.pending, resp.creation_date.ToDatetime()
def test_multiple_positions(self): sample_sheet = load_sample_sheet_csv( sample_sheet_csv_path("good", "multiple_positions")) self.compare_sample_sheet( sample_sheet, [ ParsedSampleSheetEntry( flow_cell_id=None, position_id="A1", protocol_run_user_info=ProtocolRunUserInfo( sample_id=StringValue(value="my_sample_1"), protocol_group_id=StringValue(value="my_experiment"), barcode_user_info=[ BarcodeUserData(barcode_name="barcode01", alias="alias01"), ], ), ), ParsedSampleSheetEntry( flow_cell_id=None, position_id="A2", protocol_run_user_info=ProtocolRunUserInfo( sample_id=StringValue(value="my_sample_2"), protocol_group_id=StringValue(value="my_experiment"), barcode_user_info=[ BarcodeUserData(barcode_name="barcode01", alias="alias01"), ], ), ), ], )
def _make_run_userinfo(self, experiment_group_id: str, sample_id: str): experiment_group_value = StringValue(value=experiment_group_id) sample_id_value = StringValue(value=sample_id) protocol_user_info = protocol.ProtocolRunUserInfo( protocol_group_id=experiment_group_value, sample_id=sample_id_value) return protocol_user_info
def gen_block_hash_from_block(block: BlockMessage) -> bytes: signed_obj = b''.join([ block.header.SerializeToString(), block.sender, StringValue(value=block.sigAlgorithm).SerializeToString(), Int32Value(value=block.seqNum).SerializeToString(), StringValue(value=block.shardId).SerializeToString(), block.extraBytes ]) return blake2b_32(signed_obj).digest()
def to_api(self) -> messaging_pb2.WebpageMedia: if self.image is not None: image = self.image.to_api() else: image = None return messaging_pb2.WebpageMedia( url=StringValue(value=self.url), title=StringValue(value=self.title), description=StringValue(value=self.description), image=image)
def test_nested_deserialization(): child = Child(name='child', label=StringValue(value='small')) parent = Parent(name='parent', label=StringValue(value='big'), child=child) data = protobuf_to_dict(parent) assert data == dict(name='parent', label='big', child=dict( name='child', label='small', category=None, ))
def scan(self, table_name: str, table_namespace: str = "default", start_row: Optional[str] = None, stop_row: Optional[str] = None, prefix: Optional[str] = None, columns: Mapping[str, List[str]] = None, min_time: Optional[int] = None, max_time: Optional[int] = None, max_versions: Optional[int] = None) -> 'Result': if start_row is not None: _start_row = StringValue(value=start_row) else: _start_row = None if stop_row is not None: _stop_row = StringValue(value=stop_row) else: _stop_row = None if prefix is not None: _prefix = StringValue(value=prefix) else: _prefix = None if min_time is not None: _min_time = Int64Value(value=min_time) else: _min_time = None if max_time is not None: _max_time = Int64Value(value=max_time) else: _max_time = None if max_versions is not None: _max_versions = Int32Value(value=max_versions) else: _max_versions = None query = Scan( table=Table(name=table_name, namespace=table_namespace), start_row=_start_row, stop_row=_stop_row, prefix=_prefix, columns={f: Columns(columns=c) for f, c in columns.items()}, min_time=_min_time, max_time=_max_time, max_versions=_max_versions) return Result(self._client.scan(query))
def create_calendar(stub: GoogleCalendarServiceStub, user_id: str, summary: str, **kwargs): query = GoogleCalendar.Query.Create( user_id=user_id, calendar=GoogleCalendar( summary=StringValue(value=summary), description=StringValue(value=kwargs.get('description')) if kwargs.get('description') else None, location=StringValue(value=kwargs.get('location')) if kwargs.get('location') else None, timezone=StringValue(value=kwargs.get('timezone')) if kwargs.get('timezone') else None)) result = stub.CreateGoogleCalendar(query) return result
def create_event(stub: GoogleCalendarServiceStub, user_id: str, calendar_id: str, summary: str, start: datetime, end: datetime, **kwargs): query = GoogleCalendarEvent.Query.Create( user_id=user_id, calendar_id=calendar_id, event=GoogleCalendarEvent( summary=StringValue(value=summary), start=datetime_to_protobuf(start), end=datetime_to_protobuf(end), description=StringValue(value=kwargs.get('description')) if kwargs.get('description') else None, location=StringValue(value=kwargs.get('location')) if kwargs.get('location') else None)) result = stub.CreateGoogleCalendarEvent(query) return result
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 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 transfer_query_domain(self, domain: str, auth_info: typing.Optional[str] = None) -> \ DomainTransfer: resp = self.stub.DomainTransferQuery( domain_pb2.DomainTransferQueryRequest( name=domain, auth_info=StringValue(value=auth_info) if auth_info else None)) return DomainTransfer.from_pb(resp)
def test_no_barcoding(self): sample_sheet = load_sample_sheet_csv( sample_sheet_csv_path("good", "no_barcoding")) self.compare_sample_sheet( sample_sheet, [ ParsedSampleSheetEntry( flow_cell_id="FC001", position_id=None, protocol_run_user_info=ProtocolRunUserInfo( sample_id=StringValue(value="my_sample"), protocol_group_id=StringValue(value="my_experiment"), ), ), ], )
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 set_proto(self, response_object): response_object.error.code = self.code response_object.error.message = str(self) response_object.error.status_code = self.status_code if self.client_minimum_version: response_object.error.minimumVersion.CopyFrom( StringValue(value=self.client_minimum_version))
def test_call_metrics(self): servicer = MagicMock(test_service_pb2_grpc.TestServiceServicer) servicer.UnaryUnary = lambda x, _: x with inprocess_grpc_server( servicer, test_service_pb2_grpc. add_TestServiceServicer_to_server) as address: set_global_tracer(global_tracer()) client = make_grpc_client("foo", "bar", address, test_service_pb2_grpc.TestServiceStub) unary_value = StringValue(value="foo") self.assertEqual(unary_value, client.UnaryUnary(unary_value)) labels = { "client_name": "foo", "server_name": "bar", "service": "eagr_TestService", "endpoint": "UnaryUnary", } call_count = REGISTRY.get_sample_value( "clientside_grpc_endpoint_count", labels=labels) self.assertEqual(1, call_count) # Try that again to see if the number changes self.assertEqual(unary_value, client.UnaryUnary(unary_value)) call_count = REGISTRY.get_sample_value( "clientside_grpc_endpoint_count", labels=labels) self.assertEqual(2, call_count)
def test_exception_tracking(self): servicer = MagicMock(test_service_pb2_grpc.TestServiceServicer) servicer.UnaryUnary = lambda x, _: time.sleep(10) count_labels = { "client_name": "foo", "server_name": "bar", "service": "eagr_TestService", "endpoint": "UnaryUnary", } exception_labels = dict(count_labels, exception="TimeoutError") with inprocess_grpc_server( servicer, test_service_pb2_grpc. add_TestServiceServicer_to_server) as address: set_global_tracer(global_tracer()) client = make_grpc_client("foo", "bar", address, test_service_pb2_grpc.TestServiceStub) calls_before = (REGISTRY.get_sample_value( "clientside_grpc_endpoint_count", labels=count_labels) or 0) exceptions_before = (REGISTRY.get_sample_value( "clientside_grpc_endpoint_error_total", labels=exception_labels) or 0) with self.assertRaises(TimeoutError): client.UnaryUnary(StringValue(value="foo"), timeout=1) calls_after = REGISTRY.get_sample_value( "clientside_grpc_endpoint_count", labels=count_labels) exceptions_after = REGISTRY.get_sample_value( "clientside_grpc_endpoint_error_total", labels=exception_labels) self.assertEqual(1, calls_after - calls_before) print(exceptions_after, exceptions_before) # noqa self.assertEqual(1, exceptions_after - exceptions_before)
def edit_nickname(self, nick: str) -> None: """Edit bot nickname (shortname). :param nick: new bot nickname. :return: None """ self.internal.profile.EditNickName(profile_pb2.RequestEditNickName(nickname=StringValue(value=nick)))
def edit_about(self, about: str) -> None: """Edit bot about. :param about: new bot about. :return: """ self.internal.profile.EditAbout(profile_pb2.RequestEditAbout(about=StringValue(value=about)))
def get_observation(self, obs_id): respond = self.stub.getObservation(StringValue(value=obs_id)) observation = [] for obs in respond.obs: observation.append(obs) return observation
def get_formatted_address(self, address): """ Get formatted address :param address: address :return: the formatted address """ if isinstance(address, Address): address = base58.b58encode_check(address.value).decode() token_contract_address = self.get_system_contract_address('AElf.ContractNames.Token') transaction = self.create_transaction(token_contract_address, 'GetPrimaryTokenSymbol') transaction = self.sign_transaction(self._private_key, transaction) raw_symbol = self.execute_transaction(transaction) symbol = StringValue() symbol.ParseFromString(bytes.fromhex(raw_symbol.decode())) chain_status = self.get_chain_status() return '%s_%s_%s' % (symbol.value, address, chain_status['ChainId'])
def edit_user_status(self, type: UserStatus, text: str) -> None: """Edit bot sex. :param type: new bot status type. :param text: new bot status text. :return: None. """ self.internal.profile.ChangeUserStatus( profile_pb2.RequestChangeUserStatus(status=users_pb2.UserStatus( type=type, text=StringValue(value=text))))
def PeerSearch(self, request: RequestPeerSearch) -> ResponsePeerSearch: return ResponsePeerSearch( users=[], groups=[], search_results=[ PeerSearchResult(peer=Peer(id=1, type=PEERTYPE_GROUP), shortname=StringValue(value="short_name")) ], user_peers=[], group_peers=[])
def upload_animated_move_async(self, animation, generated_id="", **kwargs): """Async version of upload_animated_move().""" gen_id_proto = StringValue(value=generated_id) req = choreography_sequence_pb2.UploadAnimatedMoveRequest( animated_move=animation, animated_move_generated_id=gen_id_proto) return self.call_async( self._stub.UploadAnimatedMove, req, value_from_response=None, # Return the complete response message error_from_response=_upload_animated_move_errors, **kwargs)
def update_event(stub: GoogleCalendarServiceStub, user_id: str, calendar_id: str, event_id: str, **kwargs): query = GoogleCalendarEvent.Query.Update( user_id=user_id, calendar_id=calendar_id, event_id=event_id, event=GoogleCalendarEvent( summary=StringValue(value=kwargs.get('summary')) if kwargs.get('summary') else None, start=datetime_to_protobuf(kwargs.get('start')) if kwargs.get('start') and type(kwargs.get('start')) is datetime else None, end=datetime_to_protobuf(kwargs.get('end')) if kwargs.get('end') and type(kwargs.get('end')) is datetime else None, description=StringValue(value=kwargs.get('description')) if kwargs.get('description') else None, location=StringValue(value=kwargs.get('location')) if kwargs.get('location') else None)) result = stub.UpdateGoogleCalendarEvent(query) return result
def test_methods(self): with inprocess_grpc_server( Servicer(), test_service_pb2_grpc.add_TestServiceServicer_to_server ) as address: channel = grpc.insecure_channel(address) stub = test_service_pb2_grpc.TestServiceStub(channel) unary_value = StringValue(value="foo") self.assertEqual(unary_value, stub.UnaryUnary(unary_value)) self.assertEqual([unary_value] * 10, list(stub.UnaryStream(unary_value))) data_to_stream = [ StringValue(value="foo"), StringValue(value="bar"), StringValue(value="baz"), ] self.assertEqual( StringValue(value="foobarbaz"), stub.StreamUnary((x for x in data_to_stream)) ) self.assertEqual(data_to_stream, list(stub.StreamStream((x for x in data_to_stream))))
async def _save_result(self, group, task_id, proto, task_results, size_of_state): saved_to_storage = False if self._storage is not None and size_of_state >= self._storage.threshold: saved_to_storage = await self._try_save_to_store([group.group_id, task_id], proto) if saved_to_storage: # record ptr to state task_results.by_id[task_id].CopyFrom(pack_any(StringValue(value=task_id))) else: # record data to state task_results.by_id[task_id].CopyFrom(proto)
def to_pb(self) -> contact_pb2.PostalAddress: if self.birth_date: birth_date = Timestamp() birth_date.FromDatetime( datetime.datetime.combine(self.birth_date, datetime.datetime.min.time())) else: birth_date = None return contact_pb2.PostalAddress( name=self.name, organisation=StringValue( value=self.organisation) if self.organisation else None, streets=self.streets, city=self.city, province=StringValue( value=self.province) if self.province else None, postal_code=StringValue( value=self.postal_code) if self.postal_code else None, country_code=self.country_code, identity_number=StringValue( value=self.identity_number) if self.identity_number else None, birth_date=birth_date)