Linting fixes

Author: rwb27

src/labthings/actions/pool.py

@@ -29,7 +29,7 @@ def start(self, thread: ActionThread):
         self.add(thread)
         thread.start()
 
-    def spawn(self, action: str, function, http_error_lock=None, *args, **kwargs):
+    def spawn(self, action: str, function, *args, http_error_lock=None, **kwargs):
         """
 
         :param function:
@@ -38,11 +38,11 @@ def spawn(self, action: str, function, http_error_lock=None, *args, **kwargs):
 
         """
         thread = ActionThread(
-            action, 
-            target=function, 
-            http_error_lock=http_error_lock, 
-            args=args, 
-            kwargs=kwargs
+            action,
+            target=function,
+            http_error_lock=http_error_lock,
+            args=args,
+            kwargs=kwargs,
         )
         self.start(thread)
         return thread

src/labthings/actions/thread.py

@@ -40,7 +40,7 @@ class ActionThread(threading.Thread):
     * The exception appearing in the logs with a traceback
     * The exception being raised in the background thread.
     However, `HTTPException` subclasses are used in Flask/Werkzeug web apps to
-    return HTTP status codes indicating specific errors, and so merit being 
+    return HTTP status codes indicating specific errors, and so merit being
     handled differently.
 
     Normally, when an Action is initiated, the thread handling the HTTP request
@@ -49,14 +49,14 @@ class ActionThread(threading.Thread):
     in the Action thread before the initiating thread has sent an HTTP response,
     we **don't** want to propagate the error here, but instead want to re-raise
     it in the calling thread.  This will then mean that the HTTP request is
-    answered with the appropriate error code, rather than returning a `201` 
+    answered with the appropriate error code, rather than returning a `201`
     code, along with a description of the task (showing that it was successfully
     started, but also showing that it subsequently failed with an error).
 
-    In order to activate this behaviour, we must pass in a `threading.Lock` 
+    In order to activate this behaviour, we must pass in a `threading.Lock`
     object.  This lock should already be acquired by the request-handling
     thread.  If an error occurs, and this lock is acquired, the exception
-    should not be re-raised until the calling thread has had the chance to deal 
+    should not be re-raised until the calling thread has had the chance to deal
     with it.
     """
 
@@ -70,7 +70,7 @@ def __init__(
         daemon: bool = True,
         default_stop_timeout: int = 5,
         log_len: int = 100,
-        http_error_lock: Optional[threading.Lock] = None
+        http_error_lock: Optional[threading.Lock] = None,
     ):
         threading.Thread.__init__(
             self,
@@ -271,8 +271,6 @@ def wrapped(*args, **kwargs):
                     )
                     logging.error(traceback.format_exc())
                     raise e
-                else:
-                    logging.info(f"Propagating {e} back to request handler")
             except Exception as e:  # skipcq: PYL-W0703
                 self._exception = e
                 logging.error(traceback.format_exc())
@@ -285,7 +283,6 @@ def wrapped(*args, **kwargs):
                     self._return_value = str(self._exception)
                     self._status = "error"
 
-
         return wrapped
 
     def get(self, block: bool = True, timeout: Optional[int] = None):

src/labthings/views/__init__.py

@@ -217,10 +217,14 @@ def dispatch_request(self, *args, **kwargs):
         pool = (
             current_labthing().actions if current_labthing() else self._emergency_pool
         )
-        error_lock = threading.RLock() # This indicates that we'll handle errors for now
+        # We pass in this lock to tell the Action thread that we'll deal
+        # with HTTP errors in this thread
+        error_lock = threading.RLock()
         with error_lock:
             # Make a task out of the views `post` method
-            task = pool.spawn(self.endpoint, meth, *args, http_error_lock=error_lock, **kwargs)
+            task = pool.spawn(
+                self.endpoint, meth, *args, http_error_lock=error_lock, **kwargs
+            )
             # Optionally override the threads default_stop_timeout
             if self.default_stop_timeout is not None:
                 task.default_stop_timeout = self.default_stop_timeout
@@ -234,7 +238,6 @@ def dispatch_request(self, *args, **kwargs):
             except TimeoutError:
                 pass
 
-
         # If the action returns quickly, and returns a valid Response, return it as-is
         if task.output and isinstance(task.output, ResponseBase):
             return self.represent_response((task.output, 200))

tests/test_action_api.py

@@ -43,27 +43,24 @@ def test_action_abort(thing_with_some_views, client):
     r = client.post("/AbortAction")
     assert r.status_code == 418
 
+
 @pytest.mark.filterwarnings("ignore:Exception in thread")
 def test_action_abort_late(thing_with_some_views, client, caplog):
     """Check HTTPExceptions raised late are just regular errors."""
     caplog.set_level(logging.ERROR)
     caplog.clear()
     r = client.post("/AbortAction", data=json.dumps({"abort_after": 0.2}))
-    assert r.status_code == 201 # Should have started OK
+    assert r.status_code == 201  # Should have started OK
     time.sleep(0.3)
     # Now check the status - should be error
     r2 = client.get(r.get_json()["links"]["self"]["href"])
     assert r2.get_json()["status"] == "error"
     # Check it was logged as well
     error_was_raised = False
     for r in caplog.records:
-        if (
-            r.levelname == "ERROR"
-            and "HTTPException" in r.message
-        ):
+        if r.levelname == "ERROR" and "HTTPException" in r.message:
             error_was_raised = True
     assert error_was_raised
-        
 
 
 def test_action_validate(thing_with_some_views, client):