Merge pull request #160 from labthings/typing

Add more type hints and mypy

Author: jtc42

.github/workflows/publish.yml

@@ -19,13 +19,13 @@ jobs:
         with:
           python-version: ${{ matrix.python }}
 
-      - name: Install Poetry
-        uses: dschep/install-poetry-action@v1.3
-
-      - name: Set Poetry config
-        run: |
-          poetry config virtualenvs.in-project false
-          poetry config virtualenvs.path ~/.virtualenvs
+      - name: Install and configure Poetry
+        uses: snok/install-poetry@v1.1.1
+        with:
+          version: 1.1.4
+          virtualenvs-create: true
+          virtualenvs-in-project: false
+          virtualenvs-path: ~/.virtualenvs
 
       - name: Install Dependencies
         run: poetry install
@@ -34,6 +34,9 @@ jobs:
         run: poetry run black . --check
         continue-on-error: true
 
+      - name: Analyse with MyPy
+        run: poetry run mypy src
+
       - name: Test with pytest
         run: poetry run pytest
 

.github/workflows/test.yml

@@ -21,13 +21,13 @@ jobs:
         with:
           python-version: ${{ matrix.python }}
 
-      - name: Install Poetry
-        uses: dschep/install-poetry-action@v1.3
-
-      - name: Set Poetry config
-        run: |
-          poetry config virtualenvs.in-project false
-          poetry config virtualenvs.path ~/.virtualenvs
+      - name: Install and configure Poetry
+        uses: snok/install-poetry@v1.1.1
+        with:
+          version: 1.1.4
+          virtualenvs-create: true
+          virtualenvs-in-project: false
+          virtualenvs-path: ~/.virtualenvs
 
       - name: Install Dependencies
         run: poetry install
@@ -36,6 +36,9 @@ jobs:
         run: poetry run black . --check
         continue-on-error: true
 
+      - name: Analyse with MyPy
+        run: poetry run mypy src
+
       - name: Test with pytest
         run: poetry run pytest
 

poetry.lock

@@ -31,6 +31,7 @@ pylint = "^2.6.0"
 sphinx = "^3.2.1"
 sphinx-autoapi = "^1.4.0"
 sphinx-rtd-theme = "^0.5.0"
+mypy = "^0.790"
 
 [tool.black]
 exclude = '(\.eggs|\.git|\.venv)'

pyproject.toml

@@ -51,12 +51,14 @@
     "update_action_progress",
     "update_action_data",
     "ActionKilledException",
+    "marshalling",
     "extensions",
     "views",
     "fields",
     "Schema",
     "json",
     "PropertyView",
     "ActionView",
+    "EventView",
     "op",
 ]

src/labthings/__init__.py

@@ -1,6 +1,7 @@
 import logging
 import threading
-from functools import wraps
+
+from typing import Dict
 
 from ..deque import Deque
 from .thread import ActionThread
@@ -41,7 +42,7 @@ def spawn(self, action: str, function, *args, **kwargs):
         self.start(thread)
         return thread
 
-    def kill(self, timeout=5):
+    def kill(self, timeout: int = 5):
         """
 
         :param timeout:  (Default value = 5)
@@ -73,7 +74,7 @@ def states(self):
         """
         return {str(t.id): t.state for t in self.threads}
 
-    def to_dict(self):
+    def to_dict(self) -> Dict[str, ActionThread]:
         """
 
 
@@ -84,8 +85,8 @@ def to_dict(self):
         """
         return {str(t.id): t for t in self.threads}
 
-    def get(self, task_id):
-        return self.to_dict.get(task_id, None)
+    def get(self, task_id: str):
+        return self.to_dict().get(task_id, None)
 
     def discard_id(self, task_id):
         """

src/labthings/actions/pool.py

@@ -8,6 +8,8 @@
 from flask import copy_current_request_context, has_request_context, request
 from werkzeug.exceptions import BadRequest
 
+from typing import Optional, Iterable, Dict, Any, Callable
+
 from ..deque import LockableDeque
 from ..utilities import TimeoutTracker
 
@@ -25,12 +27,12 @@ class ActionThread(threading.Thread):
 
     def __init__(
         self,
-        action,
-        target=None,
-        name=None,
-        args=None,
-        kwargs=None,
-        daemon=True,
+        action: str,
+        target: Optional[Callable] = None,
+        name: Optional[str] = None,
+        args: Optional[Iterable[Any]] = None,
+        kwargs: Optional[Dict[str, Any]] = None,
+        daemon: bool = True,
         default_stop_timeout: int = 5,
         log_len: int = 100,
     ):
@@ -39,34 +41,32 @@ def __init__(
             group=None,
             target=target,
             name=name,
-            args=args,
-            kwargs=kwargs,
+            args=args or (),
+            kwargs=kwargs or {},
             daemon=daemon,
         )
 
-        # Safely populate missing arguments
-        args = args or ()
-        kwargs = kwargs or {}
-
         # Action resource corresponding to this action object
         self.action = action
 
         # A UUID for the ActionThread (not the same as the threading.Thread ident)
         self._ID = uuid.uuid4()  # Task ID
 
         # Event to track if the task has started
-        self.started = threading.Event()
+        self.started: threading.Event = threading.Event()
         # Event to track if the user has requested stop
-        self.stopping = threading.Event()
-        self.default_stop_timeout = default_stop_timeout
+        self.stopping: threading.Event = threading.Event()
+        self.default_stop_timeout: int = default_stop_timeout
 
         # Make _target, _args, and _kwargs available to the subclass
-        self._target = target
-        self._args = args
-        self._kwargs = kwargs
+        self._target: Optional[Callable] = target
+        self._args: Iterable[Any] = args or ()
+        self._kwargs: Dict[str, Any] = kwargs or {}
 
         # Nice string representation of target function
-        self.target_string = f"{self._target}(args={self._args}, kwargs={self._kwargs})"
+        self.target_string: str = (
+            f"{self._target}(args={self._args}, kwargs={self._kwargs})"
+        )
 
         # copy_current_request_context allows threads to access flask current_app
         if has_request_context():
@@ -82,14 +82,14 @@ def __init__(
 
         # Private state properties
         self._status: str = "pending"  # Task status
-        self._return_value = None  # Return value
-        self._request_time = datetime.datetime.now()
-        self._start_time = None  # Task start time
-        self._end_time = None  # Task end time
+        self._return_value: Optional[Any] = None  # Return value
+        self._request_time: datetime.datetime = datetime.datetime.now()
+        self._start_time: Optional[datetime.datetime] = None  # Task start time
+        self._end_time: Optional[datetime.datetime] = None  # Task end time
 
         # Public state properties
-        self.progress: int = None  # Percent progress of the task
-        self.data = {}  # Dictionary of custom data added during the task
+        self.progress: Optional[int] = None  # Percent progress of the task
+        self.data: dict = {}  # Dictionary of custom data added during the task
         self._log = LockableDeque(
             None, log_len
         )  # The log will hold dictionary objects with log information
@@ -100,14 +100,14 @@ def __init__(
         )  # Lock obtained while self._target is running
 
     @property
-    def id(self):
+    def id(self) -> uuid.UUID:
         """
         UUID for the thread. Note this not the same as the native thread ident.
         """
         return self._ID
 
     @property
-    def output(self):
+    def output(self) -> Any:
         """
         Return value of the Action function. If the Action is still running, returns None.
         """
@@ -119,7 +119,7 @@ def log(self):
             return list(logdeque)
 
     @property
-    def status(self):
+    def status(self) -> str:
         """
         Current running status of the thread.
 
@@ -136,19 +136,19 @@ def status(self):
         return self._status
 
     @property
-    def dead(self):
+    def dead(self) -> bool:
         """
         Has the thread finished, by any means (return, exception, termination).
         """
         return not self.is_alive()
 
     @property
-    def stopped(self):
+    def stopped(self) -> bool:
         """Has the thread been cancelled"""
         return self.stopping.is_set()
 
     @property
-    def cancelled(self):
+    def cancelled(self) -> bool:
         """Alias of `stopped`"""
         return self.stopped
 
@@ -162,7 +162,7 @@ def update_progress(self, progress: int):
         # Update progress of the task
         self.progress = progress
 
-    def update_data(self, data: dict):
+    def update_data(self, data: Dict[Any, Any]):
         """
 
         :param data: dict:
@@ -183,7 +183,7 @@ def run(self):
             # an argument that has a member that points to the thread.
             del self._target, self._args, self._kwargs
 
-    def _thread_proc(self, f):
+    def _thread_proc(self, f: Callable):
         """Wraps the target function to handle recording `status` and `return` to `state`.
         Happens inside the task thread.
 
@@ -228,7 +228,7 @@ def wrapped(*args, **kwargs):
 
         return wrapped
 
-    def get(self, block=True, timeout=None):
+    def get(self, block: bool = True, timeout: Optional[int] = None):
         """Start waiting for the task to finish before returning
 
         :param block:  (Default value = True)
@@ -275,7 +275,7 @@ def _async_raise(self, exc_type):
                 % (exc_type, self.name, self.ident, result)
             )
 
-    def _is_thread_proc_running(self):
+    def _is_thread_proc_running(self) -> bool:
         """Test if thread funtion (_thread_proc) is running,
         by attemtping to acquire the lock _thread_proc acquires at runtime.
 
@@ -285,13 +285,13 @@ def _is_thread_proc_running(self):
         :rtype: bool
 
         """
-        could_acquire = self._running_lock.acquire(0)
+        could_acquire = self._running_lock.acquire(False)
         if could_acquire:
             self._running_lock.release()
             return False
         return True
 
-    def terminate(self, exception=ActionKilledException):
+    def terminate(self, exception=ActionKilledException) -> bool:
         """
 
         :param exception:  (Default value = ActionKilledException)
@@ -314,7 +314,7 @@ def terminate(self, exception=ActionKilledException):
         self.progress = None
         return True
 
-    def stop(self, timeout=None, exception=ActionKilledException):
+    def stop(self, timeout=None, exception=ActionKilledException) -> bool:
         """Sets the threads internal stopped event, waits for timeout seconds for the
         thread to stop nicely, then forcefully kills the thread.
 

src/labthings/actions/thread.py

@@ -1,7 +1,7 @@
 import re
 
-from apispec import BasePlugin
-from apispec.ext.marshmallow import MarshmallowPlugin as _MarshmallowPlugin
+from apispec import BasePlugin  # type: ignore
+from apispec.ext.marshmallow import MarshmallowPlugin as _MarshmallowPlugin  # type: ignore
 from apispec.ext.marshmallow import OpenAPIConverter
 from flask.views import http_method_funcs