コード例 #1
0
ファイル: ipython_pb2.py プロジェクト: Nullification/zeppelin
  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)
コード例 #2
0
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)
コード例 #3
0
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)
コード例 #4
0
    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)
コード例 #5
0
  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
コード例 #6
0
    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)
コード例 #7
0
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)
コード例 #8
0
  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)
コード例 #9
0
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)
コード例 #10
0
  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)
コード例 #11
0
  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)
コード例 #12
0
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)
コード例 #13
0
ファイル: mysqlctl_pb2.py プロジェクト: mdhheydari/vitess
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)
コード例 #14
0
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)
コード例 #15
0
ファイル: debate_pb2.py プロジェクト: slz250/classes
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)
コード例 #16
0
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)
コード例 #17
0
    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)
コード例 #18
0
  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)
コード例 #19
0
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)
コード例 #20
0
ファイル: logging_metrics_pb2.py プロジェクト: norama/mapapp
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)
コード例 #21
0
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)
コード例 #22
0
  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)
コード例 #23
0
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)
コード例 #24
0
ファイル: bfkv_pb2.py プロジェクト: testmana2/bfpy
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)
コード例 #25
0
ファイル: uber_pb2.py プロジェクト: tmc/grpc-uber
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_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)
コード例 #27
0
ファイル: users_pb2.py プロジェクト: soboto/common-framework
  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)
コード例 #28
0
    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)
コード例 #29
0
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)
コード例 #30
0
ファイル: vtctlservice_pb2.py プロジェクト: zhaoyta/vitess
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)
コード例 #31
0
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)
コード例 #32
0
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)
コード例 #33
0
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)
コード例 #34
0
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)
コード例 #35
0
  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)
コード例 #36
0
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)
コード例 #37
0
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)
コード例 #38
0
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)
コード例 #39
0
ファイル: skynet_pb2.py プロジェクト: chunxiusun/DG
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)
コード例 #40
0
ファイル: admin_pb2.py プロジェクト: 2016Nishi/fabric
  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)
コード例 #41
0
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)
コード例 #42
0
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)
コード例 #43
0
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)
コード例 #44
0
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)
コード例 #45
0
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)
コード例 #46
0
ファイル: admin_pb2.py プロジェクト: a20351766/mchain
  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)
コード例 #47
0
ファイル: daemon_pb2.py プロジェクト: dbentley/scoot
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)
コード例 #48
0
  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
コード例 #49
0
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)
コード例 #50
0
  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)
コード例 #51
0
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)
コード例 #52
0
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)
コード例 #53
0
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)
コード例 #54
0
ファイル: jobupload_pb2.py プロジェクト: sherlockwu/cloud
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)
コード例 #55
0
  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)
コード例 #56
0
  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)
コード例 #57
0
  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)
コード例 #58
0
ファイル: paxos_pb2.py プロジェクト: victordomene/ram-paxos
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)