Python assemble_service Examples

Example #1

def early_adopter_create_RouteGuide_server(servicer, port, root_certificates,
                                           key_chain_pairs):
    method_implementations = {
        "GetFeature": utilities.unary_unary_inline(servicer.GetFeature),
        "ListFeatures": utilities.unary_stream_inline(servicer.ListFeatures),
        "RecordRoute": utilities.stream_unary_inline(servicer.RecordRoute),
        "RouteChat": utilities.stream_stream_inline(servicer.RouteChat),
    }
    import route_guide_pb2
    import route_guide_pb2
    import route_guide_pb2
    import route_guide_pb2
    request_deserializers = {
        "GetFeature": route_guide_pb2.Point.FromString,
        "ListFeatures": route_guide_pb2.Rectangle.FromString,
        "RecordRoute": route_guide_pb2.Point.FromString,
        "RouteChat": route_guide_pb2.RouteNote.FromString,
    }
    response_serializers = {
        "GetFeature": lambda x: x.SerializeToString(),
        "ListFeatures": lambda x: x.SerializeToString(),
        "RecordRoute": lambda x: x.SerializeToString(),
        "RouteChat": lambda x: x.SerializeToString(),
    }
    link = fore.activated_fore_link(port, request_deserializers,
                                    response_serializers, root_certificates,
                                    key_chain_pairs)
    return implementations.assemble_service(method_implementations, link)

Example #2

File: route_guide_pb2.py Project: Cixelyn/grpc-common

def early_adopter_create_RouteGuide_server(servicer, port, root_certificates, key_chain_pairs):
  method_implementations = {
    "GetFeature": utilities.unary_unary_inline(servicer.GetFeature),
    "ListFeatures": utilities.unary_stream_inline(servicer.ListFeatures),
    "RecordRoute": utilities.stream_unary_inline(servicer.RecordRoute),
    "RouteChat": utilities.stream_stream_inline(servicer.RouteChat),
  }
  import route_guide_pb2
  import route_guide_pb2
  import route_guide_pb2
  import route_guide_pb2
  request_deserializers = {
    "GetFeature": route_guide_pb2.Point.FromString,
    "ListFeatures": route_guide_pb2.Rectangle.FromString,
    "RecordRoute": route_guide_pb2.Point.FromString,
    "RouteChat": route_guide_pb2.RouteNote.FromString,
  }
  response_serializers = {
    "GetFeature": lambda x: x.SerializeToString(),
    "ListFeatures": lambda x: x.SerializeToString(),
    "RecordRoute": lambda x: x.SerializeToString(),
    "RouteChat": lambda x: x.SerializeToString(),
  }
  link = fore.activated_fore_link(port, request_deserializers, response_serializers, root_certificates, key_chain_pairs)
  return implementations.assemble_service(method_implementations, link)

Example #3

File: implementations.py Project: mindis/grpc

  def _start(self):
    with self._lock:
      if self._server is None:
        self._fore_link = _fore.activated_fore_link(
            self._port, self._breakdown.request_deserializers,
            self._breakdown.response_serializers, None, self._key_chain_pairs)

        self._server = _assembly_implementations.assemble_service(
            self._breakdown.implementations, self._fore_link)
        self._server.start()
      else:
        raise ValueError('Server currently running!')

Example #4

File: implementations_test.py Project: zhangf911/grpc

    def testStreamUnary(self):
        stream_length = 127
        pipe = PipeLink()
        service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
        dynamic_stub = implementations.assemble_dynamic_inline_stub(
            _IMPLEMENTATIONS, pipe)

        with service, dynamic_stub:
            response_future = dynamic_stub.Sum. async (
                (math_pb2.Num(num=index) for index in range(stream_length)),
                _TIMEOUT)
            self.assertEqual((stream_length * (stream_length - 1)) / 2,
                             response_future.result().num)

Example #5

File: implementations_test.py Project: zhangf911/grpc

    def testStreamUnary(self):
        stream_length = 13
        pipe = PipeLink()
        service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
        face_stub = implementations.assemble_face_stub(pipe)

        with service, face_stub:
            sync_async = face_stub.stream_unary_sync_async(SUM)
            response_future = sync_async. async (
                (math_pb2.Num(num=index) for index in range(stream_length)),
                _TIMEOUT)
            self.assertEqual((stream_length * (stream_length - 1)) / 2,
                             response_future.result().num)

Example #6

File: implementations_test.py Project: zhangf911/grpc

    def testUnaryStream(self):
        stream_length = 29
        pipe = PipeLink()
        service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
        face_stub = implementations.assemble_face_stub(pipe)

        with service, face_stub:
            responses = list(
                face_stub.inline_value_in_stream_out(
                    FIB, math_pb2.FibArgs(limit=stream_length), _TIMEOUT))
            numbers = [response.num for response in responses]
            for early, middle, later in zip(numbers, numbers[1:], numbers[2:]):
                self.assertEqual(early + middle, later)

Example #7

File: helloworld_pb2.py Project: digideskio/grpc-common

def early_adopter_create_Greeter_server(servicer, port, root_certificates, key_chain_pairs):
  method_implementations = {
    "SayHello": utilities.unary_unary_inline(servicer.SayHello),
  }
  import helloworld_pb2
  request_deserializers = {
    "SayHello": helloworld_pb2.HelloRequest.FromString,
  }
  response_serializers = {
    "SayHello": lambda x: x.SerializeToString(),
  }
  link = fore.activated_fore_link(port, request_deserializers, response_serializers, root_certificates, key_chain_pairs)
  return implementations.assemble_service(method_implementations, link)

Example #8

File: implementations_test.py Project: mindis/grpc

  def testUnaryStream(self):
    stream_length = 29
    pipe = PipeLink()
    service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
    face_stub = implementations.assemble_face_stub(pipe)

    with service, face_stub:
      responses = list(
          face_stub.inline_value_in_stream_out(
              FIB, math_pb2.FibArgs(limit=stream_length), _TIMEOUT))
      numbers = [response.num for response in responses]
      for early, middle, later in zip(numbers, numbers[1:], numbers[2:]):
        self.assertEqual(early + middle, later)

Example #9

File: implementations.py Project: nmittler/grpc

    def _start(self):
        with self._lock:
            if self._server is None:
                self._fore_link = _fore.activated_fore_link(
                    self._port, self._breakdown.request_deserializers,
                    self._breakdown.response_serializers, None,
                    self._key_chain_pairs)

                self._server = _assembly_implementations.assemble_service(
                    self._breakdown.implementations, self._fore_link)
                self._server.start()
            else:
                raise ValueError('Server currently running!')

Example #10

File: implementations_test.py Project: zhangf911/grpc

    def testUnaryStream(self):
        stream_length = 43
        pipe = PipeLink()
        service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
        dynamic_stub = implementations.assemble_dynamic_inline_stub(
            _IMPLEMENTATIONS, pipe)

        with service, dynamic_stub:
            response_iterator = dynamic_stub.Fib(
                math_pb2.FibArgs(limit=stream_length), _TIMEOUT)
            numbers = tuple(response.num for response in response_iterator)
            for early, middle, later in zip(numbers, numbers[:1], numbers[:2]):
                self.assertEqual(early + middle, later)
            self.assertEqual(stream_length, len(numbers))

Example #11

File: implementations_test.py Project: mindis/grpc

  def testStreamUnary(self):
    stream_length = 13
    pipe = PipeLink()
    service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
    face_stub = implementations.assemble_face_stub(pipe)

    with service, face_stub:
      sync_async = face_stub.stream_unary_sync_async(SUM)
      response_future = sync_async.async(
          (math_pb2.Num(num=index) for index in range(stream_length)),
          _TIMEOUT)
      self.assertEqual(
          (stream_length * (stream_length - 1)) / 2,
          response_future.result().num)

Example #12

File: implementations_test.py Project: mindis/grpc

  def testUnaryStream(self):
    stream_length = 43
    pipe = PipeLink()
    service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
    dynamic_stub = implementations.assemble_dynamic_inline_stub(
        _IMPLEMENTATIONS, pipe)

    with service, dynamic_stub:
      response_iterator = dynamic_stub.Fib(
          math_pb2.FibArgs(limit=stream_length), _TIMEOUT)
      numbers = tuple(response.num for response in response_iterator)
      for early, middle, later in zip(numbers, numbers[:1], numbers[:2]):
        self.assertEqual(early + middle, later)
      self.assertEqual(stream_length, len(numbers))

Example #13

File: implementations_test.py Project: mindis/grpc

  def testStreamUnary(self):
    stream_length = 127
    pipe = PipeLink()
    service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
    dynamic_stub = implementations.assemble_dynamic_inline_stub(
        _IMPLEMENTATIONS, pipe)

    with service, dynamic_stub:
      response_future = dynamic_stub.Sum.async(
          (math_pb2.Num(num=index) for index in range(stream_length)),
          _TIMEOUT)
      self.assertEqual(
          (stream_length * (stream_length - 1)) / 2,
          response_future.result().num)

Example #14

def early_adopter_create_Greeter_server(servicer, port, root_certificates,
                                        key_chain_pairs):
    method_implementations = {
        "SayHello": utilities.unary_unary_inline(servicer.SayHello),
    }
    import helloworld_pb2
    request_deserializers = {
        "SayHello": helloworld_pb2.HelloRequest.FromString,
    }
    response_serializers = {
        "SayHello": lambda x: x.SerializeToString(),
    }
    link = fore.activated_fore_link(port, request_deserializers,
                                    response_serializers, root_certificates,
                                    key_chain_pairs)
    return implementations.assemble_service(method_implementations, link)

Example #15

File: implementations_test.py Project: mindis/grpc

  def testUnaryUnary(self):
    divisor = 59
    dividend = 973
    expected_quotient = dividend / divisor
    expected_remainder = dividend % divisor
    pipe = PipeLink()
    service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
    dynamic_stub = implementations.assemble_dynamic_inline_stub(
        _IMPLEMENTATIONS, pipe)

    service.start()
    with dynamic_stub:
      response = dynamic_stub.Div(
          math_pb2.DivArgs(divisor=divisor, dividend=dividend), _TIMEOUT)
      self.assertEqual(expected_quotient, response.quotient)
      self.assertEqual(expected_remainder, response.remainder)
    service.stop()

Example #16

File: implementations_test.py Project: zhangf911/grpc

    def testUnaryUnary(self):
        divisor = 59
        dividend = 973
        expected_quotient = dividend / divisor
        expected_remainder = dividend % divisor
        pipe = PipeLink()
        service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
        dynamic_stub = implementations.assemble_dynamic_inline_stub(
            _IMPLEMENTATIONS, pipe)

        service.start()
        with dynamic_stub:
            response = dynamic_stub.Div(
                math_pb2.DivArgs(divisor=divisor, dividend=dividend), _TIMEOUT)
            self.assertEqual(expected_quotient, response.quotient)
            self.assertEqual(expected_remainder, response.remainder)
        service.stop()

Example #17

File: implementations_test.py Project: zhangf911/grpc

    def testUnaryUnary(self):
        divisor = 7
        dividend = 13
        expected_quotient = 1
        expected_remainder = 6
        pipe = PipeLink()
        service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
        face_stub = implementations.assemble_face_stub(pipe)

        service.start()
        try:
            with face_stub:
                response = face_stub.blocking_value_in_value_out(
                    DIV, math_pb2.DivArgs(divisor=divisor, dividend=dividend),
                    _TIMEOUT)
                self.assertEqual(expected_quotient, response.quotient)
                self.assertEqual(expected_remainder, response.remainder)
        finally:
            service.stop()

Example #18

File: implementations_test.py Project: mindis/grpc

  def testUnaryUnary(self):
    divisor = 7
    dividend = 13
    expected_quotient = 1
    expected_remainder = 6
    pipe = PipeLink()
    service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
    face_stub = implementations.assemble_face_stub(pipe)

    service.start()
    try:
      with face_stub:
        response = face_stub.blocking_value_in_value_out(
            DIV, math_pb2.DivArgs(divisor=divisor, dividend=dividend),
            _TIMEOUT)
        self.assertEqual(expected_quotient, response.quotient)
        self.assertEqual(expected_remainder, response.remainder)
    finally:
      service.stop()

Example #19

File: implementations_test.py Project: zhangf911/grpc

    def testStreamStream(self):
        stream_length = 17
        divisor_offset = 7
        dividend_offset = 17
        pipe = PipeLink()
        service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
        face_stub = implementations.assemble_face_stub(pipe)

        with service, face_stub:
            response_iterator = face_stub.inline_stream_in_stream_out(
                DIV_MANY, (math_pb2.DivArgs(divisor=divisor_offset + index,
                                            dividend=dividend_offset + index)
                           for index in range(stream_length)), _TIMEOUT)
            for index, response in enumerate(response_iterator):
                self.assertEqual(
                    (dividend_offset + index) / (divisor_offset + index),
                    response.quotient)
                self.assertEqual(
                    (dividend_offset + index) % (divisor_offset + index),
                    response.remainder)
            self.assertEqual(stream_length, index + 1)

Example #20

File: implementations_test.py Project: zhangf911/grpc

    def testStreamStream(self):
        stream_length = 179
        divisor_offset = 71
        dividend_offset = 1763
        pipe = PipeLink()
        service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
        dynamic_stub = implementations.assemble_dynamic_inline_stub(
            _IMPLEMENTATIONS, pipe)

        with service, dynamic_stub:
            response_iterator = dynamic_stub.DivMany(
                (math_pb2.DivArgs(divisor=divisor_offset + index,
                                  dividend=dividend_offset + index)
                 for index in range(stream_length)), _TIMEOUT)
            for index, response in enumerate(response_iterator):
                self.assertEqual(
                    (dividend_offset + index) / (divisor_offset + index),
                    response.quotient)
                self.assertEqual(
                    (dividend_offset + index) % (divisor_offset + index),
                    response.remainder)
            self.assertEqual(stream_length, index + 1)

Example #21

File: implementations_test.py Project: mindis/grpc

  def testStreamStream(self):
    stream_length = 179
    divisor_offset = 71
    dividend_offset = 1763
    pipe = PipeLink()
    service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
    dynamic_stub = implementations.assemble_dynamic_inline_stub(
        _IMPLEMENTATIONS, pipe)

    with service, dynamic_stub:
      response_iterator = dynamic_stub.DivMany(
          (math_pb2.DivArgs(
               divisor=divisor_offset + index,
               dividend=dividend_offset + index)
           for index in range(stream_length)),
          _TIMEOUT)
      for index, response in enumerate(response_iterator):
        self.assertEqual(
            (dividend_offset + index) / (divisor_offset + index),
            response.quotient)
        self.assertEqual(
            (dividend_offset + index) % (divisor_offset + index),
            response.remainder)
      self.assertEqual(stream_length, index + 1)

Example #22

File: implementations_test.py Project: mindis/grpc

  def testStreamStream(self):
    stream_length = 17
    divisor_offset = 7
    dividend_offset = 17
    pipe = PipeLink()
    service = implementations.assemble_service(_IMPLEMENTATIONS, pipe)
    face_stub = implementations.assemble_face_stub(pipe)

    with service, face_stub:
      response_iterator = face_stub.inline_stream_in_stream_out(
          DIV_MANY,
          (math_pb2.DivArgs(
               divisor=divisor_offset + index,
               dividend=dividend_offset + index)
           for index in range(stream_length)),
          _TIMEOUT)
      for index, response in enumerate(response_iterator):
        self.assertEqual(
            (dividend_offset + index) / (divisor_offset + index),
            response.quotient)
        self.assertEqual(
            (dividend_offset + index) % (divisor_offset + index),
            response.remainder)
      self.assertEqual(stream_length, index + 1)