Merge pull request googleapis#3094 from dhermes/fix-2746-lookup

Making datastore Connection.lookup() return low-level protobuf.

Author: dhermes

datastore/google/cloud/datastore/_http.py

@@ -326,23 +326,14 @@ def lookup(self, project, key_pbs,
                                the given transaction.  Incompatible with
                                ``eventual==True``.
 
-        :rtype: tuple
-        :returns: A triple of (``results``, ``missing``, ``deferred``) where
-                  both ``results`` and ``missing`` are lists of
-                  :class:`.entity_pb2.Entity`
-                  and ``deferred`` is a list of
-                  :class:`.entity_pb2.Key`.
+        :rtype: :class:`.datastore_pb2.LookupResponse`
+        :returns: The returned protobuf for the lookup request.
         """
         lookup_request = _datastore_pb2.LookupRequest()
         _set_read_options(lookup_request, eventual, transaction_id)
         _add_keys_to_request(lookup_request.keys, key_pbs)
 
-        lookup_response = self._datastore_api.lookup(project, lookup_request)
-
-        results = [result.entity for result in lookup_response.found]
-        missing = [result.entity for result in lookup_response.missing]
-
-        return results, missing, list(lookup_response.deferred)
+        return self._datastore_api.lookup(project, lookup_request)
 
     def run_query(self, project, query_pb, namespace=None,
                   eventual=False, transaction_id=None):

datastore/google/cloud/datastore/client.py

@@ -116,28 +116,29 @@ def _extended_lookup(connection, project, key_pbs,
     while loop_num < _MAX_LOOPS:  # loop against possible deferred.
         loop_num += 1
 
-        results_found, missing_found, deferred_found = connection.lookup(
+        lookup_response = connection.lookup(
             project=project,
             key_pbs=key_pbs,
             eventual=eventual,
             transaction_id=transaction_id,
         )
 
-        results.extend(results_found)
+        # Accumulate the new results.
+        results.extend(result.entity for result in lookup_response.found)
 
         if missing is not None:
-            missing.extend(missing_found)
+            missing.extend(result.entity for result in lookup_response.missing)
 
         if deferred is not None:
-            deferred.extend(deferred_found)
+            deferred.extend(lookup_response.deferred)
             break
 
-        if len(deferred_found) == 0:
+        if len(lookup_response.deferred) == 0:
             break
 
         # We have deferred keys, and the user didn't ask to know about
         # them, so retry (but only with the deferred ones).
-        key_pbs = deferred_found
+        key_pbs = lookup_response.deferred
 
     return results