Autogenerated type safety parameterisation of all methods

providers/staticdata/file_download_static_data_provider.py

@@ -1,8 +1,12 @@
+from __future__ import annotations
+
 import logging
 from datetime import datetime
 from threading import Event, Thread
+from typing import Any
 
 import pytz
+from requests import Response
 from requests.exceptions import ConnectionError, ConnectTimeout, ReadTimeout
 
 from core.constants import HTTP_HEADERS
@@ -16,36 +20,36 @@ class FileDownloadStaticDataProvider(StaticDataProvider):
     """Generic static reference data provider class for providers that fetch their data from the web by downloading a
     file."""
 
-    def __init__(self, name, provider_config, url, poll_interval):
+    def __init__(self, name: str, provider_config: dict[str, Any], url: str, poll_interval: float) -> None:
         """Set up the provider, note poll_interval is in *days*."""
         super().__init__(name, provider_config)
         self._url = url
         self._poll_interval = poll_interval
-        self._thread = None
+        self._thread: Thread | None = None
         self._stop_event = Event()
         self._url_data_cache = URLDataCache(f"staticdata_{name}")
 
-    def start(self):
+    def start(self) -> None:
         # Fire off the polling thread. It will poll immediately on startup, then sleep for poll_interval between
         # subsequent polls, so start() returns immediately and the application can continue starting.
         logger.info(f"Set up query of {self.name} static reference data every {self._poll_interval!s} days.")
         self._thread = Thread(target=self._run, name=f"FileDownloadStaticDataProvider-{self.name}", daemon=True)
         self._thread.start()
 
-    def stop(self):
+    def stop(self) -> None:
         self._stop_event.set()
         if self._thread:
             self._thread.join(timeout=12)
             if self._thread.is_alive():
                 logger.warning(f"{self.name} static data worker thread did not exit on time and will be killed.")
 
-    def _run(self):
+    def _run(self) -> None:
         while True:
             self._poll()
             if self._stop_event.wait(timeout=self._poll_interval * 60 * 60 * 24):
                 break
 
-    def _poll(self):
+    def _poll(self) -> None:
         try:
             # Request data from API. Use the data cache (with a TTL of 1 day) here, not as the main mechanism for
             # caching, but just so continual restarts of the software during testing don't hammer the servers.
@@ -76,7 +80,7 @@ class FileDownloadStaticDataProvider(StaticDataProvider):
             logger.exception(f"Exception in HTTP static reference data provider ({self.name})")
             self._stop_event.wait(timeout=1)
 
-    def _handle_http_response(self, http_response):
+    def _handle_http_response(self, http_response: Response) -> bool:
         """Handle an HTTP response returned by the server and load the data from it. Return true if successful,
         false otherwise."""