[BACKEND-826] yapf enforcer + yapf entire repo (#33)

* Create python-package.yml

* fix syntax errors

* remove unused function

* env key

* test against prod

* let tox manage pyenv for now

* tox gh actions

* install python

* environ chooser

* fix

* move environ to conftest

* environ

* remove import

* fix

* fix

* prod

* fix

* no comments

* fix

* fix

* fix

* fix

* yapf in action

* yapf

* yapf

Author: rllin

.github/workflows/python-package.yml

@@ -1,7 +1,4 @@
-# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
-
-name: Python package
+name: Labelbox Python SDK
 
 on:
   push:
@@ -11,6 +8,8 @@ on:
 
 jobs:
   build:
+    if: github.event.pull_request.head.repo.full_name == github.repository
+
     runs-on: ubuntu-latest
     strategy:
       max-parallel: 1
@@ -19,22 +18,33 @@ jobs:
 
     steps:
     - uses: actions/checkout@v2
+      with:
+        token: ${{ secrets.ACTIONS_ACCESS_TOKEN  }}
+        ref: ${{ github.head_ref }}
 
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v2
       with:
         python-version: ${{ matrix.python-version }}
-    - name: Install dependencies
+
+    - name: yapf
+      id: yapf
+      uses: AlexanderMelde/yapf-action@master
+      with:
+        args: --verbose --recursive --parallel --style "google"
+
+    - name: install labelbox package
       run: |
-        python -m pip install --upgrade pip
-        pip install flake8 tox tox-gh-actions
         python setup.py install
-    - name: Lint with flake8
+    - name: mypy
       run: |
-        # stop the build if there are Python syntax errors or undefined names
-        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
-        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
-        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+        python -m pip install --upgrade pip
+        pip install mypy==0.782
+        mypy -p labelbox --pretty --show-error-codes
+    - name: Install package and test dependencies
+      run: |
+        pip install tox==3.18.1 tox-gh-actions==1.3.0
+
     - name: Test with tox
       env:
         # make sure to tell tox to use these environs in tox.ini
@@ -45,4 +55,4 @@ jobs:
         # the main branch which is develop right now
         LABELBOX_TEST_ENVIRON: "PROD"
       run: |
-        tox -- -svv
+        tox -- -svv

labelbox/client.py

@@ -18,10 +18,8 @@
 from labelbox.schema.organization import Organization
 from labelbox.schema.labeling_frontend import LabelingFrontend
 
-
 logger = logging.getLogger(__name__)
 
-
 _LABELBOX_API_KEY = "LABELBOX_API_KEY"
 
 
@@ -31,7 +29,8 @@ class Client:
     querying and creating top-level data objects (Projects, Datasets).
     """
 
-    def __init__(self, api_key=None,
+    def __init__(self,
+                 api_key=None,
                  endpoint='https://api.labelbox.com/graphql'):
         """ Creates and initializes a Labelbox Client.
 
@@ -54,9 +53,11 @@ def __init__(self, api_key=None,
         logger.info("Initializing Labelbox client at '%s'", endpoint)
 
         self.endpoint = endpoint
-        self.headers = {'Accept': 'application/json',
-                        'Content-Type': 'application/json',
-                        'Authorization': 'Bearer %s' % api_key}
+        self.headers = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer %s' % api_key
+        }
 
     def execute(self, query, params=None, timeout=10.0):
         """ Sends a request to the server for the execution of the
@@ -95,15 +96,17 @@ def convert_value(value):
             return value
 
         if params is not None:
-            params = {key: convert_value(value) for key, value in params.items()}
+            params = {
+                key: convert_value(value) for key, value in params.items()
+            }
 
-        data = json.dumps(
-            {'query': query, 'variables': params}).encode('utf-8')
+        data = json.dumps({'query': query, 'variables': params}).encode('utf-8')
 
         try:
-            response = requests.post(self.endpoint, data=data,
-                                        headers=self.headers,
-                                        timeout=timeout)
+            response = requests.post(self.endpoint,
+                                     data=data,
+                                     headers=self.headers,
+                                     timeout=timeout)
             logger.debug("Response: %s", response.text)
         except requests.exceptions.Timeout as e:
             raise labelbox.exceptions.TimeoutError(str(e))
@@ -136,8 +139,8 @@ def check_errors(keywords, *path):
                     return error
             return None
 
-        if check_errors(["AUTHENTICATION_ERROR"],
-                        "extensions", "exception", "code") is not None:
+        if check_errors(["AUTHENTICATION_ERROR"], "extensions", "exception",
+                        "code") is not None:
             raise labelbox.exceptions.AuthenticationError("Invalid API key")
 
         authorization_error = check_errors(["AUTHORIZATION_ERROR"],
@@ -155,7 +158,8 @@ def check_errors(keywords, *path):
             else:
                 raise labelbox.exceptions.InvalidQueryError(message)
 
-        graphql_error = check_errors(["GRAPHQL_PARSE_FAILED"], "extensions", "code")
+        graphql_error = check_errors(["GRAPHQL_PARSE_FAILED"], "extensions",
+                                     "code")
         if graphql_error is not None:
             raise labelbox.exceptions.InvalidQueryError(
                 graphql_error["message"])
@@ -167,8 +171,8 @@ def check_errors(keywords, *path):
 
         if len(errors) > 0:
             logger.warning("Unparsed errors on query execution: %r", errors)
-            raise labelbox.exceptions.LabelboxError(
-                "Unknown error: %s" % str(errors))
+            raise labelbox.exceptions.LabelboxError("Unknown error: %s" %
+                                                    str(errors))
 
         return response["data"]
 
@@ -201,24 +205,30 @@ def upload_data(self, data):
             labelbox.exceptions.LabelboxError: If upload failed.
         """
         request_data = {
-            "operations": json.dumps({
-                "variables": {"file": None, "contentLength": len(data), "sign": False},
-                "query": """mutation UploadFile($file: Upload!, $contentLength: Int!,
+            "operations":
+                json.dumps({
+                    "variables": {
+                        "file": None,
+                        "contentLength": len(data),
+                        "sign": False
+                    },
+                    "query":
+                        """mutation UploadFile($file: Upload!, $contentLength: Int!,
                                             $sign: Boolean) {
                             uploadFile(file: $file, contentLength: $contentLength,
-                                       sign: $sign) {url filename} } """,}),
+                                       sign: $sign) {url filename} } """,
+                }),
             "map": (None, json.dumps({"1": ["variables.file"]})),
-            }
+        }
         response = requests.post(
             self.endpoint,
             headers={"authorization": "Bearer %s" % self.api_key},
             data=request_data,
-            files={"1": data}
-        )
+            files={"1": data})
 
         try:
             file_data = response.json().get("data", None)
-        except ValueError as e: # response is not valid JSON
+        except ValueError as e:  # response is not valid JSON
             raise labelbox.exceptions.LabelboxError(
                 "Failed to upload, unknown cause", e)
 
@@ -350,9 +360,11 @@ def _create(self, db_object_type, data):
         """
         # Convert string attribute names to Field or Relationship objects.
         # Also convert Labelbox object values to their UIDs.
-        data = {db_object_type.attribute(attr) if isinstance(attr, str) else attr:
-                value.uid if isinstance(value, DbObject) else value
-                for attr, value in data.items()}
+        data = {
+            db_object_type.attribute(attr) if isinstance(attr, str) else attr:
+            value.uid if isinstance(value, DbObject) else value
+            for attr, value in data.items()
+        }
 
         query_string, params = query.create(db_object_type, data)
         res = self.execute(query_string, params)

labelbox/exceptions.py

@@ -1,5 +1,6 @@
 class LabelboxError(Exception):
     """Base class for exceptions."""
+
     def __init__(self, message, cause=None):
         """
         Args:
@@ -34,8 +35,8 @@ def __init__(self, db_object_type, params):
             db_object_type (type): A labelbox.schema.DbObject subtype.
             params (dict): Dict of params identifying the sought resource.
         """
-        super().__init__("Resouce '%s' not found for params: %r" % (
-            db_object_type.type_name(), params))
+        super().__init__("Resouce '%s' not found for params: %r" %
+                         (db_object_type.type_name(), params))
         self.db_object_type = db_object_type
         self.params = params
 
@@ -56,6 +57,7 @@ class InvalidQueryError(LabelboxError):
 
 class NetworkError(LabelboxError):
     """Raised when an HTTPError occurs."""
+
     def __init__(self, cause):
         super().__init__(str(cause), cause)
         self.cause = cause
@@ -69,9 +71,10 @@ class TimeoutError(LabelboxError):
 class InvalidAttributeError(LabelboxError):
     """ Raised when a field (name or Field instance) is not valid or found
     for a specific DB object type. """
+
     def __init__(self, db_object_type, field):
-        super().__init__("Field(s) '%r' not valid on DB type '%s'" % (
-            field, db_object_type.type_name()))
+        super().__init__("Field(s) '%r' not valid on DB type '%s'" %
+                         (field, db_object_type.type_name()))
         self.db_object_type = db_object_type
         self.field = field
 

labelbox/orm/comparison.py

@@ -1,6 +1,4 @@
 from enum import Enum, auto
-
-
 """ Classes for defining the client-side comparison operations used
 for filtering data in fetches. Intended for use by library internals
 and not by the end user.
@@ -60,7 +58,8 @@ def __eq__(self, other):
             (self.first == other.second and self.second == other.first))
 
     def __hash__(self):
-        return hash(self.op) + 2833 * hash(self.first) + 2837 * hash(self.second)
+        return hash(
+            self.op) + 2833 * hash(self.first) + 2837 * hash(self.second)
 
     def __repr__(self):
         return "%r %s %r" % (self.first, self.op.name, self.second)

labelbox/orm/db_object.py

@@ -7,7 +7,6 @@
 from labelbox.orm.model import Field, Relationship, Entity
 from labelbox.pagination import PaginatedCollection
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -62,8 +61,9 @@ def _set_field_values(self, field_values):
                     value = datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%fZ")
                     value = value.replace(tzinfo=timezone.utc)
                 except ValueError:
-                    logger.warning("Failed to convert value '%s' to datetime for "
-                                   "field %s", value, field)
+                    logger.warning(
+                        "Failed to convert value '%s' to datetime for "
+                        "field %s", value, field)
             setattr(self, field.name, value)
 
     def __repr__(self):
@@ -74,10 +74,10 @@ def __repr__(self):
             return "<%s>" % type_name
 
     def __str__(self):
-        attribute_values = {field.name: getattr(self, field.name)
-                            for field in self.fields()}
-        return "<%s %s>" % (self.type_name().split(".")[-1],
-                                attribute_values)
+        attribute_values = {
+            field.name: getattr(self, field.name) for field in self.fields()
+        }
+        return "<%s %s>" % (self.type_name().split(".")[-1], attribute_values)
 
     def __eq__(self, other):
         return self.type_name() == other.type_name() and self.uid == other.uid
@@ -105,7 +105,7 @@ def __init__(self, source, relationship):
         self.supports_sorting = True
         self.filter_on_id = True
 
-    def __call__(self, *args, **kwargs ):
+    def __call__(self, *args, **kwargs):
         """ Forwards the call to either `_to_many` or `_to_one` methods,
         depending on relationship type. """
         if self.relationship.relationship_type == Relationship.Type.ToMany:
@@ -125,32 +125,30 @@ def _to_many(self, where=None, order_by=None):
 
         if where is not None and not self.supports_filtering:
             raise InvalidQueryError(
-                "Relationship %s.%s doesn't support filtering" % (
-                self.source.type_name(), rel.name))
+                "Relationship %s.%s doesn't support filtering" %
+                (self.source.type_name(), rel.name))
         if order_by is not None and not self.supports_sorting:
             raise InvalidQueryError(
-                "Relationship %s.%s doesn't support sorting" % (
-                self.source.type_name(), rel.name))
+                "Relationship %s.%s doesn't support sorting" %
+                (self.source.type_name(), rel.name))
 
         if rel.filter_deleted:
             not_deleted = rel.destination_type.deleted == False
             where = not_deleted if where is None else where & not_deleted
 
         query_string, params = query.relationship(
-            self.source if self.filter_on_id else type(self.source),
-            rel, where, order_by)
+            self.source if self.filter_on_id else type(self.source), rel, where,
+            order_by)
         return PaginatedCollection(
             self.source.client, query_string, params,
-            [utils.camel_case(self.source.type_name()),
-             rel.graphql_name],
+            [utils.camel_case(self.source.type_name()), rel.graphql_name],
             rel.destination_type)
 
     def _to_one(self):
         """ Returns the relationship destination object. """
         rel = self.relationship
 
-        query_string, params = query.relationship(
-            self.source, rel, None, None)
+        query_string, params = query.relationship(self.source, rel, None, None)
         result = self.source.client.execute(query_string, params)
         result = result[utils.camel_case(type(self.source).type_name())]
         result = result[rel.graphql_name]
@@ -172,6 +170,7 @@ def disconnect(self, other):
 
 
 class Updateable:
+
     def update(self, **kwargs):
         """ Updates this DB object with new values. Values should be
         passed as key-value arguments with field names as keys:
@@ -216,6 +215,7 @@ class BulkDeletable:
     with the appropriate `use_where_clause` argument for that particular
     type.
     """
+
     @staticmethod
     def _bulk_delete(objects, use_where_clause):
         """
@@ -235,7 +235,6 @@ def _bulk_delete(objects, use_where_clause):
         query_str, params = query.bulk_delete(objects, use_where_clause)
         objects[0].client.execute(query_str, params)
 
-
     def delete(self):
         """ Deletes this DB object from the DB (server side). After
         a call to this you should not use this DB object anymore.