Black formatting.

Author: paul121

farmOS/__init__.py

@@ -16,13 +16,15 @@
 class farmOS:
     """A client that connects to the farmOS server."""
 
-    def __init__(self,
-                 hostname,
-                 client_id='farm',
-                 client_secret=None,
-                 scope='user_access',
-                 token=None,
-                 token_updater=None):
+    def __init__(
+        self,
+        hostname,
+        client_id="farm",
+        client_secret=None,
+        scope="user_access",
+        token=None,
+        token_updater=None,
+    ):
         """
         Initialize instance of the farmOS client that connects to a single farmOS server.
 
@@ -35,12 +37,12 @@ def __init__(self,
         :param token_updater: A function used to save OAuth tokens outside of the client.
         """
 
-        logger.debug('Creating farmOS client.')
+        logger.debug("Creating farmOS client.")
 
         # Load the token updater function.
         self.token_updater = None
         if token_updater is not None:
-            logger.debug('Using provided token_updater utility.')
+            logger.debug("Using provided token_updater utility.")
             self.token_updater = token_updater
 
         self.session = None
@@ -54,7 +56,7 @@ def __init__(self,
             # Add a default scheme if not provided.
             if not parsed_url.scheme:
                 parsed_url = parsed_url._replace(scheme=default_scheme)
-                logger.debug('No scheme provided. Using %s', default_scheme)
+                logger.debug("No scheme provided. Using %s", default_scheme)
 
             # Check for a valid scheme.
             if parsed_url.scheme not in valid_schemes:
@@ -63,7 +65,7 @@ def __init__(self,
             # If not netloc was provided, it was probably parsed as the path.
             if not parsed_url.netloc and parsed_url.path:
                 parsed_url = parsed_url._replace(netloc=parsed_url.path)
-                parsed_url = parsed_url._replace(path='')
+                parsed_url = parsed_url._replace(path="")
 
             # Check for netloc.
             if not parsed_url.netloc:
@@ -75,53 +77,57 @@ def __init__(self,
 
             # Build the url again to include changes.
             hostname = urlunparse(parsed_url)
-            logger.debug('Complete hostname configured as %s', hostname)
+            logger.debug("Complete hostname configured as %s", hostname)
 
         else:
             raise Exception("No hostname provided and could not be loaded from config.")
 
-        logger.debug('Creating an OAuth Session.')
-        token_url = hostname + '/oauth2/token'
+        logger.debug("Creating an OAuth Session.")
+        token_url = hostname + "/oauth2/token"
 
         # Check the token expiration time.
-        if token is not None and 'expires_at' in token:
+        if token is not None and "expires_at" in token:
             # Create datetime objects for comparison.
             now = datetime.now()
-            expiration_time = datetime.fromtimestamp(float(token['expires_at']))
+            expiration_time = datetime.fromtimestamp(float(token["expires_at"]))
 
             # Calculate seconds until expiration.
             timedelta = expiration_time - now
             expires_in = timedelta.total_seconds()
 
             # Update the token expires_in value
-            token['expires_in'] = expires_in
+            token["expires_in"] = expires_in
 
             # Unset the 'expires_at' key.
-            token.pop('expires_at')
+            token.pop("expires_at")
 
         # Create an OAuth Session
-        self.session = OAuthSession(hostname=hostname,
-                                    client_id=client_id,
-                                    client_secret=client_secret,
-                                    scope=scope,
-                                    token=token,
-                                    token_url=token_url,
-                                    token_updater=self.token_updater)
+        self.session = OAuthSession(
+            hostname=hostname,
+            client_id=client_id,
+            client_secret=client_secret,
+            scope=scope,
+            token=token,
+            token_url=token_url,
+            token_updater=self.token_updater,
+        )
 
         self._client_id = client_id
         self._client_secret = client_secret
 
         if self.session is None:
-            raise Exception("Could not create a session object. Supply authentication credentials when "
-                            "initializing a farmOS Client.")
+            raise Exception(
+                "Could not create a session object. Supply authentication credentials when "
+                "initializing a farmOS Client."
+            )
 
         self.log = LogAPI(self.session)
         self.asset = AssetAPI(self.session)
         self.area = AreaAPI(self.session)
         self.term = TermAPI(self.session)
         self.info = partial(info, self.session)
 
-    def authorize(self, username=None, password=None, scope='user_access'):
+    def authorize(self, username=None, password=None, scope="user_access"):
         """Authorize with the farmOS server.
 
         The client must be authorized with the farmOS server before making requests.

farmOS/client.py

@@ -4,6 +4,7 @@
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
 
+
 class BaseAPI(object):
     """Base class for API methods
 
@@ -24,17 +25,21 @@ def __init__(self, session, entity_type=None):
     def _get_single_record_data(self, id):
         """Retrieve one record given the record ID"""
         # Set path to return record type by specific ID
-        path = self.entity_type + '/' + str(id) + '.json'
+        path = self.entity_type + "/" + str(id) + ".json"
 
-        logger.debug('Getting single record data for id: %s of entity type: %s', id, self.entity_type)
+        logger.debug(
+            "Getting single record data for id: %s of entity type: %s",
+            id,
+            self.entity_type,
+        )
         response = self.session.http_request(path=path)
 
         return response.json()
 
     def _get_record_data(self, filters):
         """Retrieve one page of raw record data from the farmOS API."""
         # Set path to return record type + filters
-        path = self.entity_type + '.json'
+        path = self.entity_type + ".json"
         # Combine instance filters and filters from the method call
         filters = {**self.filters, **filters}
 
@@ -44,12 +49,12 @@ def _get_record_data(self, filters):
         data = {}
 
         response = response.json()
-        if 'list' in response:
-            data['list'] = response['list']
-            data['page'] = {
-                'self': _parse_api_page(url=response['self']),
-                'first': _parse_api_page(url=response['first']),
-                'last': _parse_api_page(url=response['last']),
+        if "list" in response:
+            data["list"] = response["list"]
+            data["page"] = {
+                "self": _parse_api_page(url=response["self"]),
+                "first": _parse_api_page(url=response["first"]),
+                "last": _parse_api_page(url=response["last"]),
             }
 
         return data
@@ -59,31 +64,37 @@ def _get_all_record_data(self, filters, page=0, list=None):
         if list is None:
             list = []
 
-        filters['page'] = page
+        filters["page"] = page
 
-        logger.debug('Getting page: %s of record data of entity type: %s', filters['page'], self.entity_type)
+        logger.debug(
+            "Getting page: %s of record data of entity type: %s",
+            filters["page"],
+            self.entity_type,
+        )
         data = self._get_record_data(filters=filters)
 
         # Append record data to list of all requested data
-        if 'list' in data:
-            list = list + data['list']
+        if "list" in data:
+            list = list + data["list"]
 
         # Check to see if there are more pages
-        if 'page' in data:
-            last_page = data['page']['last']
+        if "page" in data:
+            last_page = data["page"]["last"]
             # Last page, return the list
             if last_page == page:
                 data = {
-                    'page': {
-                        'first': data['page']['first'],
-                        'last': data['page']['last'],
+                    "page": {
+                        "first": data["page"]["first"],
+                        "last": data["page"]["last"],
                     },
-                    'list': list,
+                    "list": list,
                 }
                 return data
             # Recursive call, get the next page
             else:
-                return self._get_all_record_data(list=list, page=(page+1), filters=filters)
+                return self._get_all_record_data(
+                    list=list, page=(page + 1), filters=filters
+                )
 
     def _get_records(self, filters=None):
         """Helper function that checks to retrieve one record, one page or multiple pages of farmOS records"""
@@ -95,11 +106,17 @@ def _get_records(self, filters=None):
             return self._get_single_record_data(filters)
         elif isinstance(filters, dict):
             # Check if the caller requests a specific page
-            if 'page' in filters:
-                logger.debug('Getting page: %s of record data of entity type: %s', filters['page'], self.entity_type)
+            if "page" in filters:
+                logger.debug(
+                    "Getting page: %s of record data of entity type: %s",
+                    filters["page"],
+                    self.entity_type,
+                )
                 return self._get_record_data(filters=filters)
             else:
-                logger.debug('Getting all record data of entity type: %s', self.entity_type)
+                logger.debug(
+                    "Getting all record data of entity type: %s", self.entity_type
+                )
                 return self._get_all_record_data(filters=filters)
 
     def get(self, filters=None):
@@ -110,43 +127,47 @@ def get(self, filters=None):
         return data
 
     def send(self, payload):
-        options = {'json': payload}
+        options = {"json": payload}
 
         # If an ID is included, update the record
-        id = payload.pop('id', None)
+        id = payload.pop("id", None)
         if id:
-            logger.debug('Updating record id: of entity type: %s', id, self.entity_type)
-            path = self.entity_type + '/' + str(id)
-            response = self.session.http_request(method='PUT', path=path, options=options)
+            logger.debug("Updating record id: of entity type: %s", id, self.entity_type)
+            path = self.entity_type + "/" + str(id)
+            response = self.session.http_request(
+                method="PUT", path=path, options=options
+            )
         # If no ID is included, create a new record
         else:
-            logger.debug('Creating record of entity type: %s', self.entity_type)
+            logger.debug("Creating record of entity type: %s", self.entity_type)
             path = self.entity_type
-            response = self.session.http_request(method='POST', path=path, options=options)
+            response = self.session.http_request(
+                method="POST", path=path, options=options
+            )
 
         # Handle response from POST requests
         if response.status_code == 201:
-            logger.debug('Record created.')
+            logger.debug("Record created.")
             return response.json()
 
         # Handle response from PUT requests
         if response.status_code == 200:
-            logger.debug('Record updated.')
+            logger.debug("Record updated.")
             # farmOS returns no response data for PUT requests
             # response_data = response.json()
 
             # Hard code the entity ID, path, and resource
             entity_data = {
-                'id': id,
-                'uri': path,
-                'resource': self.entity_type,
+                "id": id,
+                "uri": path,
+                "resource": self.entity_type,
             }
             return entity_data
 
     def delete(self, id):
-        logger.debug('Deleted record id: %s of entity type: %s', id, self.entity_type)
-        path = self.entity_type + '/' + str(id)
-        response = self.session.http_request(method='DELETE', path=path)
+        logger.debug("Deleted record id: %s of entity type: %s", id, self.entity_type)
+        path = self.entity_type + "/" + str(id)
+        response = self.session.http_request(method="DELETE", path=path)
 
         return response
 
@@ -156,15 +177,15 @@ class TermAPI(BaseAPI):
 
     def __init__(self, session):
         # Define 'taxonomy_term' as the farmOS API entity endpoint
-        super().__init__(session=session, entity_type='taxonomy_term')
+        super().__init__(session=session, entity_type="taxonomy_term")
 
     def get(self, filters=None):
         """Get method that supports a bundle name as the 'filter' parameter"""
 
         # Check if filters parameter is a str
         if isinstance(filters, str):
             # Add filters to instance requests.session filter dict with keyword 'bundle'
-            self.filters['bundle'] = filters
+            self.filters["bundle"] = filters
             # Reset filters to empty dict
             filters = {}
 
@@ -178,23 +199,23 @@ class LogAPI(BaseAPI):
 
     def __init__(self, session):
         # Define 'log' as the farmOS API entity endpoint
-        super().__init__(session=session, entity_type='log')
+        super().__init__(session=session, entity_type="log")
 
 
 class AssetAPI(BaseAPI):
     """API for interacting with farm assets"""
 
     def __init__(self, session):
         # Define 'farm_asset' as the farmOS API entity endpoint
-        super().__init__(session=session, entity_type='farm_asset')
+        super().__init__(session=session, entity_type="farm_asset")
 
 
 class AreaAPI(TermAPI):
     """API for interacting with farm areas, a subset of farm terms"""
 
     def __init__(self, session):
         super().__init__(session=session)
-        self.filters['bundle'] = 'farm_areas'
+        self.filters["bundle"] = "farm_areas"
 
     def get(self, filters=None):
         """Retrieve raw record data from the farmOS API.
@@ -208,7 +229,7 @@ def get(self, filters=None):
             tid = str(filters)
             # Add tid to filters object
             filters = {
-                'tid': tid,
+                "tid": tid,
             }
 
         data = self._get_records(filters=filters)
@@ -219,7 +240,7 @@ def get(self, filters=None):
 def info(session):
     """Retrieve info about the farmOS server."""
 
-    logger.debug('Retrieving farmOS server info.')
+    logger.debug("Retrieving farmOS server info.")
     response = session.http_request("farm.json")
     return response.json()
 
@@ -233,6 +254,6 @@ def _parse_api_page(url):
     """
 
     parsed_url = urlparse(url)
-    page_num = parse_qs(parsed_url.query)['page'][0]
+    page_num = parse_qs(parsed_url.query)["page"][0]
 
     return int(page_num)