add strict rules to mypy

Author: GabrielSalla

docs/monitor.md

@@ -268,7 +268,7 @@ Reactions are defined as a list of **async functions** that are triggered when s
 Below is an example of defining a reaction function that responds to the creation of a new issue:
 
 ```python
-async def reaction_issue_created(event_payload: dict[str, Any]):
+async def reaction_issue_created(event_payload: dict[str, Any]) -> None:
     # Do something
 ```
 

internal_monitors/active_notification_alert_solved/active_notification_alert_solved.py

@@ -68,7 +68,7 @@ def is_solved(issue_data: IssueDataType) -> bool:
 
 # Reactions
 
-async def close_notification(event_payload: dict[str, Any]):
+async def close_notification(event_payload: dict[str, Any]) -> None:
     """Fix the notification by closing it"""
     issue_object = event_payload["event_data"]
     notification = await Notification.get_by_id(issue_object["data"]["notification_id"])

pyproject.toml

@@ -56,10 +56,19 @@ mypy_path = "src"
 ignore_missing_imports = true
 warn_return_any = true
 check_untyped_defs = true
+disallow_any_generics = true
+disallow_incomplete_defs = true
+disallow_subclassing_any = true
+disallow_untyped_calls = true
+disallow_untyped_decorators = true
+disallow_untyped_defs = true
+no_implicit_optional = true
 
 [[tool.mypy.overrides]]
 module = "tests.*"
 disable_error_code = ["arg-type", "empty-body", "misc", "list-item"]
+disallow_incomplete_defs = false
+disallow_untyped_defs = false
 
 [tool.isort]
 src_paths = ["src", "tests"]

src/components/controller/controller.py

@@ -58,7 +58,7 @@ async def diagnostics() -> tuple[dict[str, Any], list[str]]:
     return status, issues
 
 
-async def _queue_task(monitor: Monitor, tasks: list[str]):
+async def _queue_task(monitor: Monitor, tasks: list[str]) -> None:
     """Send a message to the queue with the monitor tasks that should be executed"""
     monitor.set_queued(True)
     await monitor.save()
@@ -80,7 +80,7 @@ async def _queue_task(monitor: Monitor, tasks: list[str]):
         await monitor.save()
 
 
-async def _process_monitor(monitor: Monitor):
+async def _process_monitor(monitor: Monitor) -> None:
     """Check if the monitor triggers any task and queue them if there're any"""
     global last_monitor_processed_at
 
@@ -106,7 +106,7 @@ async def _process_monitor(monitor: Monitor):
     await _queue_task(monitor, tasks)
 
 
-async def _run_task(semaphore: asyncio.Semaphore, monitor: Monitor):
+async def _run_task(semaphore: asyncio.Semaphore, monitor: Monitor) -> None:
     """Keep one of the semaphore's lock while the monitor is being processed"""
     _logger.info(f"Processing monitor {monitor}")
     async with semaphore:
@@ -116,7 +116,7 @@ async def _run_task(semaphore: asyncio.Semaphore, monitor: Monitor):
 async def _create_process_task(
         semaphore: asyncio.Semaphore,
         monitor: Monitor
-) -> asyncio.Task | None:
+) -> asyncio.Task[Any] | None:
     """Create a task to process the monitor"""
     # Instead of registering the monitor, skip if it's not registered yet
     # If processing a monitor that is not yet registered, the executor won't have
@@ -132,7 +132,7 @@ async def _create_process_task(
         return asyncio.create_task(_run_task(semaphore, monitor))
 
 
-async def run():
+async def run() -> None:
     global last_loop_at
     global running
 
@@ -146,7 +146,7 @@ async def run():
     # Queue setup
     semaphore = asyncio.Semaphore(configs.controller_concurrency)
 
-    tasks: list[asyncio.Task] = []
+    tasks: list[asyncio.Task[Any]] = []
 
     while app.running():
         with catch_exceptions(_logger):

src/components/controller/procedures.py

@@ -20,7 +20,7 @@
 SQL_FILES_PATH = Path(__file__).parent / "sql_files"
 
 
-async def _monitors_stuck():
+async def _monitors_stuck() -> None:
     with open(SQL_FILES_PATH / "monitors_stuck.sql") as file:
         query = file.read()
 
@@ -64,14 +64,14 @@ def _check_procedure_triggered(schedule: str, last_execution: datetime | None) -
 async def _execute_procedure(
         procedure_name: str,
         procedure: Callable[[], Coroutine[None, None, None]],
-):
+) -> None:
     """Execute the 'procedure' and update the 'last_executions' variable"""
     with catch_exceptions(logger=_logger):
         await procedure()
     last_executions[procedure_name] = datetime.now()
 
 
-async def run_procedures():
+async def run_procedures() -> None:
     """Check and run all procedures that are triggered"""
     for procedure_name, procedure in procedures.items():
         last_execution = last_executions.get(procedure_name)

src/components/executor/executor.py

@@ -60,7 +60,7 @@ async def diagnostics() -> tuple[dict[str, Any], list[str]]:
     return status, issues
 
 
-async def _change_visibility_loop(message: message_queue.Message):
+async def _change_visibility_loop(message: message_queue.Message) -> None:
     """Change the message visibility while it's been processed"""
     try:
         while app.running():
@@ -71,7 +71,7 @@ async def _change_visibility_loop(message: message_queue.Message):
 
 
 class Executor:
-    task: asyncio.Task
+    task: asyncio.Task[Any]
     _logger: logging.Logger
 
     _handlers = {
@@ -81,10 +81,10 @@ class Executor:
     }
     _current_message_type: str
 
-    def __init__(self, number: int):
+    def __init__(self, number: int) -> None:
         self._logger = logging.getLogger(f"executor_{number}")
 
-    def init(self):
+    def init(self) -> None:
         """Create the internal loop task"""
         self.task = asyncio.create_task(self.run())
 
@@ -115,7 +115,7 @@ async def process_message(
         self,
         handler: Callable[[dict[Any, Any]], Coroutine[Any, Any, Any]],
         message: message_queue.Message
-    ):
+    ) -> None:
         """Process the message with the provided handler, protecting from possible exceptions.
         During the message processing, another task will be spawned to change it's visibility in
         the queue, preventing other messages from processing it too"""
@@ -151,7 +151,7 @@ async def process_message(
             change_visibility_task.cancel()
             await change_visibility_task
 
-    async def process(self):
+    async def process(self) -> None:
         """Get a message and process it"""
         # Wait for the monitors to be ready
         await registry.wait_monitors_ready()
@@ -169,7 +169,7 @@ async def process(self):
 
         await self.process_message(handler, message)
 
-    async def run(self):
+    async def run(self) -> None:
         """Run the executor process continuously, until the application finishes"""
         self._logger.info("Executor running")
 
@@ -180,7 +180,7 @@ async def run(self):
         self._logger.info("Finishing")
 
 
-async def run():
+async def run() -> None:
     global executors
     global running
 

src/components/executor/monitor_handler.py

@@ -71,7 +71,7 @@ def _make_dict_json_compatible(data: Any) -> dict[Any, Any] | None:
     return cast(dict[Any, Any] | None, _convert_types(data))
 
 
-async def _search_routine(monitor: Monitor):
+async def _search_routine(monitor: Monitor) -> None:
     """Search routine for the monitor, executing the 'search' function and processing the returned
     data"""
     found_issues_data = await monitor.search_function()
@@ -154,7 +154,7 @@ async def _search_routine(monitor: Monitor):
     monitor.add_issues(issues)
 
 
-async def _update_routine(monitor: Monitor):
+async def _update_routine(monitor: Monitor) -> None:
     """Update routine for the monitor, executing the 'update' function and processing the returned
     data"""
     # Skip the update routine if there're no active issues
@@ -220,14 +220,14 @@ async def _update_routine(monitor: Monitor):
             await issue.update_data(raw_issue_data, session=session)
 
 
-async def _issues_solve_routine(monitor: Monitor):
+async def _issues_solve_routine(monitor: Monitor) -> None:
     """Issue solve routine for the monitor, checking all issues against the 'is_solved' function"""
     async with get_session() as session:
         for issue in monitor.active_issues:
             await issue.check_solved(session=session)
 
 
-async def _alerts_routine(monitor: Monitor):
+async def _alerts_routine(monitor: Monitor) -> None:
     """Alert routine for the monitor, creating, linking issues, updating and solving them"""
     # As 'alert_options' can be None, check it before executing
     if monitor.alert_options is None:
@@ -260,7 +260,7 @@ async def _alerts_routine(monitor: Monitor):
     await do_concurrently(*[alert.update() for alert in monitor.active_alerts])
 
 
-async def _run_routines(monitor: Monitor, tasks: list[str]):
+async def _run_routines(monitor: Monitor, tasks: list[str]) -> None:
     """Run all routines for a monitor, based on a list of tasks"""
     # Monitor instrumentation metrics
     prometheus_labels = {
@@ -299,7 +299,7 @@ async def _run_routines(monitor: Monitor, tasks: list[str]):
         await _alerts_routine(monitor)
 
 
-async def run(message: dict[Any, Any]):
+async def run(message: dict[Any, Any]) -> None:
     """Process a message with type 'process_monitor', loading the monitor and executing it's
     routines, while also detecting errors and reporting them accordingly"""
     message_payload = message["payload"]

src/components/executor/reaction_handler.py

@@ -31,7 +31,7 @@
 )
 
 
-async def run(message: dict[Any, Any]):
+async def run(message: dict[Any, Any]) -> None:
     """Process a message with type 'event' using the monitor's defined list of reactions for the
     event. The execution timeout is for each function individually"""
     message_payload = message["payload"]

src/components/executor/request_handler.py

@@ -2,7 +2,7 @@
 import json
 import logging
 import traceback
-from typing import Any
+from typing import Any, Callable, Coroutine, cast
 
 import plugins
 import registry as registry
@@ -13,7 +13,7 @@
 _logger = logging.getLogger("request_handler")
 
 
-async def alert_acknowledge(message_payload: dict[Any, Any]):
+async def alert_acknowledge(message_payload: dict[Any, Any]) -> None:
     """Acknowledge an alert"""
     alert_id = message_payload["target_id"]
     alert = await Alert.get_by_id(alert_id)
@@ -24,7 +24,7 @@ async def alert_acknowledge(message_payload: dict[Any, Any]):
     await alert.acknowledge()
 
 
-async def alert_lock(message_payload: dict[Any, Any]):
+async def alert_lock(message_payload: dict[Any, Any]) -> None:
     """Lock an alert"""
     alert_id = message_payload["target_id"]
     alert = await Alert.get_by_id(alert_id)
@@ -35,7 +35,7 @@ async def alert_lock(message_payload: dict[Any, Any]):
     await alert.lock()
 
 
-async def alert_solve(message_payload: dict[Any, Any]):
+async def alert_solve(message_payload: dict[Any, Any]) -> None:
     """Solve all alert's issues"""
     alert_id = message_payload["target_id"]
     alert = await Alert.get_by_id(alert_id)
@@ -46,7 +46,7 @@ async def alert_solve(message_payload: dict[Any, Any]):
     await alert.solve_issues()
 
 
-async def issue_drop(message_payload: dict[Any, Any]):
+async def issue_drop(message_payload: dict[Any, Any]) -> None:
     """Drop an issue"""
     issue_id = message_payload["target_id"]
     issue = await Issue.get_by_id(issue_id)
@@ -65,7 +65,7 @@ async def issue_drop(message_payload: dict[Any, Any]):
 }
 
 
-def get_action(action_name: str):
+def get_action(action_name: str) -> Callable[[dict[Any, Any]], Coroutine[Any, Any, None]] | None:
     """Get the action function by its name, checking if it is a plugin action"""
     if action_name.startswith("plugin."):
         plugin_name, action_name = action_name.split(".")[1:3]
@@ -85,12 +85,12 @@ def get_action(action_name: str):
             _logger.warning(f"Action '{plugin_name}.{action_name}' unknown")
             return None
 
-        return action
+        return cast(Callable[[dict[Any, Any]], Coroutine[Any, Any, None]], action)
 
     return actions.get(action_name)
 
 
-async def run(message: dict[Any, Any]):
+async def run(message: dict[Any, Any]) -> None:
     """Process a received request"""
     message_payload = message["payload"]
     action_name = message_payload["action"]

src/components/http_server/alert_routes.py

@@ -1,4 +1,5 @@
 from aiohttp import web
+from aiohttp.web_request import Request
 from aiohttp.web_response import Response
 
 import external_requests as external_requests
@@ -10,7 +11,7 @@
 
 @alert_routes.post(base_route + "/{alert_id}/acknowledge")
 @alert_routes.post(base_route + "/{alert_id}/acknowledge/")
-async def alert_acknowledge(request) -> Response:
+async def alert_acknowledge(request: Request) -> Response:
     """Route to acknowledge an alert"""
     alert_id = int(request.match_info["alert_id"])
 
@@ -31,7 +32,7 @@ async def alert_acknowledge(request) -> Response:
 
 @alert_routes.post(base_route + "/{alert_id}/lock")
 @alert_routes.post(base_route + "/{alert_id}/lock/")
-async def alert_lock(request) -> Response:
+async def alert_lock(request: Request) -> Response:
     """Route to lock an alert"""
     alert_id = int(request.match_info["alert_id"])
 
@@ -52,7 +53,7 @@ async def alert_lock(request) -> Response:
 
 @alert_routes.post(base_route + "/{alert_id}/solve")
 @alert_routes.post(base_route + "/{alert_id}/solve/")
-async def alert_solve(request) -> Response:
+async def alert_solve(request: Request) -> Response:
     """Route to solve an alert's issues"""
     alert_id = int(request.match_info["alert_id"])