Example #1
0
 async def create_tuple(self, elements):
   elem = anonymous_tuple.to_elements(anonymous_tuple.from_container(elements))
   proto_elem = []
   type_elem = []
   for k, v in elem:
     py_typecheck.check_type(v, RemoteValue)
     proto_elem.append(
         executor_pb2.CreateTupleRequest.Element(
             name=(k if k else None), value_ref=v.value_ref))
     type_elem.append((k, v.type_signature) if k else v.type_signature)
   result_type = computation_types.NamedTupleType(type_elem)
   response = self._stub.CreateTuple(
       executor_pb2.CreateTupleRequest(element=proto_elem))
   py_typecheck.check_type(response, executor_pb2.CreateTupleResponse)
   return RemoteValue(response.value_ref, result_type, self)
Example #2
0
 async def create_tuple(self, elements):
   constructed_anon_tuple = anonymous_tuple.from_container(elements)
   proto_elem = []
   type_elem = []
   for k, v in anonymous_tuple.iter_elements(constructed_anon_tuple):
     py_typecheck.check_type(v, RemoteValue)
     proto_elem.append(
         executor_pb2.CreateTupleRequest.Element(
             name=(k if k else None), value_ref=v.value_ref))
     type_elem.append((k, v.type_signature) if k else v.type_signature)
   result_type = computation_types.NamedTupleType(type_elem)
   request = executor_pb2.CreateTupleRequest(element=proto_elem)
   if self._bidi_stream is None:
     response = _request(self._stub.CreateTuple, request)
   else:
     response = (await self._bidi_stream.send_request(
         executor_pb2.ExecuteRequest(create_tuple=request))).create_tuple
   py_typecheck.check_type(response, executor_pb2.CreateTupleResponse)
   return RemoteValue(response.value_ref, result_type, self)
    def test_executor_service_create_and_select_from_tuple(self):
        env = TestEnv(eager_executor.EagerExecutor())

        value_proto, _ = executor_service_utils.serialize_value(10, tf.int32)
        response = env.stub.CreateValue(
            executor_pb2.CreateValueRequest(value=value_proto))
        self.assertIsInstance(response, executor_pb2.CreateValueResponse)
        ten_ref = response.value_ref
        self.assertEqual(env.get_value(ten_ref.id), 10)

        value_proto, _ = executor_service_utils.serialize_value(20, tf.int32)
        response = env.stub.CreateValue(
            executor_pb2.CreateValueRequest(value=value_proto))
        self.assertIsInstance(response, executor_pb2.CreateValueResponse)
        twenty_ref = response.value_ref
        self.assertEqual(env.get_value(twenty_ref.id), 20)

        response = env.stub.CreateTuple(
            executor_pb2.CreateTupleRequest(element=[
                executor_pb2.CreateTupleRequest.Element(name='a',
                                                        value_ref=ten_ref),
                executor_pb2.CreateTupleRequest.Element(name='b',
                                                        value_ref=twenty_ref)
            ]))
        self.assertIsInstance(response, executor_pb2.CreateTupleResponse)
        tuple_ref = response.value_ref
        self.assertEqual(str(env.get_value(tuple_ref.id)), '<a=10,b=20>')

        for arg_name, arg_val, result_val in [('name', 'a', 10),
                                              ('name', 'b', 20),
                                              ('index', 0, 10),
                                              ('index', 1, 20)]:
            response = env.stub.CreateSelection(
                executor_pb2.CreateSelectionRequest(source_ref=tuple_ref,
                                                    **{arg_name: arg_val}))
            self.assertIsInstance(response,
                                  executor_pb2.CreateSelectionResponse)
            selection_ref = response.value_ref
            self.assertEqual(env.get_value(selection_ref.id), result_val)

        del env
Example #4
0
 async def create_tuple(self, elements):
   elem = anonymous_tuple.to_elements(anonymous_tuple.from_container(elements))
   proto_elem = []
   type_elem = []
   for k, v in elem:
     py_typecheck.check_type(v, RemoteValue)
     proto_elem.append(
         executor_pb2.CreateTupleRequest.Element(
             name=(k if k else None), value_ref=v.value_ref))
     type_elem.append((k, v.type_signature) if k else v.type_signature)
   result_type = computation_types.NamedTupleType(type_elem)
   request = executor_pb2.CreateTupleRequest(element=proto_elem)
   if not self._bidi_stream:
     try:
       response = self._stub.CreateTuple(request)
     except grpc.RpcError as e:
       self._handle_grpc_error(e)
   else:
     response = (await self._bidi_stream.send_request(
         executor_pb2.ExecuteRequest(create_tuple=request))).create_tuple
   py_typecheck.check_type(response, executor_pb2.CreateTupleResponse)
   return RemoteValue(response.value_ref, result_type, self)