def beta_create_PeopleSearch_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 = {
('people.PeopleSearch', 'FindByFirstCharacter'): Name.FromString,
('people.PeopleSearch', 'FindByFullName'): Name.FromString,
}
response_serializers = {
('people.PeopleSearch', 'FindByFirstCharacter'):
PeopleInfo.SerializeToString,
('people.PeopleSearch', 'FindByFullName'):
PeopleInfo.SerializeToString,
}
method_implementations = {
('people.PeopleSearch', 'FindByFirstCharacter'):
face_utilities.unary_stream_inline(servicer.FindByFirstCharacter),
('people.PeopleSearch', 'FindByFullName'):
face_utilities.unary_unary_inline(servicer.FindByFullName),
}
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_SmsRouter_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
import sms_router_pb2
import sms_router_pb2
request_deserializers = {
('Proto.SmsRouter', 'GetRouter'):
sms_router_pb2.GetRouterReq.FromString,
}
response_serializers = {
('Proto.SmsRouter', 'GetRouter'):
sms_router_pb2.GetRouterRsp.SerializeToString,
}
method_implementations = {
('Proto.SmsRouter', 'GetRouter'):
face_utilities.unary_unary_inline(servicer.GetRouter),
}
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):
request_deserializers = {
('tensorflow.serving.PredictionService', 'Predict'):
predict__pb2.PredictRequest.FromString,
}
response_serializers = {
('tensorflow.serving.PredictionService', 'Predict'):
predict__pb2.PredictResponse.SerializeToString,
}
method_implementations = {
('tensorflow.serving.PredictionService', 'Predict'):
face_utilities.unary_unary_inline(servicer.Predict),
}
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_Profile_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 = {
('etg.profile.Profile', 'UpdateProfile'):
UpdateProfileRequest.FromString,
}
response_serializers = {
('etg.profile.Profile', 'UpdateProfile'):
UpdateProfileResponse.SerializeToString,
}
method_implementations = {
('etg.profile.Profile', 'UpdateProfile'):
face_utilities.unary_unary_inline(servicer.UpdateProfile),
}
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_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_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_JRService_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
request_deserializers = {
('JRService.JRService', 'GetSongs'): SingerId.FromString,
('JRService.JRService', 'ListSongs'): SingerId.FromString,
}
response_serializers = {
('JRService.JRService', 'GetSongs'): Song.SerializeToString,
('JRService.JRService', 'ListSongs'): SongList.SerializeToString,
}
method_implementations = {
('JRService.JRService', 'GetSongs'):
face_utilities.unary_stream_inline(servicer.GetSongs),
('JRService.JRService', 'ListSongs'):
face_utilities.unary_unary_inline(servicer.ListSongs),
}
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_Greeter_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 = {
('Greeter', 'SayHello'): HelloRequest.FromString,
('Greeter', 'SayHelloBidiStream'): HelloRequest.FromString,
('Greeter', 'SayHelloStreamUnary'): HelloRequest.FromString,
('Greeter', 'SayHelloUnaryStream'): HelloRequest.FromString,
}
response_serializers = {
('Greeter', 'SayHello'): HelloReply.SerializeToString,
('Greeter', 'SayHelloBidiStream'): HelloReply.SerializeToString,
('Greeter', 'SayHelloStreamUnary'): HelloReply.SerializeToString,
('Greeter', 'SayHelloUnaryStream'): HelloReply.SerializeToString,
}
method_implementations = {
('Greeter', 'SayHello'): face_utilities.unary_unary_inline(servicer.SayHello),
('Greeter', 'SayHelloBidiStream'): face_utilities.stream_stream_inline(servicer.SayHelloBidiStream),
('Greeter', 'SayHelloStreamUnary'): face_utilities.stream_unary_inline(servicer.SayHelloStreamUnary),
('Greeter', 'SayHelloUnaryStream'): face_utilities.unary_stream_inline(servicer.SayHelloUnaryStream),
}
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_JobsService_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
import jobs_pb2
request_deserializers = {
('jobs.JobsService', 'GetCount'): jobs_pb2.Void.FromString,
('jobs.JobsService', 'GetJobs'): jobs_pb2.SearchOptions.FromString,
}
response_serializers = {
('jobs.JobsService', 'GetCount'): jobs_pb2.Int.SerializeToString,
('jobs.JobsService', 'GetJobs'): jobs_pb2.JobInfo.SerializeToString,
}
method_implementations = {
('jobs.JobsService', 'GetCount'):
face_utilities.unary_unary_inline(servicer.GetCount),
('jobs.JobsService', 'GetJobs'):
face_utilities.unary_stream_inline(servicer.GetJobs),
}
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_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_Endorser_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.Endorser', 'ProcessProposal'):
hfc_dot_protos_dot_peer_dot_proposal__pb2.SignedProposal.
FromString,
}
response_serializers = {
('protos.Endorser', 'ProcessProposal'):
hfc_dot_protos_dot_peer_dot_proposal__response__pb2.
ProposalResponse.SerializeToString,
}
method_implementations = {
('protos.Endorser', 'ProcessProposal'):
face_utilities.unary_unary_inline(servicer.ProcessProposal),
}
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 _create_server(self, config):
if config.server_type == control_pb2.SYNC_SERVER:
servicer = benchmark_server.BenchmarkServer()
server = services_pb2.beta_create_BenchmarkService_server(servicer)
elif config.server_type == control_pb2.ASYNC_GENERIC_SERVER:
resp_size = config.payload_config.bytebuf_params.resp_size
servicer = benchmark_server.GenericBenchmarkServer(resp_size)
method_implementations = {
('grpc.testing.BenchmarkService', 'StreamingCall'):
utilities.stream_stream_inline(servicer.StreamingCall),
('grpc.testing.BenchmarkService', 'UnaryCall'):
utilities.unary_unary_inline(servicer.UnaryCall),
}
server = implementations.server(method_implementations)
else:
raise Exception('Unsupported server type {}'.format(
config.server_type))
if config.HasField('security_params'): # Use SSL
server_creds = implementations.ssl_server_credentials([
(resources.private_key(), resources.certificate_chain())
])
port = server.add_secure_port('[::]:{}'.format(config.port),
server_creds)
else:
port = server.add_insecure_port('[::]:{}'.format(config.port))
return (server, port)
def beta_create_Discovery_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
request_deserializers = {
('discovery.Discovery', 'Describe'): Void.FromString,
}
response_serializers = {
('discovery.Discovery', 'Describe'):
DescribeResponse.SerializeToString,
}
method_implementations = {
('discovery.Discovery', 'Describe'):
face_utilities.unary_unary_inline(servicer.Describe),
}
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', '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 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(), None, None)
self._stub_options = implementations.stub_options(
thread_pool_size=test_constants.POOL_SIZE)
def beta_create_wxAuth_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 = {
('wxAuth', 'CallAutoEditor'): AuthRequest.FromString,
('wxAuth', 'checkClient2Version'): AuthRequest.FromString,
('wxAuth', 'checkClientVersion'): AuthRequest.FromString,
('wxAuth', 'checkServerVersion'): AuthRequest.FromString,
('wxAuth', 'checkWxBot'): AuthRequest.FromString,
('wxAuth', 'getWxBotKey'): AuthRequest.FromString,
('wxAuth', 'runAEScript'): AuthRequest.FromString,
('wxAuth', 'wxRPCAuth'): AuthRequest.FromString,
}
response_serializers = {
('wxAuth', 'CallAutoEditor'): AuthReply.SerializeToString,
('wxAuth', 'checkClient2Version'): AuthReply.SerializeToString,
('wxAuth', 'checkClientVersion'): AuthReply.SerializeToString,
('wxAuth', 'checkServerVersion'): AuthReply.SerializeToString,
('wxAuth', 'checkWxBot'): AuthReply.SerializeToString,
('wxAuth', 'getWxBotKey'): ByteReplay.SerializeToString,
('wxAuth', 'runAEScript'): AuthReply.SerializeToString,
('wxAuth', 'wxRPCAuth'): AuthReply.SerializeToString,
}
method_implementations = {
('wxAuth', 'CallAutoEditor'):
face_utilities.unary_unary_inline(servicer.CallAutoEditor),
('wxAuth', 'checkClient2Version'):
face_utilities.unary_unary_inline(servicer.checkClient2Version),
('wxAuth', 'checkClientVersion'):
face_utilities.unary_unary_inline(servicer.checkClientVersion),
('wxAuth', 'checkServerVersion'):
face_utilities.unary_unary_inline(servicer.checkServerVersion),
('wxAuth', 'checkWxBot'):
face_utilities.unary_unary_inline(servicer.checkWxBot),
('wxAuth', 'getWxBotKey'):
face_utilities.unary_unary_inline(servicer.getWxBotKey),
('wxAuth', 'runAEScript'):
face_utilities.unary_unary_inline(servicer.runAEScript),
('wxAuth', 'wxRPCAuth'):
face_utilities.unary_unary_inline(servicer.wxRPCAuth),
}
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_BfCtaService_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
request_deserializers = {
('bfcta.BfCtaService', 'ConnectPush'):
bfgateway__pb2.BfConnectPushReq.FromString,
('bfcta.BfCtaService', 'DisconnectPush'):
bfgateway__pb2.BfVoid.FromString,
('bfcta.BfCtaService', 'Ping'): bfgateway__pb2.BfPingData.FromString,
('bfcta.BfCtaService', 'Start'): bfgateway__pb2.BfVoid.FromString,
('bfcta.BfCtaService', 'Stop'): bfgateway__pb2.BfVoid.FromString,
}
response_serializers = {
('bfcta.BfCtaService', 'ConnectPush'):
google_dot_protobuf_dot_any__pb2.Any.SerializeToString,
('bfcta.BfCtaService', 'DisconnectPush'):
bfgateway__pb2.BfVoid.SerializeToString,
('bfcta.BfCtaService', 'Ping'):
bfgateway__pb2.BfPingData.SerializeToString,
('bfcta.BfCtaService', 'Start'):
bfgateway__pb2.BfVoid.SerializeToString,
('bfcta.BfCtaService', 'Stop'):
bfgateway__pb2.BfVoid.SerializeToString,
}
method_implementations = {
('bfcta.BfCtaService', 'ConnectPush'):
face_utilities.unary_stream_inline(servicer.ConnectPush),
('bfcta.BfCtaService', 'DisconnectPush'):
face_utilities.unary_unary_inline(servicer.DisconnectPush),
('bfcta.BfCtaService', 'Ping'):
face_utilities.unary_unary_inline(servicer.Ping),
('bfcta.BfCtaService', 'Start'):
face_utilities.unary_unary_inline(servicer.Start),
('bfcta.BfCtaService', '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_CorkTypeService_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 = {
('CorkTypeService', 'EventReact'):
EventReactRequest.FromString,
('CorkTypeService', 'Kill'):
KillRequest.FromString,
('CorkTypeService', 'StageExecute'):
StageExecuteRequest.FromString,
('CorkTypeService', 'VolumesToMountGet'):
VolumesToMountGetRequest.FromString,
}
response_serializers = {
('CorkTypeService', 'EventReact'): Response.SerializeToString,
('CorkTypeService', 'Kill'): Response.SerializeToString,
('CorkTypeService', 'StageExecute'):
ExecuteEvent.SerializeToString,
('CorkTypeService', 'VolumesToMountGet'):
Response.SerializeToString,
}
method_implementations = {
('CorkTypeService', 'EventReact'):
face_utilities.unary_unary_inline(servicer.EventReact),
('CorkTypeService', 'Kill'):
face_utilities.unary_unary_inline(servicer.Kill),
('CorkTypeService', 'StageExecute'):
face_utilities.unary_stream_inline(servicer.StageExecute),
('CorkTypeService', 'VolumesToMountGet'):
face_utilities.unary_unary_inline(servicer.VolumesToMountGet),
}
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_TaskManager_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 = {
('gogrpcspec.TaskManager', 'AddTask'): Task.FromString,
('gogrpcspec.TaskManager', 'AddTasks'): Task.FromString,
('gogrpcspec.TaskManager', 'ChangeToDone'): Task.FromString,
('gogrpcspec.TaskManager', 'GetSummary'): Employee.FromString,
('gogrpcspec.TaskManager', 'GetTasks'): Employee.FromString,
}
response_serializers = {
('gogrpcspec.TaskManager', 'AddTask'):
SpecificSummary.SerializeToString,
('gogrpcspec.TaskManager', 'AddTasks'): Summary.SerializeToString,
('gogrpcspec.TaskManager', 'ChangeToDone'): Task.SerializeToString,
('gogrpcspec.TaskManager', 'GetSummary'):
SpecificSummary.SerializeToString,
('gogrpcspec.TaskManager', 'GetTasks'): Task.SerializeToString,
}
method_implementations = {
('gogrpcspec.TaskManager', 'AddTask'):
face_utilities.unary_unary_inline(servicer.AddTask),
('gogrpcspec.TaskManager', 'AddTasks'):
face_utilities.stream_unary_inline(servicer.AddTasks),
('gogrpcspec.TaskManager', 'ChangeToDone'):
face_utilities.stream_stream_inline(servicer.ChangeToDone),
('gogrpcspec.TaskManager', 'GetSummary'):
face_utilities.unary_unary_inline(servicer.GetSummary),
('gogrpcspec.TaskManager', 'GetTasks'):
face_utilities.unary_stream_inline(servicer.GetTasks),
}
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_DeviceConfig_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 = {
('device_config.DeviceConfig', 'EditConfig'):
EditConfigRequest.FromString,
('device_config.DeviceConfig', 'GetConfig'):
GetConfigRequest.FromString,
('device_config.DeviceConfig', 'Hello'): HelloRequest.FromString,
('device_config.DeviceConfig', 'Lock'): LockRequest.FromString,
}
response_serializers = {
('device_config.DeviceConfig', 'EditConfig'):
EditConfigResponse.SerializeToString,
('device_config.DeviceConfig', 'GetConfig'):
GetConfigResponse.SerializeToString,
('device_config.DeviceConfig', 'Hello'):
HelloResponse.SerializeToString,
('device_config.DeviceConfig', 'Lock'):
LockResponse.SerializeToString,
}
method_implementations = {
('device_config.DeviceConfig', 'EditConfig'):
face_utilities.unary_unary_inline(servicer.EditConfig),
('device_config.DeviceConfig', 'GetConfig'):
face_utilities.unary_unary_inline(servicer.GetConfig),
('device_config.DeviceConfig', 'Hello'):
face_utilities.unary_unary_inline(servicer.Hello),
('device_config.DeviceConfig', 'Lock'):
face_utilities.unary_unary_inline(servicer.Lock),
}
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_Synchronization_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 = {
('Synchronization', 'BlockFrom'): Message.FromString,
('Synchronization', 'BlockTo'): Block.FromString,
('Synchronization', 'ExchangeBlock'): Block.FromString,
('Synchronization', 'TransactionFrom'): Message.FromString,
('Synchronization', 'TransactionTo'): Transaction.FromString,
}
response_serializers = {
('Synchronization', 'BlockFrom'): Block.SerializeToString,
('Synchronization', 'BlockTo'): Message.SerializeToString,
('Synchronization', 'ExchangeBlock'): Block.SerializeToString,
('Synchronization', 'TransactionFrom'):
Transaction.SerializeToString,
('Synchronization', 'TransactionTo'): Message.SerializeToString,
}
method_implementations = {
('Synchronization', 'BlockFrom'):
face_utilities.unary_unary_inline(servicer.BlockFrom),
('Synchronization', 'BlockTo'):
face_utilities.unary_unary_inline(servicer.BlockTo),
('Synchronization', 'ExchangeBlock'):
face_utilities.unary_unary_inline(servicer.ExchangeBlock),
('Synchronization', 'TransactionFrom'):
face_utilities.unary_unary_inline(servicer.TransactionFrom),
('Synchronization', 'TransactionTo'):
face_utilities.unary_unary_inline(servicer.TransactionTo),
}
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_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_LoggingServiceV2_server(servicer,
pool=None,
pool_size=None,
default_timeout=None,
maximum_timeout=None):
request_deserializers = {
('google.logging.v2.LoggingServiceV2', 'DeleteLog'):
DeleteLogRequest.FromString,
('google.logging.v2.LoggingServiceV2', 'ListLogEntries'):
ListLogEntriesRequest.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', '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', '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 beta_create_DataProvider_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 = {
('augServer.DataProvider', 'Control'): ControlSignal.FromString,
('augServer.DataProvider', 'GetStatus'): Empty.FromString,
('augServer.DataProvider', 'GetTestData'): Empty.FromString,
('augServer.DataProvider', 'GetTrainData'): Empty.FromString,
}
response_serializers = {
('augServer.DataProvider', 'Control'):
ControlResponse.SerializeToString,
('augServer.DataProvider', 'GetStatus'):
Status.SerializeToString,
('augServer.DataProvider', 'GetTestData'):
BatchData.SerializeToString,
('augServer.DataProvider', 'GetTrainData'):
BatchData.SerializeToString,
}
method_implementations = {
('augServer.DataProvider', 'Control'):
face_utilities.unary_unary_inline(servicer.Control),
('augServer.DataProvider', 'GetStatus'):
face_utilities.unary_unary_inline(servicer.GetStatus),
('augServer.DataProvider', 'GetTestData'):
face_utilities.unary_unary_inline(servicer.GetTestData),
('augServer.DataProvider', 'GetTrainData'):
face_utilities.unary_unary_inline(servicer.GetTrainData),
}
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_Bridge_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 = {
('Bridge', 'GetX'): NullMessage.FromString,
('Bridge', 'Init'): NullMessage.FromString,
('Bridge', 'Run'): Item.FromString,
('Bridge', 'SetX'): X.FromString,
('Bridge', 'StoreMetric'): Item.FromString,
}
response_serializers = {
('Bridge', 'GetX'): X.SerializeToString,
('Bridge', 'Init'): NullMessage.SerializeToString,
('Bridge', 'Run'): Item.SerializeToString,
('Bridge', 'SetX'): NullMessage.SerializeToString,
('Bridge', 'StoreMetric'): NullMessage.SerializeToString,
}
method_implementations = {
('Bridge', 'GetX'):
face_utilities.unary_unary_inline(servicer.GetX),
('Bridge', 'Init'):
face_utilities.unary_unary_inline(servicer.Init),
('Bridge', 'Run'):
face_utilities.stream_stream_inline(servicer.Run),
('Bridge', 'SetX'):
face_utilities.unary_unary_inline(servicer.SetX),
('Bridge', 'StoreMetric'):
face_utilities.stream_unary_inline(servicer.StoreMetric),
}
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_Projects_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):
request_deserializers = {
('monorail.Projects', 'ListProjects'): ListProjectsRequest.FromString,
('monorail.Projects', 'PatchProjectConfiguredLabels'): PatchProjectConfiguredLabelsRequest.FromString,
('monorail.Projects', 'UpdateProjectConfiguredLabels'): UpdateProjectConfiguredLabelsRequest.FromString,
}
response_serializers = {
('monorail.Projects', 'ListProjects'): ListProjectsResponse.SerializeToString,
('monorail.Projects', 'PatchProjectConfiguredLabels'): Labels.SerializeToString,
('monorail.Projects', 'UpdateProjectConfiguredLabels'): Labels.SerializeToString,
}
method_implementations = {
('monorail.Projects', 'ListProjects'): face_utilities.unary_unary_inline(servicer.ListProjects),
('monorail.Projects', 'PatchProjectConfiguredLabels'): face_utilities.unary_unary_inline(servicer.PatchProjectConfiguredLabels),
('monorail.Projects', 'UpdateProjectConfiguredLabels'): face_utilities.unary_unary_inline(servicer.UpdateProjectConfiguredLabels),
}
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)
