Fix linting error invalid-name and too-many-arguments.

1. x,y,z coordinates were too short for attribute names.
2. Too many args for Face.__init__ so moved image
   property values to FaceImageProperties.

Author: daspecster

gcloud/vision/face.py

@@ -140,20 +140,18 @@ def anger_likelihood(self):
 class Face(object):
     """Representation of a face found by the Vision API"""
 
-    def __init__(self, angles, blurred_likelihood, bounds,
-                 detection_confidence, emotions, fd_bounds,
-                 headwear_likelihood, landmarks, landmarking_confidence,
-                 under_exposed_likelihood):
+    def __init__(self, angles, bounds, detection_confidence, emotions,
+                 fd_bounds, headwear_likelihood, image_properties, landmarks,
+                 landmarking_confidence):
         self._angles = angles
-        self._blurred_likelihood = blurred_likelihood
         self._bounds = bounds
         self._detection_confidence = detection_confidence
         self._emotions = emotions
         self._fd_bounds = fd_bounds
         self._headwear_likelihood = headwear_likelihood
         self._landmarks = landmarks
         self._landmarking_confidence = landmarking_confidence
-        self._under_exposed_likelihood = under_exposed_likelihood
+        self._image_properties = image_properties
 
     @classmethod
     def from_api_repr(cls, response):
@@ -166,21 +164,19 @@ def from_api_repr(cls, response):
         :returns: A instance of `Face` with data parsed from `response`.
         """
         angles = Angles.from_api_repr(response)
-        blurred_likelihood = getattr(Likelihood, response['blurredLikelihood'])
         bounds = Bounds.from_api_repr(response['boundingPoly'])
         detection_confidence = response['detectionConfidence']
         emotions = Emotions.from_api_repr(response)
         fd_bounds = FDBounds.from_api_repr(response['fdBoundingPoly'])
         headwear_likelihood = getattr(Likelihood,
                                       response['headwearLikelihood'])
+        image_properties = FaceImageProperties.from_api_repr(response)
         landmarks = Landmarks(response['landmarks'])
         landmarking_confidence = response['landmarkingConfidence']
-        under_exposed_likelihood = getattr(Likelihood,
-                                           response['underExposedLikelihood'])
 
-        return cls(angles, blurred_likelihood, bounds, detection_confidence,
-                   emotions, fd_bounds, headwear_likelihood, landmarks,
-                   landmarking_confidence, under_exposed_likelihood)
+        return cls(angles, bounds, detection_confidence, emotions, fd_bounds,
+                   headwear_likelihood, image_properties, landmarks,
+                   landmarking_confidence)
 
     @property
     def angles(self):
@@ -192,16 +188,6 @@ def angles(self):
 
         return self._angles
 
-    @property
-    def blurred_likelihood(self):
-        """Likelihood of the image being blurred.
-
-        :rtype: str
-        :returns: String representing the likelihood based on
-                  :class:`gcloud.vision.face.Likelihood`
-        """
-        return self._blurred_likelihood
-
     @property
     def bounds(self):
         """Accessor to the bounding poly information of the detected face.
@@ -249,6 +235,15 @@ def headwear_likelihood(self):
         """
         return self._headwear_likelihood
 
+    @property
+    def image_properties(self):
+        """Image properties from imaged used in face detection.
+
+        :rtype: :class:`gcloud.vision.face.FaceImageProperties`
+        :returns: ``FaceImageProperties`` object with image properties.
+        """
+        return self._image_properties
+
     @property
     def landmarks(self):
         """Accessor to the facial landmarks detected in a face.
@@ -268,15 +263,46 @@ def landmarking_confidence(self):
         """
         return self._landmarking_confidence
 
+
+class FaceImageProperties(object):
+    """A representation of the image properties from face detection."""
+    def __init__(self, blurred_likelihood, underexposed_likelihood):
+        self._blurred_likelihood = blurred_likelihood
+        self._underexposed_likelihood = underexposed_likelihood
+
+    @classmethod
+    def from_api_repr(cls, response):
+        """Factory: construct image properties from image.
+
+        :rtype: :class:`gcloud.vision.face.FaceImageProperties`
+        :returns: Instance populated with image property data.
+        """
+        blurred_likelihood = getattr(Likelihood,
+                                     response['blurredLikelihood'])
+        underexposed_likelihood = getattr(Likelihood,
+                                          response['underExposedLikelihood'])
+
+        return cls(blurred_likelihood, underexposed_likelihood)
+
     @property
-    def under_exposed_likelihood(self):
-        """Likelihood that the image used for detection was under exposed.
+    def blurred_likelihood(self):
+        """Likelihood of the image being blurred.
 
         :rtype: str
-        :returns: String representing the likelihood based on
-                  :class:`gcloud.vision.face.Likelihood`
+        :returns: String representation derived from
+                  :class:`gcloud.vision.face.Position`.
+        """
+        return self._blurred_likelihood
+
+    @property
+    def underexposed_likelihood(self):
+        """Likelihood that the image used for detection was underexposed.
+
+        :rtype: str
+        :returns: String representation derived from
+                  :class:`gcloud.vision.face.Position`.
         """
-        return self._under_exposed_likelihood
+        return self._underexposed_likelihood
 
 
 class FaceLandmarkTypes(object):
@@ -348,7 +374,7 @@ def from_api_repr(cls, response_landmark):
 
     @property
     def position(self):
-        """Landmark position.
+        """Landmark position on face.
 
         :rtype: :class:`gcloud.vision.face.Position`
         :returns: Instance of `Position` with landmark coordinates.
@@ -357,7 +383,7 @@ def position(self):
 
     @property
     def landmark_type(self):
-        """Landmark type.
+        """Landmark type of facial feature.
 
         :rtype: str
         :returns: String representation of facial landmark type.

gcloud/vision/geometry.py

@@ -52,10 +52,10 @@ class Position(object):
     See:
     https://cloud.google.com/vision/reference/rest/v1/images/annotate#Position
     """
-    def __init__(self, x, y, z):
-        self._x = x
-        self._y = y
-        self._z = z
+    def __init__(self, x_coordinate, y_coordinate, z_coordinate):
+        self._x_coordinate = x_coordinate
+        self._y_coordinate = y_coordinate
+        self._z_coordinate = z_coordinate
 
     @classmethod
     def from_api_repr(cls, response_position):
@@ -64,37 +64,37 @@ def from_api_repr(cls, response_position):
         :rtype: :class:`gcloud.vision.geometry.Position`
         :returns: `Position` constructed with 3D points from API response.
         """
-        x = response_position['x']
-        y = response_position['y']
-        z = response_position['z']
-        return cls(x, y, z)
+        x_coordinate = response_position['x']
+        y_coordinate = response_position['y']
+        z_coordinate = response_position['z']
+        return cls(x_coordinate, y_coordinate, z_coordinate)
 
     @property
-    def x(self):
+    def x_coordinate(self):
         """X position coordinate.
 
         :rtype: float
         :returns: X position coordinate.
         """
-        return self._x
+        return self._x_coordinate
 
     @property
-    def y(self):
+    def y_coordinate(self):
         """Y position coordinate.
 
         :rtype: float
         :returns: Y position coordinate.
         """
-        return self._y
+        return self._y_coordinate
 
     @property
-    def z(self):
+    def z_coordinate(self):
         """Z position coordinate.
 
         :rtype: float
         :returns: Z position coordinate.
         """
-        return self._z
+        return self._z_coordinate
 
 
 class Vertex(object):
@@ -103,24 +103,24 @@ class Vertex(object):
     See:
     https://cloud.google.com/vision/reference/rest/v1/images/annotate#Vertex
     """
-    def __init__(self, x, y):
-        self._x = x
-        self._y = y
+    def __init__(self, x_coordinate, y_coordinate):
+        self._x_coordinate = x_coordinate
+        self._y_coordinate = y_coordinate
 
     @property
-    def x(self):
+    def x_coordinate(self):
         """X position coordinate.
 
         :rtype: float
         :returns: X position coordinate.
         """
-        return self._x
+        return self._x_coordinate
 
     @property
-    def y(self):
+    def y_coordinate(self):
         """Y position coordinate.
 
         :rtype: float
         :returns: Y position coordinate.
         """
-        return self._y
+        return self._y_coordinate

gcloud/vision/test_face.py

@@ -31,9 +31,12 @@ def test_face_landmarks(self):
         self.assertEqual(0.54453093, self.face.landmarking_confidence)
         self.assertEqual(0.9863683, self.face.detection_confidence)
         self.assertTrue(hasattr(self.face.landmarks, 'left_eye'))
-        self.assertEqual(1004.8003, self.face.landmarks.left_eye.position.x)
-        self.assertEqual(482.69385, self.face.landmarks.left_eye.position.y)
-        self.assertEqual(0.0016593217, self.face.landmarks.left_eye.position.z)
+        self.assertEqual(1004.8003,
+                         self.face.landmarks.left_eye.position.x_coordinate)
+        self.assertEqual(482.69385,
+                         self.face.landmarks.left_eye.position.y_coordinate)
+        self.assertEqual(0.0016593217,
+                         self.face.landmarks.left_eye.position.z_coordinate)
         self.assertEqual('LEFT_EYE',
                          self.face.landmarks.left_eye.landmark_type)
 
@@ -56,18 +59,18 @@ def test_faciale_angles(self):
     def test_face_headware_and_blur_and_underexposed(self):
         from gcloud.vision.face import Likelihood
         self.assertEqual(Likelihood.VERY_UNLIKELY,
-                         self.face.blurred_likelihood)
+                         self.face.image_properties.blurred_likelihood)
         self.assertEqual(Likelihood.VERY_UNLIKELY,
                          self.face.headwear_likelihood)
         self.assertEqual(Likelihood.VERY_UNLIKELY,
-                         self.face.under_exposed_likelihood)
+                         self.face.image_properties.underexposed_likelihood)
 
     def test_face_bounds(self):
         self.assertEqual(4, len(self.face.bounds.vertices))
-        self.assertEqual(748, self.face.bounds.vertices[0].x)
-        self.assertEqual(58, self.face.bounds.vertices[0].y)
+        self.assertEqual(748, self.face.bounds.vertices[0].x_coordinate)
+        self.assertEqual(58, self.face.bounds.vertices[0].y_coordinate)
 
     def test_facial_skin_bounds(self):
         self.assertEqual(4, len(self.face.fd_bounds.vertices))
-        self.assertEqual(845, self.face.fd_bounds.vertices[0].x)
-        self.assertEqual(310, self.face.fd_bounds.vertices[0].y)
+        self.assertEqual(845, self.face.fd_bounds.vertices[0].x_coordinate)
+        self.assertEqual(310, self.face.fd_bounds.vertices[0].y_coordinate)