def beta_create_IPython_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('ipython.IPython', 'cancel'): CancelRequest.FromString, ('ipython.IPython', 'complete'): CompletionRequest.FromString, ('ipython.IPython', 'execute'): ExecuteRequest.FromString, ('ipython.IPython', 'status'): StatusRequest.FromString, ('ipython.IPython', 'stop'): StopRequest.FromString, } response_serializers = { ('ipython.IPython', 'cancel'): CancelResponse.SerializeToString, ('ipython.IPython', 'complete'): CompletionResponse.SerializeToString, ('ipython.IPython', 'execute'): ExecuteResponse.SerializeToString, ('ipython.IPython', 'status'): StatusResponse.SerializeToString, ('ipython.IPython', 'stop'): StopResponse.SerializeToString, } method_implementations = { ('ipython.IPython', 'cancel'): face_utilities.unary_unary_inline(servicer.cancel), ('ipython.IPython', 'complete'): face_utilities.unary_unary_inline(servicer.complete), ('ipython.IPython', 'execute'): face_utilities.unary_stream_inline(servicer.execute), ('ipython.IPython', 'status'): face_utilities.unary_unary_inline(servicer.status), ('ipython.IPython', 'stop'): face_utilities.unary_unary_inline(servicer.stop), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Vitess_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('vtgateservice.Vitess', 'Begin'): vtgate__pb2.BeginRequest.FromString, ('vtgateservice.Vitess', 'Commit'): vtgate__pb2.CommitRequest.FromString, ('vtgateservice.Vitess', 'Execute'): vtgate__pb2.ExecuteRequest.FromString, ('vtgateservice.Vitess', 'ExecuteBatchKeyspaceIds'): vtgate__pb2.ExecuteBatchKeyspaceIdsRequest.FromString, ('vtgateservice.Vitess', 'ExecuteBatchShards'): vtgate__pb2.ExecuteBatchShardsRequest.FromString, ('vtgateservice.Vitess', 'ExecuteEntityIds'): vtgate__pb2.ExecuteEntityIdsRequest.FromString, ('vtgateservice.Vitess', 'ExecuteKeyRanges'): vtgate__pb2.ExecuteKeyRangesRequest.FromString, ('vtgateservice.Vitess', 'ExecuteKeyspaceIds'): vtgate__pb2.ExecuteKeyspaceIdsRequest.FromString, ('vtgateservice.Vitess', 'ExecuteShards'): vtgate__pb2.ExecuteShardsRequest.FromString, ('vtgateservice.Vitess', 'GetSrvKeyspace'): vtgate__pb2.GetSrvKeyspaceRequest.FromString, ('vtgateservice.Vitess', 'Rollback'): vtgate__pb2.RollbackRequest.FromString, ('vtgateservice.Vitess', 'SplitQuery'): vtgate__pb2.SplitQueryRequest.FromString, ('vtgateservice.Vitess', 'StreamExecute'): vtgate__pb2.StreamExecuteRequest.FromString, ('vtgateservice.Vitess', 'StreamExecuteKeyRanges'): vtgate__pb2.StreamExecuteKeyRangesRequest.FromString, ('vtgateservice.Vitess', 'StreamExecuteKeyspaceIds'): vtgate__pb2.StreamExecuteKeyspaceIdsRequest.FromString, ('vtgateservice.Vitess', 'StreamExecuteShards'): vtgate__pb2.StreamExecuteShardsRequest.FromString, ('vtgateservice.Vitess', 'UpdateStream'): vtgate__pb2.UpdateStreamRequest.FromString, } response_serializers = { ('vtgateservice.Vitess', 'Begin'): vtgate__pb2.BeginResponse.SerializeToString, ('vtgateservice.Vitess', 'Commit'): vtgate__pb2.CommitResponse.SerializeToString, ('vtgateservice.Vitess', 'Execute'): vtgate__pb2.ExecuteResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteBatchKeyspaceIds'): vtgate__pb2.ExecuteBatchKeyspaceIdsResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteBatchShards'): vtgate__pb2.ExecuteBatchShardsResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteEntityIds'): vtgate__pb2.ExecuteEntityIdsResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteKeyRanges'): vtgate__pb2.ExecuteKeyRangesResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteKeyspaceIds'): vtgate__pb2.ExecuteKeyspaceIdsResponse.SerializeToString, ('vtgateservice.Vitess', 'ExecuteShards'): vtgate__pb2.ExecuteShardsResponse.SerializeToString, ('vtgateservice.Vitess', 'GetSrvKeyspace'): vtgate__pb2.GetSrvKeyspaceResponse.SerializeToString, ('vtgateservice.Vitess', 'Rollback'): vtgate__pb2.RollbackResponse.SerializeToString, ('vtgateservice.Vitess', 'SplitQuery'): vtgate__pb2.SplitQueryResponse.SerializeToString, ('vtgateservice.Vitess', 'StreamExecute'): vtgate__pb2.StreamExecuteResponse.SerializeToString, ('vtgateservice.Vitess', 'StreamExecuteKeyRanges'): vtgate__pb2.StreamExecuteKeyRangesResponse.SerializeToString, ('vtgateservice.Vitess', 'StreamExecuteKeyspaceIds'): vtgate__pb2.StreamExecuteKeyspaceIdsResponse.SerializeToString, ('vtgateservice.Vitess', 'StreamExecuteShards'): vtgate__pb2.StreamExecuteShardsResponse.SerializeToString, ('vtgateservice.Vitess', 'UpdateStream'): vtgate__pb2.UpdateStreamResponse.SerializeToString, } method_implementations = { ('vtgateservice.Vitess', 'Begin'): face_utilities.unary_unary_inline(servicer.Begin), ('vtgateservice.Vitess', 'Commit'): face_utilities.unary_unary_inline(servicer.Commit), ('vtgateservice.Vitess', 'Execute'): face_utilities.unary_unary_inline(servicer.Execute), ('vtgateservice.Vitess', 'ExecuteBatchKeyspaceIds'): face_utilities.unary_unary_inline(servicer.ExecuteBatchKeyspaceIds), ('vtgateservice.Vitess', 'ExecuteBatchShards'): face_utilities.unary_unary_inline(servicer.ExecuteBatchShards), ('vtgateservice.Vitess', 'ExecuteEntityIds'): face_utilities.unary_unary_inline(servicer.ExecuteEntityIds), ('vtgateservice.Vitess', 'ExecuteKeyRanges'): face_utilities.unary_unary_inline(servicer.ExecuteKeyRanges), ('vtgateservice.Vitess', 'ExecuteKeyspaceIds'): face_utilities.unary_unary_inline(servicer.ExecuteKeyspaceIds), ('vtgateservice.Vitess', 'ExecuteShards'): face_utilities.unary_unary_inline(servicer.ExecuteShards), ('vtgateservice.Vitess', 'GetSrvKeyspace'): face_utilities.unary_unary_inline(servicer.GetSrvKeyspace), ('vtgateservice.Vitess', 'Rollback'): face_utilities.unary_unary_inline(servicer.Rollback), ('vtgateservice.Vitess', 'SplitQuery'): face_utilities.unary_unary_inline(servicer.SplitQuery), ('vtgateservice.Vitess', 'StreamExecute'): face_utilities.unary_stream_inline(servicer.StreamExecute), ('vtgateservice.Vitess', 'StreamExecuteKeyRanges'): face_utilities.unary_stream_inline(servicer.StreamExecuteKeyRanges), ('vtgateservice.Vitess', 'StreamExecuteKeyspaceIds'): face_utilities.unary_stream_inline(servicer.StreamExecuteKeyspaceIds), ('vtgateservice.Vitess', 'StreamExecuteShards'): face_utilities.unary_stream_inline(servicer.StreamExecuteShards), ('vtgateservice.Vitess', 'UpdateStream'): face_utilities.unary_stream_inline(servicer.UpdateStream), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_VariantService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('ga4gh.VariantService', 'GetCallSet'): GetCallSetRequest.FromString, ('ga4gh.VariantService', 'GetVariant'): GetVariantRequest.FromString, ('ga4gh.VariantService', 'GetVariantSet'): GetVariantSetRequest.FromString, ('ga4gh.VariantService', 'SearchCallSets'): SearchCallSetsRequest.FromString, ('ga4gh.VariantService', 'SearchVariantSets'): SearchVariantSetsRequest.FromString, ('ga4gh.VariantService', 'SearchVariants'): SearchVariantsRequest.FromString, } response_serializers = { ('ga4gh.VariantService', 'GetCallSet'): ga4gh_dot_variants__pb2.CallSet.SerializeToString, ('ga4gh.VariantService', 'GetVariant'): ga4gh_dot_variants__pb2.Variant.SerializeToString, ('ga4gh.VariantService', 'GetVariantSet'): ga4gh_dot_variants__pb2.VariantSet.SerializeToString, ('ga4gh.VariantService', 'SearchCallSets'): SearchCallSetsResponse.SerializeToString, ('ga4gh.VariantService', 'SearchVariantSets'): SearchVariantSetsResponse.SerializeToString, ('ga4gh.VariantService', 'SearchVariants'): ga4gh_dot_variants__pb2.Variant.SerializeToString, } method_implementations = { ('ga4gh.VariantService', 'GetCallSet'): face_utilities.unary_unary_inline(servicer.GetCallSet), ('ga4gh.VariantService', 'GetVariant'): face_utilities.unary_unary_inline(servicer.GetVariant), ('ga4gh.VariantService', 'GetVariantSet'): face_utilities.unary_unary_inline(servicer.GetVariantSet), ('ga4gh.VariantService', 'SearchCallSets'): face_utilities.unary_unary_inline(servicer.SearchCallSets), ('ga4gh.VariantService', 'SearchVariantSets'): face_utilities.unary_unary_inline(servicer.SearchVariantSets), ('ga4gh.VariantService', 'SearchVariants'): face_utilities.unary_stream_inline(servicer.SearchVariants), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def setUp(self): self._servicer = _Servicer() self._method_implementations = { (_GROUP, _UNARY_UNARY): utilities.unary_unary_inline(self._servicer.unary_unary), (_GROUP, _UNARY_STREAM): utilities.unary_stream_inline(self._servicer.unary_stream), (_GROUP, _STREAM_UNARY): utilities.stream_unary_inline(self._servicer.stream_unary), (_GROUP, _STREAM_STREAM): utilities.stream_stream_inline(self._servicer.stream_stream), } self._cardinalities = { _UNARY_UNARY: cardinality.Cardinality.UNARY_UNARY, _UNARY_STREAM: cardinality.Cardinality.UNARY_STREAM, _STREAM_UNARY: cardinality.Cardinality.STREAM_UNARY, _STREAM_STREAM: cardinality.Cardinality.STREAM_STREAM, } self._server_options = implementations.server_options( thread_pool_size=test_constants.POOL_SIZE) self._server_credentials = implementations.ssl_server_credentials([ ( resources.private_key(), resources.certificate_chain(), ), ]) self._channel_credentials = implementations.ssl_channel_credentials( resources.test_root_certificates()) self._stub_options = implementations.stub_options( thread_pool_size=test_constants.POOL_SIZE)
def instantiate( self, methods, method_implementations, multi_method_implementation): serialization_behaviors = _serialization_behaviors_from_test_methods( methods) # TODO(nathaniel): Add a "groups" attribute to _digest.TestServiceDigest. service = next(iter(methods))[0] # TODO(nathaniel): Add a "cardinalities_by_group" attribute to # _digest.TestServiceDigest. cardinalities = { method: method_object.cardinality() for (group, method), method_object in six.iteritems(methods)} server_options = implementations.server_options( request_deserializers=serialization_behaviors.request_deserializers, response_serializers=serialization_behaviors.response_serializers, thread_pool_size=test_constants.POOL_SIZE) server = implementations.server( method_implementations, options=server_options) server_credentials = implementations.ssl_server_credentials( [(resources.private_key(), resources.certificate_chain(),),]) port = server.add_secure_port('[::]:0', server_credentials) server.start() channel_credentials = implementations.ssl_channel_credentials( resources.test_root_certificates()) channel = test_utilities.not_really_secure_channel( 'localhost', port, channel_credentials, _SERVER_HOST_OVERRIDE) stub_options = implementations.stub_options( request_serializers=serialization_behaviors.request_serializers, response_deserializers=serialization_behaviors.response_deserializers, thread_pool_size=test_constants.POOL_SIZE) generic_stub = implementations.generic_stub(channel, options=stub_options) dynamic_stub = implementations.dynamic_stub( channel, service, cardinalities, options=stub_options) return generic_stub, {service: dynamic_stub}, server
def beta_create_PredictionService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('tensorflow.serving.PredictionService', 'DynamicReload'): model__server__config__pb2.ModelServerConfig.FromString, } response_serializers = { ('tensorflow.serving.PredictionService', 'DynamicReload'): ReloadResponse.SerializeToString, } method_implementations = { ('tensorflow.serving.PredictionService', 'DynamicReload'): face_utilities.unary_unary_inline(servicer.DynamicReload), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Datastore_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('google.datastore.v1beta3.Datastore', 'AllocateIds'): AllocateIdsRequest.FromString, ('google.datastore.v1beta3.Datastore', 'BeginTransaction'): BeginTransactionRequest.FromString, ('google.datastore.v1beta3.Datastore', 'Commit'): CommitRequest.FromString, ('google.datastore.v1beta3.Datastore', 'Lookup'): LookupRequest.FromString, ('google.datastore.v1beta3.Datastore', 'Rollback'): RollbackRequest.FromString, ('google.datastore.v1beta3.Datastore', 'RunQuery'): RunQueryRequest.FromString, } response_serializers = { ('google.datastore.v1beta3.Datastore', 'AllocateIds'): AllocateIdsResponse.SerializeToString, ('google.datastore.v1beta3.Datastore', 'BeginTransaction'): BeginTransactionResponse.SerializeToString, ('google.datastore.v1beta3.Datastore', 'Commit'): CommitResponse.SerializeToString, ('google.datastore.v1beta3.Datastore', 'Lookup'): LookupResponse.SerializeToString, ('google.datastore.v1beta3.Datastore', 'Rollback'): RollbackResponse.SerializeToString, ('google.datastore.v1beta3.Datastore', 'RunQuery'): RunQueryResponse.SerializeToString, } method_implementations = { ('google.datastore.v1beta3.Datastore', 'AllocateIds'): face_utilities.unary_unary_inline(servicer.AllocateIds), ('google.datastore.v1beta3.Datastore', 'BeginTransaction'): face_utilities.unary_unary_inline(servicer.BeginTransaction), ('google.datastore.v1beta3.Datastore', 'Commit'): face_utilities.unary_unary_inline(servicer.Commit), ('google.datastore.v1beta3.Datastore', 'Lookup'): face_utilities.unary_unary_inline(servicer.Lookup), ('google.datastore.v1beta3.Datastore', 'Rollback'): face_utilities.unary_unary_inline(servicer.Rollback), ('google.datastore.v1beta3.Datastore', 'RunQuery'): face_utilities.unary_unary_inline(servicer.RunQuery), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_HelloService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('hello.HelloService', 'BidiHello'): HelloRequest.FromString, ('hello.HelloService', 'LotsOfGreetings'): HelloRequest.FromString, ('hello.HelloService', 'LotsOfReplies'): HelloRequest.FromString, ('hello.HelloService', 'SayHello'): HelloRequest.FromString, } response_serializers = { ('hello.HelloService', 'BidiHello'): HelloResponse.SerializeToString, ('hello.HelloService', 'LotsOfGreetings'): HelloResponse.SerializeToString, ('hello.HelloService', 'LotsOfReplies'): HelloResponse.SerializeToString, ('hello.HelloService', 'SayHello'): HelloResponse.SerializeToString, } method_implementations = { ('hello.HelloService', 'BidiHello'): face_utilities.stream_stream_inline(servicer.BidiHello), ('hello.HelloService', 'LotsOfGreetings'): face_utilities.stream_unary_inline(servicer.LotsOfGreetings), ('hello.HelloService', 'LotsOfReplies'): face_utilities.unary_stream_inline(servicer.LotsOfReplies), ('hello.HelloService', 'SayHello'): face_utilities.unary_unary_inline(servicer.SayHello), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Seldon_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('io.seldon.api.rpc.Seldon', 'Classify'): ClassificationRequest.FromString, } response_serializers = { ('io.seldon.api.rpc.Seldon', 'Classify'): ClassificationReply.SerializeToString, } method_implementations = { ('io.seldon.api.rpc.Seldon', 'Classify'): face_utilities.unary_unary_inline(servicer.Classify), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_DbService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('DbService', 'FetchDoctors'): Empty.FromString, ('DbService', 'FetchPatients'): Empty.FromString, ('DbService', 'FetchTechnicians'): Empty.FromString, ('DbService', 'NewDoctor'): Person.FromString, ('DbService', 'NewPatient'): Person.FromString, ('DbService', 'NewTechnician'): Person.FromString, } response_serializers = { ('DbService', 'FetchDoctors'): Doctor.SerializeToString, ('DbService', 'FetchPatients'): Patient.SerializeToString, ('DbService', 'FetchTechnicians'): Technician.SerializeToString, ('DbService', 'NewDoctor'): Doctor.SerializeToString, ('DbService', 'NewPatient'): Patient.SerializeToString, ('DbService', 'NewTechnician'): Technician.SerializeToString, } method_implementations = { ('DbService', 'FetchDoctors'): face_utilities.unary_stream_inline(servicer.FetchDoctors), ('DbService', 'FetchPatients'): face_utilities.unary_stream_inline(servicer.FetchPatients), ('DbService', 'FetchTechnicians'): face_utilities.unary_stream_inline(servicer.FetchTechnicians), ('DbService', 'NewDoctor'): face_utilities.unary_unary_inline(servicer.NewDoctor), ('DbService', 'NewPatient'): face_utilities.unary_unary_inline(servicer.NewPatient), ('DbService', 'NewTechnician'): face_utilities.unary_unary_inline(servicer.NewTechnician), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_MetricsServiceV2_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('google.logging.v2.MetricsServiceV2', 'CreateLogMetric'): CreateLogMetricRequest.FromString, ('google.logging.v2.MetricsServiceV2', 'DeleteLogMetric'): DeleteLogMetricRequest.FromString, ('google.logging.v2.MetricsServiceV2', 'GetLogMetric'): GetLogMetricRequest.FromString, ('google.logging.v2.MetricsServiceV2', 'ListLogMetrics'): ListLogMetricsRequest.FromString, ('google.logging.v2.MetricsServiceV2', 'UpdateLogMetric'): UpdateLogMetricRequest.FromString, } response_serializers = { ('google.logging.v2.MetricsServiceV2', 'CreateLogMetric'): LogMetric.SerializeToString, ('google.logging.v2.MetricsServiceV2', 'DeleteLogMetric'): google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, ('google.logging.v2.MetricsServiceV2', 'GetLogMetric'): LogMetric.SerializeToString, ('google.logging.v2.MetricsServiceV2', 'ListLogMetrics'): ListLogMetricsResponse.SerializeToString, ('google.logging.v2.MetricsServiceV2', 'UpdateLogMetric'): LogMetric.SerializeToString, } method_implementations = { ('google.logging.v2.MetricsServiceV2', 'CreateLogMetric'): face_utilities.unary_unary_inline(servicer.CreateLogMetric), ('google.logging.v2.MetricsServiceV2', 'DeleteLogMetric'): face_utilities.unary_unary_inline(servicer.DeleteLogMetric), ('google.logging.v2.MetricsServiceV2', 'GetLogMetric'): face_utilities.unary_unary_inline(servicer.GetLogMetric), ('google.logging.v2.MetricsServiceV2', 'ListLogMetrics'): face_utilities.unary_unary_inline(servicer.ListLogMetrics), ('google.logging.v2.MetricsServiceV2', 'UpdateLogMetric'): face_utilities.unary_unary_inline(servicer.UpdateLogMetric), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BfDatafeedService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 import bftrader_pb2 request_deserializers = { ('bftrader.bfdatafeed.BfDatafeedService', 'GetBar'): bftrader_pb2.BfGetBarReq.FromString, ('bftrader.bfdatafeed.BfDatafeedService', 'GetTickPack'): bftrader_pb2.BfGetTickPackReq.FromString, ('bftrader.bfdatafeed.BfDatafeedService', 'InsertBar'): bftrader_pb2.BfBarData.FromString, ('bftrader.bfdatafeed.BfDatafeedService', 'InsertTickPack'): bftrader_pb2.BfTickPackData.FromString, } response_serializers = { ('bftrader.bfdatafeed.BfDatafeedService', 'GetBar'): bftrader_pb2.BfBarData.SerializeToString, ('bftrader.bfdatafeed.BfDatafeedService', 'GetTickPack'): bftrader_pb2.BfTickPackData.SerializeToString, ('bftrader.bfdatafeed.BfDatafeedService', 'InsertBar'): bftrader_pb2.BfVoid.SerializeToString, ('bftrader.bfdatafeed.BfDatafeedService', 'InsertTickPack'): bftrader_pb2.BfVoid.SerializeToString, } method_implementations = { ('bftrader.bfdatafeed.BfDatafeedService', 'GetBar'): face_utilities.unary_stream_inline(servicer.GetBar), ('bftrader.bfdatafeed.BfDatafeedService', 'GetTickPack'): face_utilities.unary_stream_inline(servicer.GetTickPack), ('bftrader.bfdatafeed.BfDatafeedService', 'InsertBar'): face_utilities.unary_unary_inline(servicer.InsertBar), ('bftrader.bfdatafeed.BfDatafeedService', 'InsertTickPack'): face_utilities.unary_unary_inline(servicer.InsertTickPack), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_MysqlCtl_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import mysqlctl_pb2 import mysqlctl_pb2 import mysqlctl_pb2 import mysqlctl_pb2 import mysqlctl_pb2 import mysqlctl_pb2 import mysqlctl_pb2 import mysqlctl_pb2 request_deserializers = { ('mysqlctl.MysqlCtl', 'ReinitConfig'): mysqlctl_pb2.ReinitConfigRequest.FromString, ('mysqlctl.MysqlCtl', 'RunMysqlUpgrade'): mysqlctl_pb2.RunMysqlUpgradeRequest.FromString, ('mysqlctl.MysqlCtl', 'Shutdown'): mysqlctl_pb2.ShutdownRequest.FromString, ('mysqlctl.MysqlCtl', 'Start'): mysqlctl_pb2.StartRequest.FromString, } response_serializers = { ('mysqlctl.MysqlCtl', 'ReinitConfig'): mysqlctl_pb2.ReinitConfigResponse.SerializeToString, ('mysqlctl.MysqlCtl', 'RunMysqlUpgrade'): mysqlctl_pb2.RunMysqlUpgradeResponse.SerializeToString, ('mysqlctl.MysqlCtl', 'Shutdown'): mysqlctl_pb2.ShutdownResponse.SerializeToString, ('mysqlctl.MysqlCtl', 'Start'): mysqlctl_pb2.StartResponse.SerializeToString, } method_implementations = { ('mysqlctl.MysqlCtl', 'ReinitConfig'): face_utilities.unary_unary_inline(servicer.ReinitConfig), ('mysqlctl.MysqlCtl', 'RunMysqlUpgrade'): face_utilities.unary_unary_inline(servicer.RunMysqlUpgrade), ('mysqlctl.MysqlCtl', 'Shutdown'): face_utilities.unary_unary_inline(servicer.Shutdown), ('mysqlctl.MysqlCtl', 'Start'): face_utilities.unary_unary_inline(servicer.Start), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Operations_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import google.longrunning.operations_pb2 import google.longrunning.operations_pb2 import google.longrunning.operations_pb2 import google.longrunning.operations_pb2 import google.longrunning.operations_pb2 import google.protobuf.empty_pb2 import google.longrunning.operations_pb2 import google.protobuf.empty_pb2 request_deserializers = { ('google.longrunning.Operations', 'CancelOperation'): google.longrunning.operations_pb2.CancelOperationRequest.FromString, ('google.longrunning.Operations', 'DeleteOperation'): google.longrunning.operations_pb2.DeleteOperationRequest.FromString, ('google.longrunning.Operations', 'GetOperation'): google.longrunning.operations_pb2.GetOperationRequest.FromString, ('google.longrunning.Operations', 'ListOperations'): google.longrunning.operations_pb2.ListOperationsRequest.FromString, } response_serializers = { ('google.longrunning.Operations', 'CancelOperation'): google.protobuf.empty_pb2.Empty.SerializeToString, ('google.longrunning.Operations', 'DeleteOperation'): google.protobuf.empty_pb2.Empty.SerializeToString, ('google.longrunning.Operations', 'GetOperation'): google.longrunning.operations_pb2.Operation.SerializeToString, ('google.longrunning.Operations', 'ListOperations'): google.longrunning.operations_pb2.ListOperationsResponse.SerializeToString, } method_implementations = { ('google.longrunning.Operations', 'CancelOperation'): face_utilities.unary_unary_inline(servicer.CancelOperation), ('google.longrunning.Operations', 'DeleteOperation'): face_utilities.unary_unary_inline(servicer.DeleteOperation), ('google.longrunning.Operations', 'GetOperation'): face_utilities.unary_unary_inline(servicer.GetOperation), ('google.longrunning.Operations', 'ListOperations'): face_utilities.unary_unary_inline(servicer.ListOperations), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Candidate_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import debate_pb2 import debate_pb2 import debate_pb2 import debate_pb2 request_deserializers = { ('debate.Candidate', 'Answer'): debate_pb2.AnswerRequest.FromString, ('debate.Candidate', 'Elaborate'): debate_pb2.ElaborateRequest.FromString, } response_serializers = { ('debate.Candidate', 'Answer'): debate_pb2.AnswerReply.SerializeToString, ('debate.Candidate', 'Elaborate'): debate_pb2.ElaborateReply.SerializeToString, } method_implementations = { ('debate.Candidate', 'Answer'): face_utilities.unary_unary_inline(servicer.Answer), ('debate.Candidate', 'Elaborate'): face_utilities.unary_unary_inline(servicer.Elaborate), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_CloudWindmillServiceV1Alpha1_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import windmill_pb2 import windmill_pb2 import windmill_pb2 import windmill_pb2 import windmill_pb2 import windmill_pb2 import windmill_pb2 import windmill_pb2 import windmill_pb2 import windmill_pb2 request_deserializers = { ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'CommitWork'): windmill_pb2.CommitWorkRequest.FromString, ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'GetConfig'): windmill_pb2.GetConfigRequest.FromString, ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'GetData'): windmill_pb2.GetDataRequest.FromString, ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'GetWork'): windmill_pb2.GetWorkRequest.FromString, ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'ReportStats'): windmill_pb2.ReportStatsRequest.FromString, } response_serializers = { ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'CommitWork'): windmill_pb2.CommitWorkResponse.SerializeToString, ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'GetConfig'): windmill_pb2.GetConfigResponse.SerializeToString, ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'GetData'): windmill_pb2.GetDataResponse.SerializeToString, ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'GetWork'): windmill_pb2.GetWorkResponse.SerializeToString, ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'ReportStats'): windmill_pb2.ReportStatsResponse.SerializeToString, } method_implementations = { ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'CommitWork'): face_utilities.unary_unary_inline(servicer.CommitWork), ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'GetConfig'): face_utilities.unary_unary_inline(servicer.GetConfig), ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'GetData'): face_utilities.unary_unary_inline(servicer.GetData), ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'GetWork'): face_utilities.unary_unary_inline(servicer.GetWork), ('google.dataflow.windmillservice.v1alpha1.CloudWindmillServiceV1Alpha1', 'ReportStats'): face_utilities.unary_unary_inline(servicer.ReportStats), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_ChaincodeSupport_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('hfc.protos.peer.ChaincodeSupport', 'Register'): ChaincodeMessage.FromString, } response_serializers = { ('hfc.protos.peer.ChaincodeSupport', 'Register'): ChaincodeMessage.SerializeToString, } method_implementations = { ('hfc.protos.peer.ChaincodeSupport', 'Register'): face_utilities.stream_stream_inline(servicer.Register), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_NetworkServer_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('networkserver.NetworkServer', 'Activate'): github__com_dot_TheThingsNetwork_dot_api_dot_handler_dot_handler__pb2.DeviceActivationResponse.FromString, ('networkserver.NetworkServer', 'Downlink'): github__com_dot_TheThingsNetwork_dot_api_dot_broker_dot_broker__pb2.DownlinkMessage.FromString, ('networkserver.NetworkServer', 'GetDevices'): DevicesRequest.FromString, ('networkserver.NetworkServer', 'PrepareActivation'): github__com_dot_TheThingsNetwork_dot_api_dot_broker_dot_broker__pb2.DeduplicatedDeviceActivationRequest.FromString, ('networkserver.NetworkServer', 'Uplink'): github__com_dot_TheThingsNetwork_dot_api_dot_broker_dot_broker__pb2.DeduplicatedUplinkMessage.FromString, } response_serializers = { ('networkserver.NetworkServer', 'Activate'): github__com_dot_TheThingsNetwork_dot_api_dot_handler_dot_handler__pb2.DeviceActivationResponse.SerializeToString, ('networkserver.NetworkServer', 'Downlink'): github__com_dot_TheThingsNetwork_dot_api_dot_broker_dot_broker__pb2.DownlinkMessage.SerializeToString, ('networkserver.NetworkServer', 'GetDevices'): DevicesResponse.SerializeToString, ('networkserver.NetworkServer', 'PrepareActivation'): github__com_dot_TheThingsNetwork_dot_api_dot_broker_dot_broker__pb2.DeduplicatedDeviceActivationRequest.SerializeToString, ('networkserver.NetworkServer', 'Uplink'): github__com_dot_TheThingsNetwork_dot_api_dot_broker_dot_broker__pb2.DeduplicatedUplinkMessage.SerializeToString, } method_implementations = { ('networkserver.NetworkServer', 'Activate'): face_utilities.unary_unary_inline(servicer.Activate), ('networkserver.NetworkServer', 'Downlink'): face_utilities.unary_unary_inline(servicer.Downlink), ('networkserver.NetworkServer', 'GetDevices'): face_utilities.unary_unary_inline(servicer.GetDevices), ('networkserver.NetworkServer', 'PrepareActivation'): face_utilities.unary_unary_inline(servicer.PrepareActivation), ('networkserver.NetworkServer', 'Uplink'): face_utilities.unary_unary_inline(servicer.Uplink), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_SystemUtilizationService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('com.brocade.telemetry.systemutilization.SystemUtilizationService', 'ListSystemUtilizationStatistics'): SystemUtilizationProfileRequest.FromString, } response_serializers = { ('com.brocade.telemetry.systemutilization.SystemUtilizationService', 'ListSystemUtilizationStatistics'): SystemUtilizationProfileResponse.SerializeToString, } method_implementations = { ('com.brocade.telemetry.systemutilization.SystemUtilizationService', 'ListSystemUtilizationStatistics'): face_utilities.unary_stream_inline( servicer.ListSystemUtilizationStatistics), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_MetricsServiceV2_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import google.logging.v2.logging_metrics_pb2 import google.logging.v2.logging_metrics_pb2 import google.logging.v2.logging_metrics_pb2 import google.logging.v2.logging_metrics_pb2 import google.logging.v2.logging_metrics_pb2 import google.logging.v2.logging_metrics_pb2 import google.logging.v2.logging_metrics_pb2 import google.logging.v2.logging_metrics_pb2 import google.logging.v2.logging_metrics_pb2 import google.protobuf.empty_pb2 request_deserializers = { ('google.logging.v2.MetricsServiceV2', 'CreateLogMetric'): google.logging.v2.logging_metrics_pb2.CreateLogMetricRequest.FromString, ('google.logging.v2.MetricsServiceV2', 'DeleteLogMetric'): google.logging.v2.logging_metrics_pb2.DeleteLogMetricRequest.FromString, ('google.logging.v2.MetricsServiceV2', 'GetLogMetric'): google.logging.v2.logging_metrics_pb2.GetLogMetricRequest.FromString, ('google.logging.v2.MetricsServiceV2', 'ListLogMetrics'): google.logging.v2.logging_metrics_pb2.ListLogMetricsRequest.FromString, ('google.logging.v2.MetricsServiceV2', 'UpdateLogMetric'): google.logging.v2.logging_metrics_pb2.UpdateLogMetricRequest.FromString, } response_serializers = { ('google.logging.v2.MetricsServiceV2', 'CreateLogMetric'): google.logging.v2.logging_metrics_pb2.LogMetric.SerializeToString, ('google.logging.v2.MetricsServiceV2', 'DeleteLogMetric'): google.protobuf.empty_pb2.Empty.SerializeToString, ('google.logging.v2.MetricsServiceV2', 'GetLogMetric'): google.logging.v2.logging_metrics_pb2.LogMetric.SerializeToString, ('google.logging.v2.MetricsServiceV2', 'ListLogMetrics'): google.logging.v2.logging_metrics_pb2.ListLogMetricsResponse.SerializeToString, ('google.logging.v2.MetricsServiceV2', 'UpdateLogMetric'): google.logging.v2.logging_metrics_pb2.LogMetric.SerializeToString, } method_implementations = { ('google.logging.v2.MetricsServiceV2', 'CreateLogMetric'): face_utilities.unary_unary_inline(servicer.CreateLogMetric), ('google.logging.v2.MetricsServiceV2', 'DeleteLogMetric'): face_utilities.unary_unary_inline(servicer.DeleteLogMetric), ('google.logging.v2.MetricsServiceV2', 'GetLogMetric'): face_utilities.unary_unary_inline(servicer.GetLogMetric), ('google.logging.v2.MetricsServiceV2', 'ListLogMetrics'): face_utilities.unary_unary_inline(servicer.ListLogMetrics), ('google.logging.v2.MetricsServiceV2', 'UpdateLogMetric'): face_utilities.unary_unary_inline(servicer.UpdateLogMetric), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_InferenceService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('tensorflow.serving.InferenceService', 'DoInference'): InferenceRequest.FromString, } response_serializers = { ('tensorflow.serving.InferenceService', 'DoInference'): InferenceResponse.SerializeToString, } method_implementations = { ('tensorflow.serving.InferenceService', 'DoInference'): face_utilities.unary_unary_inline(servicer.DoInference), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_StockHQService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('stock_hq.StockHQService', 'QA_fetch_p2p'): query_struct.FromString, ('stock_hq.StockHQService', 'QA_fetch_p2s'): query_struct.FromString, ('stock_hq.StockHQService', 'QA_fetch_s2p'): query_struct.FromString, ('stock_hq.StockHQService', 'QA_fetch_s2s'): query_struct.FromString, } response_serializers = { ('stock_hq.StockHQService', 'QA_fetch_p2p'): hq_struct.SerializeToString, ('stock_hq.StockHQService', 'QA_fetch_p2s'): hq_struct.SerializeToString, ('stock_hq.StockHQService', 'QA_fetch_s2p'): hq_struct.SerializeToString, ('stock_hq.StockHQService', 'QA_fetch_s2s'): hq_struct.SerializeToString, } method_implementations = { ('stock_hq.StockHQService', 'QA_fetch_p2p'): face_utilities.unary_unary_inline(servicer.QA_fetch_p2p), ('stock_hq.StockHQService', 'QA_fetch_p2s'): face_utilities.unary_stream_inline(servicer.QA_fetch_p2s), ('stock_hq.StockHQService', 'QA_fetch_s2p'): face_utilities.stream_unary_inline(servicer.QA_fetch_s2p), ('stock_hq.StockHQService', 'QA_fetch_s2s'): face_utilities.stream_stream_inline(servicer.QA_fetch_s2s), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_PredictionService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('tensorflow.serving.PredictionService', 'Classify'): tensorflow__serving_dot_apis_dot_classification__pb2.ClassificationRequest.FromString, ('tensorflow.serving.PredictionService', 'GetModelMetadata'): tensorflow__serving_dot_apis_dot_get__model__metadata__pb2.GetModelMetadataRequest.FromString, ('tensorflow.serving.PredictionService', 'Predict'): tensorflow__serving_dot_apis_dot_predict__pb2.PredictRequest.FromString, ('tensorflow.serving.PredictionService', 'Regress'): tensorflow__serving_dot_apis_dot_regression__pb2.RegressionRequest.FromString, } response_serializers = { ('tensorflow.serving.PredictionService', 'Classify'): tensorflow__serving_dot_apis_dot_classification__pb2.ClassificationResponse.SerializeToString, ('tensorflow.serving.PredictionService', 'GetModelMetadata'): tensorflow__serving_dot_apis_dot_get__model__metadata__pb2.GetModelMetadataResponse.SerializeToString, ('tensorflow.serving.PredictionService', 'Predict'): tensorflow__serving_dot_apis_dot_predict__pb2.PredictResponse.SerializeToString, ('tensorflow.serving.PredictionService', 'Regress'): tensorflow__serving_dot_apis_dot_regression__pb2.RegressionResponse.SerializeToString, } method_implementations = { ('tensorflow.serving.PredictionService', 'Classify'): face_utilities.unary_unary_inline(servicer.Classify), ('tensorflow.serving.PredictionService', 'GetModelMetadata'): face_utilities.unary_unary_inline(servicer.GetModelMetadata), ('tensorflow.serving.PredictionService', 'Predict'): face_utilities.unary_unary_inline(servicer.Predict), ('tensorflow.serving.PredictionService', 'Regress'): face_utilities.unary_unary_inline(servicer.Regress), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BfKvService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('bfkv.BfKvService', 'GetKv'): bfgateway__pb2.BfKvData.FromString, ('bfkv.BfKvService', 'Ping'): bfgateway__pb2.BfPingData.FromString, ('bfkv.BfKvService', 'PingStreamC'): google_dot_protobuf_dot_any__pb2.Any.FromString, ('bfkv.BfKvService', 'PingStreamCS'): google_dot_protobuf_dot_any__pb2.Any.FromString, ('bfkv.BfKvService', 'PingStreamS'): google_dot_protobuf_dot_any__pb2.Any.FromString, ('bfkv.BfKvService', 'SetKv'): bfgateway__pb2.BfKvData.FromString, } response_serializers = { ('bfkv.BfKvService', 'GetKv'): bfgateway__pb2.BfKvData.SerializeToString, ('bfkv.BfKvService', 'Ping'): bfgateway__pb2.BfPingData.SerializeToString, ('bfkv.BfKvService', 'PingStreamC'): google_dot_protobuf_dot_any__pb2.Any.SerializeToString, ('bfkv.BfKvService', 'PingStreamCS'): google_dot_protobuf_dot_any__pb2.Any.SerializeToString, ('bfkv.BfKvService', 'PingStreamS'): google_dot_protobuf_dot_any__pb2.Any.SerializeToString, ('bfkv.BfKvService', 'SetKv'): bfgateway__pb2.BfVoid.SerializeToString, } method_implementations = { ('bfkv.BfKvService', 'GetKv'): face_utilities.unary_unary_inline(servicer.GetKv), ('bfkv.BfKvService', 'Ping'): face_utilities.unary_unary_inline(servicer.Ping), ('bfkv.BfKvService', 'PingStreamC'): face_utilities.stream_unary_inline(servicer.PingStreamC), ('bfkv.BfKvService', 'PingStreamCS'): face_utilities.stream_stream_inline(servicer.PingStreamCS), ('bfkv.BfKvService', 'PingStreamS'): face_utilities.unary_stream_inline(servicer.PingStreamS), ('bfkv.BfKvService', 'SetKv'): face_utilities.unary_unary_inline(servicer.SetKv), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_UberAPIService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import uber_pb2 import uber_pb2 import uber_pb2 import uber_pb2 import uber_pb2 import uber_pb2 import google.protobuf.empty_pb2 import uber_pb2 import uber_pb2 import uber_pb2 request_deserializers = { ('uberapi.UberAPIService', 'GetEstimatesPrice'): uber_pb2.GetEstimatesPriceRequest.FromString, ('uberapi.UberAPIService', 'GetEstimatesTime'): uber_pb2.GetEstimatesTimeRequest.FromString, ('uberapi.UberAPIService', 'GetHistory'): uber_pb2.GetHistoryRequest.FromString, ('uberapi.UberAPIService', 'GetMe'): google.protobuf.empty_pb2.Empty.FromString, ('uberapi.UberAPIService', 'GetProducts'): uber_pb2.GetProductsRequest.FromString, } response_serializers = { ('uberapi.UberAPIService', 'GetEstimatesPrice'): uber_pb2.GetEstimatesPriceResponse.SerializeToString, ('uberapi.UberAPIService', 'GetEstimatesTime'): uber_pb2.GetEstimatesTimeResponse.SerializeToString, ('uberapi.UberAPIService', 'GetHistory'): uber_pb2.Activities.SerializeToString, ('uberapi.UberAPIService', 'GetMe'): uber_pb2.Profile.SerializeToString, ('uberapi.UberAPIService', 'GetProducts'): uber_pb2.GetProductsResponse.SerializeToString, } method_implementations = { ('uberapi.UberAPIService', 'GetEstimatesPrice'): face_utilities.unary_unary_inline(servicer.GetEstimatesPrice), ('uberapi.UberAPIService', 'GetEstimatesTime'): face_utilities.unary_unary_inline(servicer.GetEstimatesTime), ('uberapi.UberAPIService', 'GetHistory'): face_utilities.unary_unary_inline(servicer.GetHistory), ('uberapi.UberAPIService', 'GetMe'): face_utilities.unary_unary_inline(servicer.GetMe), ('uberapi.UberAPIService', 'GetProducts'): face_utilities.unary_unary_inline(servicer.GetProducts), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_UsersService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('soboto.users.UsersService', 'getBOUserInfo'): GetBOUserInfoRequest.FromString, ('soboto.users.UsersService', 'getCustomerInfo'): GetCustomerInfoRequest.FromString, ('soboto.users.UsersService', 'getUserPermissions'): GetUserPermissionsRequest.FromString, ('soboto.users.UsersService', 'setEntityOwner'): SetEntityOwnerRequest.FromString, ('soboto.users.UsersService', 'validateAuthenticationToken'): ValidateAuthenticationTokenRequest.FromString, } response_serializers = { ('soboto.users.UsersService', 'getBOUserInfo'): GetBOUserInfoResponse.SerializeToString, ('soboto.users.UsersService', 'getCustomerInfo'): GetCustomerInfoResponse.SerializeToString, ('soboto.users.UsersService', 'getUserPermissions'): GetUserPermissionsResponse.SerializeToString, ('soboto.users.UsersService', 'setEntityOwner'): SetEntityOwnerResponse.SerializeToString, ('soboto.users.UsersService', 'validateAuthenticationToken'): ValidateAuthenticationTokenResponse.SerializeToString, } method_implementations = { ('soboto.users.UsersService', 'getBOUserInfo'): face_utilities.unary_unary_inline(servicer.getBOUserInfo), ('soboto.users.UsersService', 'getCustomerInfo'): face_utilities.unary_unary_inline(servicer.getCustomerInfo), ('soboto.users.UsersService', 'getUserPermissions'): face_utilities.unary_unary_inline(servicer.getUserPermissions), ('soboto.users.UsersService', 'setEntityOwner'): face_utilities.unary_unary_inline(servicer.setEntityOwner), ('soboto.users.UsersService', 'validateAuthenticationToken'): face_utilities.unary_unary_inline(servicer.validateAuthenticationToken), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_EmbeddedAssistant_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('google.assistant.embedded.v1alpha1.EmbeddedAssistant', 'Converse'): ConverseRequest.FromString, } response_serializers = { ('google.assistant.embedded.v1alpha1.EmbeddedAssistant', 'Converse'): ConverseResponse.SerializeToString, } method_implementations = { ('google.assistant.embedded.v1alpha1.EmbeddedAssistant', 'Converse'): face_utilities.stream_stream_inline(servicer.Converse), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Throttler_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import throttlerdata_pb2 import throttlerdata_pb2 import throttlerdata_pb2 import throttlerdata_pb2 import throttlerdata_pb2 import throttlerdata_pb2 import throttlerdata_pb2 import throttlerdata_pb2 import throttlerdata_pb2 import throttlerdata_pb2 request_deserializers = { ('throttlerservice.Throttler', 'GetConfiguration'): throttlerdata_pb2.GetConfigurationRequest.FromString, ('throttlerservice.Throttler', 'MaxRates'): throttlerdata_pb2.MaxRatesRequest.FromString, ('throttlerservice.Throttler', 'ResetConfiguration'): throttlerdata_pb2.ResetConfigurationRequest.FromString, ('throttlerservice.Throttler', 'SetMaxRate'): throttlerdata_pb2.SetMaxRateRequest.FromString, ('throttlerservice.Throttler', 'UpdateConfiguration'): throttlerdata_pb2.UpdateConfigurationRequest.FromString, } response_serializers = { ('throttlerservice.Throttler', 'GetConfiguration'): throttlerdata_pb2.GetConfigurationResponse.SerializeToString, ('throttlerservice.Throttler', 'MaxRates'): throttlerdata_pb2.MaxRatesResponse.SerializeToString, ('throttlerservice.Throttler', 'ResetConfiguration'): throttlerdata_pb2.ResetConfigurationResponse.SerializeToString, ('throttlerservice.Throttler', 'SetMaxRate'): throttlerdata_pb2.SetMaxRateResponse.SerializeToString, ('throttlerservice.Throttler', 'UpdateConfiguration'): throttlerdata_pb2.UpdateConfigurationResponse.SerializeToString, } method_implementations = { ('throttlerservice.Throttler', 'GetConfiguration'): face_utilities.unary_unary_inline(servicer.GetConfiguration), ('throttlerservice.Throttler', 'MaxRates'): face_utilities.unary_unary_inline(servicer.MaxRates), ('throttlerservice.Throttler', 'ResetConfiguration'): face_utilities.unary_unary_inline(servicer.ResetConfiguration), ('throttlerservice.Throttler', 'SetMaxRate'): face_utilities.unary_unary_inline(servicer.SetMaxRate), ('throttlerservice.Throttler', 'UpdateConfiguration'): face_utilities.unary_unary_inline(servicer.UpdateConfiguration), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Vtctl_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import vtctldata_pb2 import vtctldata_pb2 request_deserializers = { ('vtctlservice.Vtctl', 'ExecuteVtctlCommand'): vtctldata_pb2.ExecuteVtctlCommandRequest.FromString, } response_serializers = { ('vtctlservice.Vtctl', 'ExecuteVtctlCommand'): vtctldata_pb2.ExecuteVtctlCommandResponse.SerializeToString, } method_implementations = { ('vtctlservice.Vtctl', 'ExecuteVtctlCommand'): face_utilities.unary_stream_inline(servicer.ExecuteVtctlCommand), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_MnistService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import mnist_inference_pb2 import mnist_inference_pb2 request_deserializers = { ('tensorflow.serving.MnistService', 'Classify'): mnist_inference_pb2.MnistRequest.FromString, } response_serializers = { ('tensorflow.serving.MnistService', 'Classify'): mnist_inference_pb2.MnistResponse.SerializeToString, } method_implementations = { ('tensorflow.serving.MnistService', 'Classify'): face_utilities.unary_unary_inline(servicer.Classify), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BioMetadataService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import ga4gh.bio_metadata_service_pb2 import ga4gh.bio_metadata_service_pb2 import ga4gh.bio_metadata_service_pb2 import ga4gh.bio_metadata_service_pb2 import ga4gh.bio_metadata_service_pb2 import ga4gh.bio_metadata_pb2 import ga4gh.bio_metadata_service_pb2 import ga4gh.bio_metadata_pb2 request_deserializers = { ('ga4gh.BioMetadataService', 'GetBioSample'): ga4gh.bio_metadata_service_pb2.GetBioSampleRequest.FromString, ('ga4gh.BioMetadataService', 'GetIndividual'): ga4gh.bio_metadata_service_pb2.GetIndividualRequest.FromString, ('ga4gh.BioMetadataService', 'SearchBioSamples'): ga4gh.bio_metadata_service_pb2.SearchBioSamplesRequest.FromString, ('ga4gh.BioMetadataService', 'SearchIndividuals'): ga4gh.bio_metadata_service_pb2.SearchIndividualsRequest.FromString, } response_serializers = { ('ga4gh.BioMetadataService', 'GetBioSample'): ga4gh.bio_metadata_pb2.BioSample.SerializeToString, ('ga4gh.BioMetadataService', 'GetIndividual'): ga4gh.bio_metadata_pb2.Individual.SerializeToString, ('ga4gh.BioMetadataService', 'SearchBioSamples'): ga4gh.bio_metadata_service_pb2.SearchBioSamplesResponse.SerializeToString, ('ga4gh.BioMetadataService', 'SearchIndividuals'): ga4gh.bio_metadata_service_pb2.SearchIndividualsResponse.SerializeToString, } method_implementations = { ('ga4gh.BioMetadataService', 'GetBioSample'): face_utilities.unary_unary_inline(servicer.GetBioSample), ('ga4gh.BioMetadataService', 'GetIndividual'): face_utilities.unary_unary_inline(servicer.GetIndividual), ('ga4gh.BioMetadataService', 'SearchBioSamples'): face_utilities.unary_unary_inline(servicer.SearchBioSamples), ('ga4gh.BioMetadataService', 'SearchIndividuals'): face_utilities.unary_unary_inline(servicer.SearchIndividuals), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Dgraph_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import graphresponse_pb2 request_deserializers = { ('graph.Dgraph', 'Query'): graphresponse_pb2.Request.FromString, } response_serializers = { ('graph.Dgraph', 'Query'): graphresponse_pb2.Response.SerializeToString, } method_implementations = { ('graph.Dgraph', 'Query'): face_utilities.unary_unary_inline(servicer.Query), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_AtomicBroadcast_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('atomicbroadcast.AtomicBroadcast', 'Broadcast'): BroadcastMessage.FromString, ('atomicbroadcast.AtomicBroadcast', 'Deliver'): DeliverUpdate.FromString, } response_serializers = { ('atomicbroadcast.AtomicBroadcast', 'Broadcast'): BroadcastResponse.SerializeToString, ('atomicbroadcast.AtomicBroadcast', 'Deliver'): DeliverResponse.SerializeToString, } method_implementations = { ('atomicbroadcast.AtomicBroadcast', 'Broadcast'): face_utilities.stream_stream_inline(servicer.Broadcast), ('atomicbroadcast.AtomicBroadcast', 'Deliver'): face_utilities.stream_stream_inline(servicer.Deliver), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_FirestoreAdmin_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('google.firestore.admin.v1beta1.FirestoreAdmin', 'CreateIndex'): CreateIndexRequest.FromString, ('google.firestore.admin.v1beta1.FirestoreAdmin', 'DeleteIndex'): DeleteIndexRequest.FromString, ('google.firestore.admin.v1beta1.FirestoreAdmin', 'GetIndex'): GetIndexRequest.FromString, ('google.firestore.admin.v1beta1.FirestoreAdmin', 'ListIndexes'): ListIndexesRequest.FromString, } response_serializers = { ('google.firestore.admin.v1beta1.FirestoreAdmin', 'CreateIndex'): google_dot_longrunning_dot_operations__pb2.Operation.SerializeToString, ('google.firestore.admin.v1beta1.FirestoreAdmin', 'DeleteIndex'): google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, ('google.firestore.admin.v1beta1.FirestoreAdmin', 'GetIndex'): google_dot_cloud_dot_firestore__v1beta1_dot_proto_dot_admin_dot_index__pb2.Index.SerializeToString, ('google.firestore.admin.v1beta1.FirestoreAdmin', 'ListIndexes'): ListIndexesResponse.SerializeToString, } method_implementations = { ('google.firestore.admin.v1beta1.FirestoreAdmin', 'CreateIndex'): face_utilities.unary_unary_inline(servicer.CreateIndex), ('google.firestore.admin.v1beta1.FirestoreAdmin', 'DeleteIndex'): face_utilities.unary_unary_inline(servicer.DeleteIndex), ('google.firestore.admin.v1beta1.FirestoreAdmin', 'GetIndex'): face_utilities.unary_unary_inline(servicer.GetIndex), ('google.firestore.admin.v1beta1.FirestoreAdmin', 'ListIndexes'): face_utilities.unary_unary_inline(servicer.ListIndexes), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_RouteGuide_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 import route_guide_pb2 request_deserializers = { ('routeguide.RouteGuide', 'GetFeature'): route_guide_pb2.Point.FromString, ('routeguide.RouteGuide', 'ListFeatures'): route_guide_pb2.Rectangle.FromString, ('routeguide.RouteGuide', 'RecordRoute'): route_guide_pb2.Point.FromString, ('routeguide.RouteGuide', 'RouteChat'): route_guide_pb2.RouteNote.FromString, } response_serializers = { ('routeguide.RouteGuide', 'GetFeature'): route_guide_pb2.Feature.SerializeToString, ('routeguide.RouteGuide', 'ListFeatures'): route_guide_pb2.Feature.SerializeToString, ('routeguide.RouteGuide', 'RecordRoute'): route_guide_pb2.RouteSummary.SerializeToString, ('routeguide.RouteGuide', 'RouteChat'): route_guide_pb2.RouteNote.SerializeToString, } method_implementations = { ('routeguide.RouteGuide', 'GetFeature'): face_utilities.unary_unary_inline(servicer.GetFeature), ('routeguide.RouteGuide', 'ListFeatures'): face_utilities.unary_stream_inline(servicer.ListFeatures), ('routeguide.RouteGuide', 'RecordRoute'): face_utilities.stream_unary_inline(servicer.RecordRoute), ('routeguide.RouteGuide', 'RouteChat'): face_utilities.stream_stream_inline(servicer.RouteChat), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_OwstoniService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('btwan.OwstoniService', 'GetMetadataInfo'): InfoHash.FromString, ('btwan.OwstoniService', 'Index'): MetadataInfo.FromString, ('btwan.OwstoniService', 'Recv'): Void.FromString, ('btwan.OwstoniService', 'Search'): SearchReq.FromString, ('btwan.OwstoniService', 'Send'): Event.FromString, ('btwan.OwstoniService', 'SendInfoHash'): InfoHash.FromString, } response_serializers = { ('btwan.OwstoniService', 'GetMetadataInfo'): MetadataInfo.SerializeToString, ('btwan.OwstoniService', 'Index'): Void.SerializeToString, ('btwan.OwstoniService', 'Recv'): Event.SerializeToString, ('btwan.OwstoniService', 'Search'): SearchResp.SerializeToString, ('btwan.OwstoniService', 'Send'): Void.SerializeToString, ('btwan.OwstoniService', 'SendInfoHash'): Void.SerializeToString, } method_implementations = { ('btwan.OwstoniService', 'GetMetadataInfo'): face_utilities.unary_unary_inline(servicer.GetMetadataInfo), ('btwan.OwstoniService', 'Index'): face_utilities.unary_unary_inline(servicer.Index), ('btwan.OwstoniService', 'Recv'): face_utilities.unary_stream_inline(servicer.Recv), ('btwan.OwstoniService', 'Search'): face_utilities.unary_unary_inline(servicer.Search), ('btwan.OwstoniService', 'Send'): face_utilities.stream_unary_inline(servicer.Send), ('btwan.OwstoniService', 'SendInfoHash'): face_utilities.unary_unary_inline(servicer.SendInfoHash), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Authentication_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import auth_pb2 import auth_pb2 request_deserializers = { ('auth.Authentication', 'Login'): auth_pb2.LoginRequest.FromString, } response_serializers = { ('auth.Authentication', 'Login'): auth_pb2.LoginResponse.SerializeToString, } method_implementations = { ('auth.Authentication', 'Login'): face_utilities.unary_unary_inline(servicer.Login), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_SkynetService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('dg.model.SkynetService', 'VideoRecognize'): SkynetRequest.FromString, } response_serializers = { ('dg.model.SkynetService', 'VideoRecognize'): SkynetResponse.SerializeToString, } method_implementations = { ('dg.model.SkynetService', 'VideoRecognize'): face_utilities.unary_unary_inline(servicer.VideoRecognize), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Admin_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('protos.Admin', 'GetModuleLogLevel'): LogLevelRequest.FromString, ('protos.Admin', 'GetStatus'): google_dot_protobuf_dot_empty__pb2.Empty.FromString, ('protos.Admin', 'SetModuleLogLevel'): LogLevelRequest.FromString, ('protos.Admin', 'StartServer'): google_dot_protobuf_dot_empty__pb2.Empty.FromString, ('protos.Admin', 'StopServer'): google_dot_protobuf_dot_empty__pb2.Empty.FromString, } response_serializers = { ('protos.Admin', 'GetModuleLogLevel'): LogLevelResponse.SerializeToString, ('protos.Admin', 'GetStatus'): ServerStatus.SerializeToString, ('protos.Admin', 'SetModuleLogLevel'): LogLevelResponse.SerializeToString, ('protos.Admin', 'StartServer'): ServerStatus.SerializeToString, ('protos.Admin', 'StopServer'): ServerStatus.SerializeToString, } method_implementations = { ('protos.Admin', 'GetModuleLogLevel'): face_utilities.unary_unary_inline(servicer.GetModuleLogLevel), ('protos.Admin', 'GetStatus'): face_utilities.unary_unary_inline(servicer.GetStatus), ('protos.Admin', 'SetModuleLogLevel'): face_utilities.unary_unary_inline(servicer.SetModuleLogLevel), ('protos.Admin', 'StartServer'): face_utilities.unary_unary_inline(servicer.StartServer), ('protos.Admin', 'StopServer'): face_utilities.unary_unary_inline(servicer.StopServer), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_ReadService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import ga4gh.read_service_pb2 import ga4gh.read_service_pb2 import ga4gh.read_service_pb2 import ga4gh.reads_pb2 import ga4gh.read_service_pb2 import ga4gh.read_service_pb2 request_deserializers = { ("ga4gh.ReadService", "GetReadGroupSet"): ga4gh.read_service_pb2.GetReadGroupSetRequest.FromString, ("ga4gh.ReadService", "SearchReadGroupSets"): ga4gh.read_service_pb2.SearchReadGroupSetsRequest.FromString, ("ga4gh.ReadService", "SearchReads"): ga4gh.read_service_pb2.SearchReadsRequest.FromString, } response_serializers = { ("ga4gh.ReadService", "GetReadGroupSet"): ga4gh.reads_pb2.ReadGroupSet.SerializeToString, ( "ga4gh.ReadService", "SearchReadGroupSets", ): ga4gh.read_service_pb2.SearchReadGroupSetsResponse.SerializeToString, ("ga4gh.ReadService", "SearchReads"): ga4gh.read_service_pb2.SearchReadsResponse.SerializeToString, } method_implementations = { ("ga4gh.ReadService", "GetReadGroupSet"): face_utilities.unary_unary_inline(servicer.GetReadGroupSet), ("ga4gh.ReadService", "SearchReadGroupSets"): face_utilities.unary_unary_inline(servicer.SearchReadGroupSets), ("ga4gh.ReadService", "SearchReads"): face_utilities.unary_unary_inline(servicer.SearchReads), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout, ) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Bigtable_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('google.bigtable.v2.Bigtable', 'CheckAndMutateRow'): CheckAndMutateRowRequest.FromString, ('google.bigtable.v2.Bigtable', 'MutateRow'): MutateRowRequest.FromString, ('google.bigtable.v2.Bigtable', 'MutateRows'): MutateRowsRequest.FromString, ('google.bigtable.v2.Bigtable', 'ReadModifyWriteRow'): ReadModifyWriteRowRequest.FromString, ('google.bigtable.v2.Bigtable', 'ReadRows'): ReadRowsRequest.FromString, ('google.bigtable.v2.Bigtable', 'SampleRowKeys'): SampleRowKeysRequest.FromString, } response_serializers = { ('google.bigtable.v2.Bigtable', 'CheckAndMutateRow'): CheckAndMutateRowResponse.SerializeToString, ('google.bigtable.v2.Bigtable', 'MutateRow'): MutateRowResponse.SerializeToString, ('google.bigtable.v2.Bigtable', 'MutateRows'): MutateRowsResponse.SerializeToString, ('google.bigtable.v2.Bigtable', 'ReadModifyWriteRow'): ReadModifyWriteRowResponse.SerializeToString, ('google.bigtable.v2.Bigtable', 'ReadRows'): ReadRowsResponse.SerializeToString, ('google.bigtable.v2.Bigtable', 'SampleRowKeys'): SampleRowKeysResponse.SerializeToString, } method_implementations = { ('google.bigtable.v2.Bigtable', 'CheckAndMutateRow'): face_utilities.unary_unary_inline(servicer.CheckAndMutateRow), ('google.bigtable.v2.Bigtable', 'MutateRow'): face_utilities.unary_unary_inline(servicer.MutateRow), ('google.bigtable.v2.Bigtable', 'MutateRows'): face_utilities.unary_stream_inline(servicer.MutateRows), ('google.bigtable.v2.Bigtable', 'ReadModifyWriteRow'): face_utilities.unary_unary_inline(servicer.ReadModifyWriteRow), ('google.bigtable.v2.Bigtable', 'ReadRows'): face_utilities.unary_stream_inline(servicer.ReadRows), ('google.bigtable.v2.Bigtable', 'SampleRowKeys'): face_utilities.unary_stream_inline(servicer.SampleRowKeys), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Health_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('grpc_python_example.Health', 'Check'): HealthCheckRequest.FromString, } response_serializers = { ('grpc_python_example.Health', 'Check'): HealthCheckResponse.SerializeToString, } method_implementations = { ('grpc_python_example.Health', 'Check'): face_utilities.unary_unary_inline(servicer.Check), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_KV_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('kv.KV', 'Get'): GetRequest.FromString, ('kv.KV', 'Set'): SetRequest.FromString, } response_serializers = { ('kv.KV', 'Get'): GetResponse.SerializeToString, ('kv.KV', 'Set'): SetResponse.SerializeToString, } method_implementations = { ('kv.KV', 'Get'): face_utilities.unary_unary_inline(servicer.Get), ('kv.KV', 'Set'): face_utilities.unary_unary_inline(servicer.Set), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Processor_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('processor.Processor', 'ProcessPost'): ProcessPostRequest.FromString, } response_serializers = { ('processor.Processor', 'ProcessPost'): ProcessPostReply.SerializeToString, } method_implementations = { ('processor.Processor', 'ProcessPost'): face_utilities.unary_unary_inline(servicer.ProcessPost), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_ScootDaemon_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('protocol.ScootDaemon', 'CheckoutSnapshot'): CheckoutSnapshotRequest.FromString, ('protocol.ScootDaemon', 'CreateSnapshot'): CreateSnapshotRequest.FromString, ('protocol.ScootDaemon', 'Echo'): EchoRequest.FromString, ('protocol.ScootDaemon', 'Poll'): PollRequest.FromString, ('protocol.ScootDaemon', 'Run'): RunRequest.FromString, ('protocol.ScootDaemon', 'StopDaemon'): EmptyStruct.FromString, } response_serializers = { ('protocol.ScootDaemon', 'CheckoutSnapshot'): CheckoutSnapshotReply.SerializeToString, ('protocol.ScootDaemon', 'CreateSnapshot'): CreateSnapshotReply.SerializeToString, ('protocol.ScootDaemon', 'Echo'): EchoReply.SerializeToString, ('protocol.ScootDaemon', 'Poll'): PollReply.SerializeToString, ('protocol.ScootDaemon', 'Run'): RunReply.SerializeToString, ('protocol.ScootDaemon', 'StopDaemon'): EmptyStruct.SerializeToString, } method_implementations = { ('protocol.ScootDaemon', 'CheckoutSnapshot'): face_utilities.unary_unary_inline(servicer.CheckoutSnapshot), ('protocol.ScootDaemon', 'CreateSnapshot'): face_utilities.unary_unary_inline(servicer.CreateSnapshot), ('protocol.ScootDaemon', 'Echo'): face_utilities.unary_unary_inline(servicer.Echo), ('protocol.ScootDaemon', 'Poll'): face_utilities.unary_unary_inline(servicer.Poll), ('protocol.ScootDaemon', 'Run'): face_utilities.unary_unary_inline(servicer.Run), ('protocol.ScootDaemon', 'StopDaemon'): face_utilities.unary_unary_inline(servicer.StopDaemon), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def instantiate( self, methods, method_implementations, multi_method_implementation): serialization_behaviors = _serialization_behaviors_from_test_methods( methods) # TODO(nathaniel): Add a "groups" attribute to _digest.TestServiceDigest. service = next(iter(methods))[0] # TODO(nathaniel): Add a "cardinalities_by_group" attribute to # _digest.TestServiceDigest. cardinalities = { method: method_object.cardinality() for (group, method), method_object in methods.iteritems()} server_options = implementations.server_options( request_deserializers=serialization_behaviors.request_deserializers, response_serializers=serialization_behaviors.response_serializers, thread_pool_size=test_constants.POOL_SIZE) server = implementations.server( method_implementations, options=server_options) server_credentials = implementations.ssl_server_credentials( [(resources.private_key(), resources.certificate_chain(),),]) port = server.add_secure_port('[::]:0', server_credentials) server.start() channel_credentials = implementations.ssl_channel_credentials( resources.test_root_certificates(), None, None) channel = test_utilities.not_really_secure_channel( 'localhost', port, channel_credentials, _SERVER_HOST_OVERRIDE) stub_options = implementations.stub_options( request_serializers=serialization_behaviors.request_serializers, response_deserializers=serialization_behaviors.response_deserializers, thread_pool_size=test_constants.POOL_SIZE) generic_stub = implementations.generic_stub(channel, options=stub_options) dynamic_stub = implementations.dynamic_stub( channel, service, cardinalities, options=stub_options) return generic_stub, {service: dynamic_stub}, server
def beta_create_SequenceAnnotationService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import ga4gh.sequence_annotation_service_pb2 import ga4gh.sequence_annotation_service_pb2 import ga4gh.sequence_annotation_service_pb2 import ga4gh.sequence_annotations_pb2 import ga4gh.sequence_annotation_service_pb2 import ga4gh.sequence_annotation_service_pb2 import ga4gh.sequence_annotation_service_pb2 import ga4gh.sequence_annotations_pb2 request_deserializers = { ('ga4gh.SequenceAnnotationService', 'GetFeature'): ga4gh.sequence_annotation_service_pb2.GetFeatureRequest.FromString, ('ga4gh.SequenceAnnotationService', 'GetFeatureSet'): ga4gh.sequence_annotation_service_pb2.GetFeatureSetRequest.FromString, ('ga4gh.SequenceAnnotationService', 'SearchFeatureSets'): ga4gh.sequence_annotation_service_pb2.SearchFeatureSetsRequest.FromString, ('ga4gh.SequenceAnnotationService', 'SearchFeatures'): ga4gh.sequence_annotation_service_pb2.SearchFeaturesRequest.FromString, } response_serializers = { ('ga4gh.SequenceAnnotationService', 'GetFeature'): ga4gh.sequence_annotations_pb2.Feature.SerializeToString, ('ga4gh.SequenceAnnotationService', 'GetFeatureSet'): ga4gh.sequence_annotations_pb2.FeatureSet.SerializeToString, ('ga4gh.SequenceAnnotationService', 'SearchFeatureSets'): ga4gh.sequence_annotation_service_pb2.SearchFeatureSetsResponse.SerializeToString, ('ga4gh.SequenceAnnotationService', 'SearchFeatures'): ga4gh.sequence_annotation_service_pb2.SearchFeaturesResponse.SerializeToString, } method_implementations = { ('ga4gh.SequenceAnnotationService', 'GetFeature'): face_utilities.unary_unary_inline(servicer.GetFeature), ('ga4gh.SequenceAnnotationService', 'GetFeatureSet'): face_utilities.unary_unary_inline(servicer.GetFeatureSet), ('ga4gh.SequenceAnnotationService', 'SearchFeatureSets'): face_utilities.unary_unary_inline(servicer.SearchFeatureSets), ('ga4gh.SequenceAnnotationService', 'SearchFeatures'): face_utilities.unary_unary_inline(servicer.SearchFeatures), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Platform_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('org.dash.platform.dapi.v0.Platform', 'applyStateTransition'): ApplyStateTransitionRequest.FromString, ('org.dash.platform.dapi.v0.Platform', 'getDataContract'): GetDataContractRequest.FromString, ('org.dash.platform.dapi.v0.Platform', 'getDocuments'): GetDocumentsRequest.FromString, ('org.dash.platform.dapi.v0.Platform', 'getIdentity'): GetIdentityRequest.FromString, ('org.dash.platform.dapi.v0.Platform', 'getIdentityByFirstPublicKey'): GetIdentityByFirstPublicKeyRequest.FromString, ('org.dash.platform.dapi.v0.Platform', 'getIdentityIdByFirstPublicKey'): GetIdentityIdByFirstPublicKeyRequest.FromString, } response_serializers = { ('org.dash.platform.dapi.v0.Platform', 'applyStateTransition'): ApplyStateTransitionResponse.SerializeToString, ('org.dash.platform.dapi.v0.Platform', 'getDataContract'): GetDataContractResponse.SerializeToString, ('org.dash.platform.dapi.v0.Platform', 'getDocuments'): GetDocumentsResponse.SerializeToString, ('org.dash.platform.dapi.v0.Platform', 'getIdentity'): GetIdentityResponse.SerializeToString, ('org.dash.platform.dapi.v0.Platform', 'getIdentityByFirstPublicKey'): GetIdentityByFirstPublicKeyResponse.SerializeToString, ('org.dash.platform.dapi.v0.Platform', 'getIdentityIdByFirstPublicKey'): GetIdentityIdByFirstPublicKeyResponse.SerializeToString, } method_implementations = { ('org.dash.platform.dapi.v0.Platform', 'applyStateTransition'): face_utilities.unary_unary_inline(servicer.applyStateTransition), ('org.dash.platform.dapi.v0.Platform', 'getDataContract'): face_utilities.unary_unary_inline(servicer.getDataContract), ('org.dash.platform.dapi.v0.Platform', 'getDocuments'): face_utilities.unary_unary_inline(servicer.getDocuments), ('org.dash.platform.dapi.v0.Platform', 'getIdentity'): face_utilities.unary_unary_inline(servicer.getIdentity), ('org.dash.platform.dapi.v0.Platform', 'getIdentityByFirstPublicKey'): face_utilities.unary_unary_inline(servicer.getIdentityByFirstPublicKey), ('org.dash.platform.dapi.v0.Platform', 'getIdentityIdByFirstPublicKey'): face_utilities.unary_unary_inline(servicer.getIdentityIdByFirstPublicKey), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_FrameSpaceService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import proto.framespace.framespace_service_pb2 import proto.framespace.framespace_service_pb2 import proto.framespace.framespace_service_pb2 import proto.framespace.framespace_service_pb2 import proto.framespace.framespace_service_pb2 import proto.framespace.framespace_service_pb2 import proto.framespace.framespace_service_pb2 import proto.framespace.framespace_service_pb2 import proto.framespace.framespace_service_pb2 import proto.framespace.framespace_pb2 request_deserializers = { ('framespace.FrameSpaceService', 'SearchAxes'): proto.framespace.framespace_service_pb2.SearchAxesRequest.FromString, ('framespace.FrameSpaceService', 'SearchDataFrames'): proto.framespace.framespace_service_pb2.SearchDataFramesRequest.FromString, ('framespace.FrameSpaceService', 'SearchKeySpaces'): proto.framespace.framespace_service_pb2.SearchKeySpacesRequest.FromString, ('framespace.FrameSpaceService', 'SearchUnits'): proto.framespace.framespace_service_pb2.SearchUnitsRequest.FromString, ('framespace.FrameSpaceService', 'SliceDataFrame'): proto.framespace.framespace_service_pb2.SliceDataFrameRequest.FromString, } response_serializers = { ('framespace.FrameSpaceService', 'SearchAxes'): proto.framespace.framespace_service_pb2.SearchAxesResponse.SerializeToString, ('framespace.FrameSpaceService', 'SearchDataFrames'): proto.framespace.framespace_service_pb2.SearchDataFramesResponse.SerializeToString, ('framespace.FrameSpaceService', 'SearchKeySpaces'): proto.framespace.framespace_service_pb2.SearchKeySpacesResponse.SerializeToString, ('framespace.FrameSpaceService', 'SearchUnits'): proto.framespace.framespace_service_pb2.SearchUnitsResponse.SerializeToString, ('framespace.FrameSpaceService', 'SliceDataFrame'): proto.framespace.framespace_pb2.DataFrame.SerializeToString, } method_implementations = { ('framespace.FrameSpaceService', 'SearchAxes'): face_utilities.unary_unary_inline(servicer.SearchAxes), ('framespace.FrameSpaceService', 'SearchDataFrames'): face_utilities.unary_unary_inline(servicer.SearchDataFrames), ('framespace.FrameSpaceService', 'SearchKeySpaces'): face_utilities.unary_unary_inline(servicer.SearchKeySpaces), ('framespace.FrameSpaceService', 'SearchUnits'): face_utilities.unary_unary_inline(servicer.SearchUnits), ('framespace.FrameSpaceService', 'SliceDataFrame'): face_utilities.unary_unary_inline(servicer.SliceDataFrame), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BigtableService_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import google.protobuf.empty_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_service_messages_pb2 import gcloud.bigtable._generated.bigtable_data_pb2 request_deserializers = { ('google.bigtable.v1.BigtableService', 'CheckAndMutateRow'): gcloud.bigtable._generated.bigtable_service_messages_pb2.CheckAndMutateRowRequest.FromString, ('google.bigtable.v1.BigtableService', 'MutateRow'): gcloud.bigtable._generated.bigtable_service_messages_pb2.MutateRowRequest.FromString, ('google.bigtable.v1.BigtableService', 'ReadModifyWriteRow'): gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadModifyWriteRowRequest.FromString, ('google.bigtable.v1.BigtableService', 'ReadRows'): gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadRowsRequest.FromString, ('google.bigtable.v1.BigtableService', 'SampleRowKeys'): gcloud.bigtable._generated.bigtable_service_messages_pb2.SampleRowKeysRequest.FromString, } response_serializers = { ('google.bigtable.v1.BigtableService', 'CheckAndMutateRow'): gcloud.bigtable._generated.bigtable_service_messages_pb2.CheckAndMutateRowResponse.SerializeToString, ('google.bigtable.v1.BigtableService', 'MutateRow'): google.protobuf.empty_pb2.Empty.SerializeToString, ('google.bigtable.v1.BigtableService', 'ReadModifyWriteRow'): gcloud.bigtable._generated.bigtable_data_pb2.Row.SerializeToString, ('google.bigtable.v1.BigtableService', 'ReadRows'): gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadRowsResponse.SerializeToString, ('google.bigtable.v1.BigtableService', 'SampleRowKeys'): gcloud.bigtable._generated.bigtable_service_messages_pb2.SampleRowKeysResponse.SerializeToString, } method_implementations = { ('google.bigtable.v1.BigtableService', 'CheckAndMutateRow'): face_utilities.unary_unary_inline(servicer.CheckAndMutateRow), ('google.bigtable.v1.BigtableService', 'MutateRow'): face_utilities.unary_unary_inline(servicer.MutateRow), ('google.bigtable.v1.BigtableService', 'ReadModifyWriteRow'): face_utilities.unary_unary_inline(servicer.ReadModifyWriteRow), ('google.bigtable.v1.BigtableService', 'ReadRows'): face_utilities.unary_stream_inline(servicer.ReadRows), ('google.bigtable.v1.BigtableService', 'SampleRowKeys'): face_utilities.unary_stream_inline(servicer.SampleRowKeys), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_BigtableTableAdmin_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('google.bigtable.admin.v2.BigtableTableAdmin', 'CreateTable'): CreateTableRequest.FromString, ('google.bigtable.admin.v2.BigtableTableAdmin', 'DeleteTable'): DeleteTableRequest.FromString, ('google.bigtable.admin.v2.BigtableTableAdmin', 'DropRowRange'): DropRowRangeRequest.FromString, ('google.bigtable.admin.v2.BigtableTableAdmin', 'GetTable'): GetTableRequest.FromString, ('google.bigtable.admin.v2.BigtableTableAdmin', 'ListTables'): ListTablesRequest.FromString, ('google.bigtable.admin.v2.BigtableTableAdmin', 'ModifyColumnFamilies'): ModifyColumnFamiliesRequest.FromString, } response_serializers = { ('google.bigtable.admin.v2.BigtableTableAdmin', 'CreateTable'): google_dot_bigtable_dot_admin_dot_v2_dot_table__pb2.Table.SerializeToString, ('google.bigtable.admin.v2.BigtableTableAdmin', 'DeleteTable'): google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, ('google.bigtable.admin.v2.BigtableTableAdmin', 'DropRowRange'): google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, ('google.bigtable.admin.v2.BigtableTableAdmin', 'GetTable'): google_dot_bigtable_dot_admin_dot_v2_dot_table__pb2.Table.SerializeToString, ('google.bigtable.admin.v2.BigtableTableAdmin', 'ListTables'): ListTablesResponse.SerializeToString, ('google.bigtable.admin.v2.BigtableTableAdmin', 'ModifyColumnFamilies'): google_dot_bigtable_dot_admin_dot_v2_dot_table__pb2.Table.SerializeToString, } method_implementations = { ('google.bigtable.admin.v2.BigtableTableAdmin', 'CreateTable'): face_utilities.unary_unary_inline(servicer.CreateTable), ('google.bigtable.admin.v2.BigtableTableAdmin', 'DeleteTable'): face_utilities.unary_unary_inline(servicer.DeleteTable), ('google.bigtable.admin.v2.BigtableTableAdmin', 'DropRowRange'): face_utilities.unary_unary_inline(servicer.DropRowRange), ('google.bigtable.admin.v2.BigtableTableAdmin', 'GetTable'): face_utilities.unary_unary_inline(servicer.GetTable), ('google.bigtable.admin.v2.BigtableTableAdmin', 'ListTables'): face_utilities.unary_unary_inline(servicer.ListTables), ('google.bigtable.admin.v2.BigtableTableAdmin', 'ModifyColumnFamilies'): face_utilities.unary_unary_inline(servicer.ModifyColumnFamilies), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_JobUpload_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): request_deserializers = { ('JobUpload', 'param'): parameters.FromString, ('JobUpload', 'upload'): line.FromString, } response_serializers = { ('JobUpload', 'param'): Status.SerializeToString, ('JobUpload', 'upload'): Status.SerializeToString, } method_implementations = { ('JobUpload', 'param'): face_utilities.unary_unary_inline(servicer.param), ('JobUpload', 'upload'): face_utilities.stream_unary_inline(servicer.upload), } server_options = beta_implementations.server_options( request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_Store_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('store.Store', 'AddItem'): AddItemRequest.FromString, ('store.Store', 'AddItems'): AddItemRequest.FromString, ('store.Store', 'ListInventory'): Empty.FromString, ('store.Store', 'QueryQuantities'): QueryItemRequest.FromString, ('store.Store', 'QueryQuantity'): QueryItemRequest.FromString, ('store.Store', 'RemoveItem'): RemoveItemRequest.FromString, ('store.Store', 'RemoveItems'): RemoveItemRequest.FromString, } response_serializers = { ('store.Store', 'AddItem'): Empty.SerializeToString, ('store.Store', 'AddItems'): Empty.SerializeToString, ('store.Store', 'ListInventory'): QuantityResponse.SerializeToString, ('store.Store', 'QueryQuantities'): QuantityResponse.SerializeToString, ('store.Store', 'QueryQuantity'): QuantityResponse.SerializeToString, ('store.Store', 'RemoveItem'): RemoveItemResponse.SerializeToString, ('store.Store', 'RemoveItems'): RemoveItemResponse.SerializeToString, } method_implementations = { ('store.Store', 'AddItem'): face_utilities.unary_unary_inline(servicer.AddItem), ('store.Store', 'AddItems'): face_utilities.stream_unary_inline(servicer.AddItems), ('store.Store', 'ListInventory'): face_utilities.unary_stream_inline(servicer.ListInventory), ('store.Store', 'QueryQuantities'): face_utilities.stream_stream_inline(servicer.QueryQuantities), ('store.Store', 'QueryQuantity'): face_utilities.unary_unary_inline(servicer.QueryQuantity), ('store.Store', 'RemoveItem'): face_utilities.unary_unary_inline(servicer.RemoveItem), ('store.Store', 'RemoveItems'): face_utilities.stream_unary_inline(servicer.RemoveItems), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def beta_create_LoggingServiceV2_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): """The Beta API is deprecated for 0.15.0 and later. It is recommended to use the GA API (classes and functions in this file not marked beta) for all further purposes. This function was generated only to ease transition from grpcio<0.15.0 to grpcio>=0.15.0""" request_deserializers = { ('google.logging.v2.LoggingServiceV2', 'DeleteLog'): DeleteLogRequest.FromString, ('google.logging.v2.LoggingServiceV2', 'ListLogEntries'): ListLogEntriesRequest.FromString, ('google.logging.v2.LoggingServiceV2', 'ListLogs'): ListLogsRequest.FromString, ('google.logging.v2.LoggingServiceV2', 'ListMonitoredResourceDescriptors'): ListMonitoredResourceDescriptorsRequest.FromString, ('google.logging.v2.LoggingServiceV2', 'WriteLogEntries'): WriteLogEntriesRequest.FromString, } response_serializers = { ('google.logging.v2.LoggingServiceV2', 'DeleteLog'): google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString, ('google.logging.v2.LoggingServiceV2', 'ListLogEntries'): ListLogEntriesResponse.SerializeToString, ('google.logging.v2.LoggingServiceV2', 'ListLogs'): ListLogsResponse.SerializeToString, ('google.logging.v2.LoggingServiceV2', 'ListMonitoredResourceDescriptors'): ListMonitoredResourceDescriptorsResponse.SerializeToString, ('google.logging.v2.LoggingServiceV2', 'WriteLogEntries'): WriteLogEntriesResponse.SerializeToString, } method_implementations = { ('google.logging.v2.LoggingServiceV2', 'DeleteLog'): face_utilities.unary_unary_inline(servicer.DeleteLog), ('google.logging.v2.LoggingServiceV2', 'ListLogEntries'): face_utilities.unary_unary_inline(servicer.ListLogEntries), ('google.logging.v2.LoggingServiceV2', 'ListLogs'): face_utilities.unary_unary_inline(servicer.ListLogs), ('google.logging.v2.LoggingServiceV2', 'ListMonitoredResourceDescriptors'): face_utilities.unary_unary_inline(servicer.ListMonitoredResourceDescriptors), ('google.logging.v2.LoggingServiceV2', 'WriteLogEntries'): face_utilities.unary_unary_inline(servicer.WriteLogEntries), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)
def setUp(self): self._servicer = _Servicer() self._method_implementations = { (_GROUP, _UNARY_UNARY): utilities.unary_unary_inline(self._servicer.unary_unary), (_GROUP, _UNARY_STREAM): utilities.unary_stream_inline(self._servicer.unary_stream), (_GROUP, _STREAM_UNARY): utilities.stream_unary_inline(self._servicer.stream_unary), (_GROUP, _STREAM_STREAM): utilities.stream_stream_inline(self._servicer.stream_stream), } self._cardinalities = { _UNARY_UNARY: cardinality.Cardinality.UNARY_UNARY, _UNARY_STREAM: cardinality.Cardinality.UNARY_STREAM, _STREAM_UNARY: cardinality.Cardinality.STREAM_UNARY, _STREAM_STREAM: cardinality.Cardinality.STREAM_STREAM, } self._server_options = implementations.server_options( thread_pool_size=test_constants.POOL_SIZE) self._server_credentials = implementations.ssl_server_credentials( [(resources.private_key(), resources.certificate_chain(),),]) self._client_credentials = implementations.ssl_client_credentials( resources.test_root_certificates(), None, None) self._stub_options = implementations.stub_options( thread_pool_size=test_constants.POOL_SIZE)
def beta_create_VM_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None): import paxos_pb2 import paxos_pb2 import paxos_pb2 import paxos_pb2 import paxos_pb2 import paxos_pb2 import paxos_pb2 import paxos_pb2 import paxos_pb2 import paxos_pb2 request_deserializers = { ('paxos.VM', 'handle_accept'): paxos_pb2.AcceptRequest.FromString, ('paxos.VM', 'handle_learn'): paxos_pb2.LearnRequest.FromString, ('paxos.VM', 'handle_prepare'): paxos_pb2.PrepareRequest.FromString, ('paxos.VM', 'handle_promise'): paxos_pb2.PromiseRequest.FromString, ('paxos.VM', 'handle_refuse'): paxos_pb2.RefuseRequest.FromString, } response_serializers = { ('paxos.VM', 'handle_accept'): paxos_pb2.OKResponse.SerializeToString, ('paxos.VM', 'handle_learn'): paxos_pb2.OKResponse.SerializeToString, ('paxos.VM', 'handle_prepare'): paxos_pb2.OKResponse.SerializeToString, ('paxos.VM', 'handle_promise'): paxos_pb2.OKResponse.SerializeToString, ('paxos.VM', 'handle_refuse'): paxos_pb2.OKResponse.SerializeToString, } method_implementations = { ('paxos.VM', 'handle_accept'): face_utilities.unary_unary_inline(servicer.handle_accept), ('paxos.VM', 'handle_learn'): face_utilities.unary_unary_inline(servicer.handle_learn), ('paxos.VM', 'handle_prepare'): face_utilities.unary_unary_inline(servicer.handle_prepare), ('paxos.VM', 'handle_promise'): face_utilities.unary_unary_inline(servicer.handle_promise), ('paxos.VM', 'handle_refuse'): face_utilities.unary_unary_inline(servicer.handle_refuse), } server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout) return beta_implementations.server(method_implementations, options=server_options)