fix formatting

Author: gabrielburnworth

farmbot_sidecar_starter_pack/functions/api.py

@@ -15,6 +15,7 @@
 
 class HTMLResponseParser(HTMLParser):
     """Response parser for HTML content."""
+
     def __init__(self):
         super().__init__()
         self.is_header = False
@@ -42,6 +43,7 @@ def handle_data(self, data):
 
 class ApiConnect():
     """Connect class for FarmBot API."""
+
     def __init__(self, state):
         self.state = state
 
@@ -52,19 +54,25 @@ def get_token(self, email, password, server="https://my.farm.bot"):
             headers = {'content-type': 'application/json'}
             user = {'user': {'email': email, 'password': password}}
             timeout = self.state.timeout["api"]
-            response = requests.post(f'{server}/api/tokens', headers=headers, json=user, timeout=timeout)
+            response = requests.post(
+                url=f'{server}/api/tokens',
+                headers=headers,
+                json=user,
+                timeout=timeout)
             # Handle HTTP status codes
             if response.status_code == 200:
                 self.state.token = response.json()
                 self.state.error = None
-                self.state.print_status(description=f"Successfully fetched token from {server}.")
+                description = f"Successfully fetched token from {server}."
+                self.state.print_status(description=description)
                 return response.json()
             elif response.status_code == 404:
                 self.state.error = "HTTP ERROR: The server address does not exist."
             elif response.status_code == 422:
                 self.state.error = "HTTP ERROR: Incorrect email address or password."
             else:
-                self.state.error = f"HTTP ERROR: Unexpected status code {response.status_code}"
+                code = response.status_code
+                self.state.error = f"HTTP ERROR: Unexpected status code {code}"
         # Handle DNS resolution errors
         except requests.exceptions.RequestException as e:
             if isinstance(e, requests.exceptions.ConnectionError):
@@ -74,7 +82,7 @@ def get_token(self, email, password, server="https://my.farm.bot"):
             elif isinstance(e, requests.exceptions.RequestException):
                 self.state.error = "DNS ERROR: There was a problem with the request."
         except Exception as e:
-            self.state.error = f"DNS ERROR: An unexpected error occurred: {str(e)}"
+            self.state.error = f"DNS ERROR: An unexpected error occurred: {e}"
 
         self.state.token = None
         self.state.print_status(description=self.state.error)
@@ -109,16 +117,18 @@ def request_handling(self, response, make_request):
             self.state.print_status(description=description)
             return 200
         if 400 <= response.status_code < 500:
-            self.state.error = f"CLIENT ERROR {response.status_code}: {error_messages.get(response.status_code, response.reason)}"
+            err = error_messages.get(response.status_code, response.reason)
+            self.state.error = f"CLIENT ERROR {response.status_code}: {err}"
         elif 500 <= response.status_code < 600:
             self.state.error = f"SERVER ERROR {response.status_code}: {text}"
         else:
-            self.state.error = f"UNEXPECTED ERROR {response.status_code}: {text}"
+            code = response.status_code
+            self.state.error = f"UNEXPECTED ERROR {code}: {text}"
 
         try:
             response.json()
         except requests.exceptions.JSONDecodeError:
-                self.state.error += f" ({text})"
+            self.state.error += f" ({text})"
         else:
             self.state.error += f" ({json.dumps(response.json(), indent=2)})"
 
@@ -142,19 +152,27 @@ def request(self, method, endpoint, database_id, payload=None):
         http_part = "https" if self.state.ssl else "http"
         url = f'{http_part}:{iss}/api/{endpoint}{id_part}'
 
-        headers = {'authorization': token['encoded'], 'content-type': 'application/json'}
+        headers = {'authorization': token['encoded'],
+                   'content-type': 'application/json'}
         make_request = not self.state.dry_run or method == "GET"
         if make_request:
             timeout = self.state.timeout["api"]
-            response = requests.request(method, url, headers=headers, json=payload, timeout=timeout)
+            response = requests.request(
+                method=method,
+                url=url,
+                headers=headers,
+                json=payload,
+                timeout=timeout)
         else:
             response = requests.Response()
             response.status_code = 200
             response._content = b'{"edit_requests_disabled": true}'
 
         if self.request_handling(response, make_request) == 200:
             self.state.error = None
-            self.state.print_status(description="Successfully returned request contents.")
+            description = "Successfully fetched request contents."
+            self.state.print_status(description=description)
             return response.json()
-        self.state.print_status(description="There was an error processing the request...")
+        description = "There was an error processing the request..."
+        self.state.print_status(description=description)
         return self.state.error

farmbot_sidecar_starter_pack/functions/basic_commands.py

@@ -11,16 +11,19 @@
 
 from .broker import BrokerConnect
 
+
 class BasicCommands():
     """Basic commands class."""
+
     def __init__(self, state):
         self.broker = BrokerConnect(state)
         self.state = state
 
     def wait(self, duration):
         """Pauses execution for a certain number of milliseconds."""
 
-        self.state.print_status(description=f"Waiting for {duration} milliseconds...")
+        description = f"Waiting for {duration} milliseconds..."
+        self.state.print_status(description=description)
 
         wait_message = {
             "kind": "wait",
@@ -54,7 +57,9 @@ def unlock(self):
             "args": {}
         }
 
-        unlock_message = self.broker.wrap_message(unlock_message, priority=9000)
+        unlock_message = self.broker.wrap_message(
+            unlock_message,
+            priority=9000)
         self.broker.publish(unlock_message)
 
     def reboot(self):

farmbot_sidecar_starter_pack/functions/broker.py

@@ -17,8 +17,10 @@
 from datetime import datetime
 import paho.mqtt.client as mqtt
 
+
 class BrokerConnect():
     """Broker connection class."""
+
     def __init__(self, state):
         self.state = state
         self.client = None
@@ -50,7 +52,8 @@ def disconnect(self):
         if self.client is not None:
             self.client.loop_stop()
             self.client.disconnect()
-            self.state.print_status(description="Disconnected from message broker.")
+            description = "Disconnected from message broker."
+            self.state.print_status(description=description)
 
     def wrap_message(self, message, priority=None):
         """Wrap message in CeleryScript format."""
@@ -78,22 +81,31 @@ def publish(self, message):
             rpc = self.wrap_message(rpc)
 
         if rpc["args"]["label"] == "":
-            rpc["args"]["label"] = uuid.uuid4().hex if not self.state.test_env else "test"
+            if self.state.test_env:
+                rpc["args"]["label"] = "test"
+            else:
+                rpc["args"]["label"] = uuid.uuid4().hex
 
         self.state.print_status(description="Publishing to 'from_clients'")
         self.state.print_status(endpoint_json=rpc, update_only=True)
         if self.state.dry_run:
-            self.state.print_status(description="Sending disabled, message not sent.", update_only=True)
+            self.state.print_status(
+                description="Sending disabled, message not sent.",
+                update_only=True)
         else:
             self.listen("from_device", publish_payload=rpc)
 
         response = self.state.last_messages.get("from_device", [])
         if len(response) > 0:
             if response[-1]["kind"] == "rpc_ok":
-                self.state.print_status(description="Success response received.", update_only=True)
+                self.state.print_status(
+                    description="Success response received.",
+                    update_only=True)
                 self.state.error = None
             else:
-                self.state.print_status(description="Error response received.", update_only=True)
+                self.state.print_status(
+                    description="Error response received.",
+                    update_only=True)
                 self.state.error = "RPC error response received."
 
         self.state.last_published = rpc
@@ -131,8 +143,8 @@ def on_message(_client, _userdata, msg):
 
             if diff_only:
                 diff = payload
-                prev_channel_key = path_channel if len(path) > 0 else channel_key
-                last_messages = self.state.last_messages.get(prev_channel_key, [])
+                key = path_channel if len(path) > 0 else channel_key
+                last_messages = self.state.last_messages.get(key, [])
                 if len(last_messages) > 1:
                     current = last_messages[-1]
                     previous = last_messages[-2]
@@ -175,9 +187,15 @@ def stop_listen(self):
 
         self.client.loop_stop()
 
-        self.state.print_status(description="Stopped listening to all message broker channels.")
+        self.state.print_status(
+            description="Stopped listening to all message broker channels.")
 
-    def listen(self, channel="#", duration=None, publish_payload=None, stop_count=1, message_options=None):
+    def listen(self,
+               channel="#",
+               duration=None,
+               publish_payload=None,
+               stop_count=1,
+               message_options=None):
         """Listen to a message broker channel for the provided duration in seconds."""
         publish = publish_payload is not None
         message = (publish_payload or {}).get("body", [{}])[0]
@@ -220,14 +238,16 @@ def listen(self, channel="#", duration=None, publish_payload=None, stop_count=1,
         self.start_listen(channel, message_options)
         if not self.state.test_env:
             if channel == "#":
-                self.state.last_messages = {"#" : []}
+                self.state.last_messages = {"#": []}
             else:
                 self.state.last_messages[channel] = []
         if publish:
-            time.sleep(0.1) # wait for start_listen to be ready
+            time.sleep(0.1)  # wait for start_listen to be ready
             device_id_str = self.state.token["token"]["unencoded"]["bot"]
-            publish_topic =  f"bot/{device_id_str}/from_clients"
-            self.client.publish(publish_topic, payload=json.dumps(publish_payload))
+            publish_topic = f"bot/{device_id_str}/from_clients"
+            self.client.publish(
+                publish_topic,
+                payload=json.dumps(publish_payload))
         self.state.print_status(update_only=True, description="", end="")
         while (datetime.now() - start_time).seconds < duration_seconds:
             self.state.print_status(update_only=True, description=".", end="")
@@ -240,20 +260,26 @@ def listen(self, channel="#", duration=None, publish_payload=None, stop_count=1,
                     continue
                 if len(last_messages) > (stop_count - 1):
                     seconds = (datetime.now() - start_time).seconds
-                    prefix = "Message" if stop_count == 1 else f"{stop_count} messages"
+                    prefix = f"{stop_count} messages"
+                    if stop_count == 1:
+                        prefix = "Message"
+                    description = f"{prefix} received after {seconds} seconds"
                     self.state.print_status(
-                        description=f"{prefix} received after {seconds} seconds",
+                        description=description,
                         update_only=True)
                     break
         if len(self.state.last_messages.get(channel, [])) == 0:
             self.state.print_status(description="", update_only=True)
+            secs = duration_seconds
+            description = f"Did not receive message after {secs} seconds"
             self.state.print_status(
-                description=f"Did not receive message after {duration_seconds} seconds",
+                description=description,
                 update_only=True)
             self.state.error = "Timed out waiting for RPC response."
 
         self.stop_listen()
 
+
 def difference(next_state, prev_state):
     """Find the difference between two states."""
     is_different = False
@@ -267,7 +293,9 @@ def difference(next_state, prev_state):
         prev_value = prev_state[key]
         if next_value != prev_value:
             if isinstance(next_value, dict) and isinstance(prev_value, dict):
-                nested_diff, nested_is_different = difference(next_value, prev_value)
+                nested_diff, nested_is_different = difference(
+                    next_value,
+                    prev_value)
                 if nested_is_different:
                     diff[key] = nested_diff
                     is_different = True

farmbot_sidecar_starter_pack/functions/camera.py

@@ -9,8 +9,10 @@
 
 from .broker import BrokerConnect
 
+
 class Camera():
     """Camera class."""
+
     def __init__(self, state):
         self.broker = BrokerConnect(state)
         self.state = state