Add gax support for entity annotations.

system_tests/vision.py

@@ -73,6 +73,10 @@ def _assert_likelihood(self, likelihood):
                   Likelihood.VERY_UNLIKELY]
         self.assertIn(likelihood, levels)
 
+    def _maybe_http_skip(self, message):
+        if not Config.CLIENT._use_gax:
+            self.skipTest(message)
+
 
 class TestVisionClientLogo(unittest.TestCase):
     def setUp(self):
@@ -190,6 +194,7 @@ def _assert_face(self, face):
 
     def test_detect_faces_content(self):
         client = Config.CLIENT
+        self._maybe_http_skip('gRPC is required for face detection.')
         with open(FACE_FILE, 'rb') as image_file:
             image = client.image(content=image_file.read())
         faces = image.detect_faces()
@@ -198,6 +203,7 @@ def test_detect_faces_content(self):
             self._assert_face(face)
 
     def test_detect_faces_gcs(self):
+        self._maybe_http_skip('gRPC is required for face detection.')
         bucket_name = Config.TEST_BUCKET.name
         blob_name = 'faces.jpg'
         blob = Config.TEST_BUCKET.blob(blob_name)
@@ -206,7 +212,6 @@ def test_detect_faces_gcs(self):
             blob.upload_from_file(file_obj)
 
         source_uri = 'gs://%s/%s' % (bucket_name, blob_name)
-
         client = Config.CLIENT
         image = client.image(source_uri=source_uri)
         faces = image.detect_faces()
@@ -215,6 +220,7 @@ def test_detect_faces_gcs(self):
             self._assert_face(face)
 
     def test_detect_faces_filename(self):
+        self._maybe_http_skip('gRPC is required for face detection.')
         client = Config.CLIENT
         image = client.image(filename=FACE_FILE)
         faces = image.detect_faces()
@@ -361,6 +367,7 @@ def _assert_safe_search(self, safe_search):
         self._assert_likelihood(safe_search.violence)
 
     def test_detect_safe_search_content(self):
+        self._maybe_http_skip('gRPC is required for safe search detection.')
         client = Config.CLIENT
         with open(FACE_FILE, 'rb') as image_file:
             image = client.image(content=image_file.read())
@@ -370,6 +377,7 @@ def test_detect_safe_search_content(self):
         self._assert_safe_search(safe_search)
 
     def test_detect_safe_search_gcs(self):
+        self._maybe_http_skip('gRPC is required for safe search detection.')
         bucket_name = Config.TEST_BUCKET.name
         blob_name = 'faces.jpg'
         blob = Config.TEST_BUCKET.blob(blob_name)
@@ -387,6 +395,7 @@ def test_detect_safe_search_gcs(self):
         self._assert_safe_search(safe_search)
 
     def test_detect_safe_search_filename(self):
+        self._maybe_http_skip('gRPC is required for safe search detection.')
         client = Config.CLIENT
         image = client.image(filename=FACE_FILE)
         safe_searches = image.detect_safe_search()
@@ -484,6 +493,7 @@ def _assert_properties(self, image_property):
             self.assertNotEqual(color_info.score, 0.0)
 
     def test_detect_properties_content(self):
+        self._maybe_http_skip('gRPC is required for text detection.')
         client = Config.CLIENT
         with open(FACE_FILE, 'rb') as image_file:
             image = client.image(content=image_file.read())
@@ -493,6 +503,8 @@ def test_detect_properties_content(self):
         self._assert_properties(image_property)
 
     def test_detect_properties_gcs(self):
+        self._maybe_http_skip('gRPC is required for text detection.')
+        client = Config.CLIENT
         bucket_name = Config.TEST_BUCKET.name
         blob_name = 'faces.jpg'
         blob = Config.TEST_BUCKET.blob(blob_name)
@@ -502,14 +514,14 @@ def test_detect_properties_gcs(self):
 
         source_uri = 'gs://%s/%s' % (bucket_name, blob_name)
 
-        client = Config.CLIENT
         image = client.image(source_uri=source_uri)
         properties = image.detect_properties()
         self.assertEqual(len(properties), 1)
         image_property = properties[0]
         self._assert_properties(image_property)
 
     def test_detect_properties_filename(self):
+        self._maybe_http_skip('gRPC is required for text detection.')
         client = Config.CLIENT
         image = client.image(filename=FACE_FILE)
         properties = image.detect_properties()

vision/google/cloud/vision/_gax.py

@@ -19,6 +19,8 @@
 
 from google.cloud._helpers import _to_bytes
 
+from google.cloud.vision.annotations import Annotations
+
 
 class _GAPICVisionAPI(object):
     """Vision API for interacting with the gRPC version of Vision.
@@ -28,7 +30,32 @@ class _GAPICVisionAPI(object):
     """
     def __init__(self, client=None):
         self._client = client
-        self._api = image_annotator_client.ImageAnnotatorClient()
+        self._annotator_client = image_annotator_client.ImageAnnotatorClient()
+
+    def annotate(self, image, features):
+        """Annotate images through GAX.
+
+        :type image: :class:`~google.cloud.vision.image.Image`
+        :param image: Instance of ``Image``.
+
+        :type features: list
+        :param features: List of :class:`~google.cloud.vision.feature.Feature`.
+
+        :rtype: :class:`~google.cloud.vision.annotations.Annotations`
+        :returns: Instance of ``Annotations`` with results or ``None``.
+        """
+        gapic_features = [_to_gapic_feature(feature) for feature in features]
+        gapic_image = _to_gapic_image(image)
+        request = image_annotator_pb2.AnnotateImageRequest(
+            image=gapic_image, features=gapic_features)
+        requests = [request]
+        annotator_client = self._annotator_client
+        images = annotator_client.batch_annotate_images(requests)
+        if len(images.responses) == 1:
+            return Annotations.from_pb(images.responses[0])
+        elif len(images.responses) > 1:
+            raise NotImplementedError(
+                'Multiple image processing is not yet supported.')
 
 
 def _to_gapic_feature(feature):

vision/google/cloud/vision/_http.py

@@ -14,6 +14,7 @@
 
 """HTTP Client for interacting with the Google Cloud Vision API."""
 
+from google.cloud.vision.annotations import Annotations
 from google.cloud.vision.feature import Feature
 
 
@@ -48,8 +49,12 @@ def annotate(self, image, features):
         data = {'requests': [request]}
         api_response = self._connection.api_request(
             method='POST', path='/images:annotate', data=data)
-        responses = api_response.get('responses')
-        return responses[0]
+        images = api_response.get('responses')
+        if len(images) == 1:
+            return Annotations.from_api_repr(images[0])
+        elif len(images) > 1:
+            raise NotImplementedError(
+                'Multiple image processing is not yet supported.')
 
 
 def _make_request(image, features):

vision/google/cloud/vision/annotations.py

@@ -93,6 +93,51 @@ def from_api_repr(cls, response):
                 _entity_from_response_type(feature_type, annotation))
         return cls(**annotations)
 
+    @classmethod
+    def from_pb(cls, response):
+        """Factory: construct an instance of ``Annotations`` from protobuf.
+
+        :type response: :class:`~google.cloud.grpc.vision.v1.\
+                        image_annotator_pb2.AnnotateImageResponse`
+        :param response: ``AnnotateImageResponse`` from protobuf call.
+
+        :rtype: :class:`~google.cloud.vision.annotations.Annotations`
+        :returns: ``Annotations`` instance populated from gRPC response.
+        """
+        annotations = _process_image_annotations(response)
+        return cls(**annotations)
+
+
+def _process_image_annotations(image):
+    """Helper for processing annotation types from protobuf.
+
+    :type image: :class:`~google.cloud.grpc.vision.v1.image_annotator_pb2.\
+                 AnnotateImageResponse`
+    :param image: ``AnnotateImageResponse`` from protobuf.
+
+    :rtype: dict
+    :returns: Dictionary populated with entities from response.
+    """
+    return {
+        'labels': _make_entity_from_pb(image.label_annotations),
+        'landmarks': _make_entity_from_pb(image.landmark_annotations),
+        'logos': _make_entity_from_pb(image.logo_annotations),
+        'texts': _make_entity_from_pb(image.text_annotations),
+    }
+
+
+def _make_entity_from_pb(annotations):
+    """Create an entity from a gRPC response.
+
+    :type annotations:
+    :class:`~google.cloud.grpc.vision.v1.image_annotator_pb2.EntityAnnotation`
+    :param annotations: protobuf instance of ``EntityAnnotation``.
+
+    :rtype: list
+    :returns: List of ``EntityAnnotation``.
+    """
+    return [EntityAnnotation.from_pb(annotation) for annotation in annotations]
+
 
 def _entity_from_response_type(feature_type, results):
     """Convert a JSON result to an entity type based on the feature.

vision/google/cloud/vision/entity.py

@@ -64,12 +64,32 @@ def from_api_repr(cls, response):
         description = response['description']
         locale = response.get('locale', None)
         locations = [LocationInformation.from_api_repr(location)
-                     for location in response.get('locations', [])]
+                     for location in response.get('locations', ())]
         mid = response.get('mid', None)
         score = response.get('score', None)
 
         return cls(bounds, description, locale, locations, mid, score)
 
+    @classmethod
+    def from_pb(cls, response):
+        """Factory: construct entity from Vision gRPC response.
+
+        :type response: :class:`~google.cloud.grpc.vision.v1.\
+                        image_annotator_pb2.AnnotateImageResponse`
+        :param response: gRPC response from Vision API with entity data.
+
+        :rtype: :class:`~google.cloud.vision.entity.EntityAnnotation`
+        :returns: Instance of ``EntityAnnotation``.
+        """
+        bounds = Bounds.from_pb(response.bounding_poly)
+        description = response.description
+        locale = response.locale
+        locations = [LocationInformation.from_pb(location)
+                     for location in response.locations]
+        mid = response.mid
+        score = response.score
+        return cls(bounds, description, locale, locations, mid, score)
+
     @property
     def bounds(self):
         """Bounding polygon of detected image feature.

vision/google/cloud/vision/geometry.py

@@ -25,21 +25,33 @@ def __init__(self, vertices):
         self._vertices = vertices
 
     @classmethod
-    def from_api_repr(cls, response_vertices):
+    def from_api_repr(cls, vertices):
         """Factory: construct BoundsBase instance from Vision API response.
 
-        :type response_vertices: dict
-        :param response_vertices: List of vertices.
+        :type vertices: dict
+        :param vertices: List of vertices.
 
         :rtype: :class:`~google.cloud.vision.geometry.BoundsBase` or None
         :returns: Instance of BoundsBase with populated verticies or None.
         """
-        if not response_vertices:
+        if vertices is None:
             return None
+        return cls([Vertex(vertex.get('x', None), vertex.get('y', None))
+                    for vertex in vertices.get('vertices', ())])
 
-        vertices = [Vertex(vertex.get('x', None), vertex.get('y', None)) for
-                    vertex in response_vertices.get('vertices', [])]
-        return cls(vertices)
+    @classmethod
+    def from_pb(cls, vertices):
+        """Factory: construct BoundsBase instance from Vision gRPC response.
+
+        :type vertices: :class:`~google.cloud.grpc.vision.v1.\
+                                 geometry_pb2.BoundingPoly`
+        :param vertices: List of vertices.
+
+        :rtype: :class:`~google.cloud.vision.geometry.BoundsBase` or None
+        :returns: Instance of ``BoundsBase`` with populated verticies.
+        """
+        return cls([Vertex(vertex.x, vertex.y)
+                    for vertex in vertices.vertices])
 
     @property
     def vertices(self):
@@ -73,20 +85,35 @@ def __init__(self, latitude, longitude):
         self._longitude = longitude
 
     @classmethod
-    def from_api_repr(cls, response):
+    def from_api_repr(cls, location_info):
         """Factory: construct location information from Vision API response.
 
-        :type response: dict
-        :param response: Dictionary response of locations.
+        :type location_info: dict
+        :param location_info: Dictionary response of locations.
 
         :rtype: :class:`~google.cloud.vision.geometry.LocationInformation`
         :returns: ``LocationInformation`` with populated latitude and
                   longitude.
         """
-        latitude = response['latLng']['latitude']
-        longitude = response['latLng']['longitude']
+        lat_long = location_info.get('latLng', {})
+        latitude = lat_long.get('latitude')
+        longitude = lat_long.get('longitude')
         return cls(latitude, longitude)
 
+    @classmethod
+    def from_pb(cls, location_info):
+        """Factory: construct location information from Vision gRPC response.
+
+        :type location_info: :class:`~google.cloud.vision.v1.LocationInfo`
+        :param location_info: gRPC response of ``LocationInfo``.
+
+        :rtype: :class:`~google.cloud.vision.geometry.LocationInformation`
+        :returns: ``LocationInformation`` with populated latitude and
+                  longitude.
+        """
+        return cls(location_info.lat_lng.latitude,
+                   location_info.lat_lng.longitude)
+
     @property
     def latitude(self):
         """Latitude coordinate.
@@ -127,15 +154,18 @@ def __init__(self, x_coordinate, y_coordinate, z_coordinate):
         self._z_coordinate = z_coordinate
 
     @classmethod
-    def from_api_repr(cls, response_position):
+    def from_api_repr(cls, position):
         """Factory: construct 3D position from API response.
 
+        :type position: dict
+        :param position: Dictionary with 3 axis position data.
+
         :rtype: :class:`~google.cloud.vision.geometry.Position`
         :returns: `Position` constructed with 3D points from API response.
         """
-        x_coordinate = response_position['x']
-        y_coordinate = response_position['y']
-        z_coordinate = response_position['z']
+        x_coordinate = position['x']
+        y_coordinate = position['y']
+        z_coordinate = position['z']
         return cls(x_coordinate, y_coordinate, z_coordinate)
 
     @property

vision/google/cloud/vision/image.py

@@ -19,7 +19,6 @@
 
 from google.cloud._helpers import _to_bytes
 from google.cloud._helpers import _bytes_to_unicode
-from google.cloud.vision.annotations import Annotations
 from google.cloud.vision.feature import Feature
 from google.cloud.vision.feature import FeatureTypes
 
@@ -109,8 +108,7 @@ def _detect_annotation(self, features):
                   :class:`~google.cloud.vision.color.ImagePropertiesAnnotation`,
                   :class:`~google.cloud.vision.sage.SafeSearchAnnotation`,
         """
-        results = self.client._vision_api.annotate(self, features)
-        return Annotations.from_api_repr(results)
+        return self.client._vision_api.annotate(self, features)
 
     def detect(self, features):
         """Detect multiple feature types.