Address linting and formatting issues from Ruff (#1)

Author: carlos-sarmiento

.vscode/settings.json

@@ -1,7 +1,6 @@
 {
-    "python.analysis.typeCheckingMode": "basic",
+    "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
     "python.terminal.activateEnvironment": true,
-
     "[python]": {
         "editor.insertSpaces": true,
         "editor.tabSize": 4,
@@ -10,5 +9,5 @@
         "editor.codeActionsOnSave": {
             "source.organizeImports": true
         },
-    }
+    },
 }

Dockerfile

@@ -10,4 +10,6 @@ COPY domovoy ./domovoy
 
 ENV PYTHONPATH /usr/src/app:${PYTHONPATH}
 
+WORKDIR /config
+
 CMD [ "python", "/usr/src/app/domovoy/cli.py", "--config", "/config/config.yml" ]

README.md

@@ -1,5 +1,12 @@
 # Domovoy
 
+## How to run
+
+```bash
+poetry install
+python domovoy/cli.py --config config.yml
+```
+
 Missing Docs
 
 ## Basic App Template with Config
@@ -31,6 +38,7 @@ class AppName(AppBase[EmptyAppConfig]):
 ```
 
 ## How to register an app
+
 ```python
 from domovoy.applications.registration import register_app
 
@@ -45,6 +53,7 @@ register_app(
 ```
 
 ## Register multiple instances of the same AppType
+
 ```python
 from domovoy.applications.registration import register_app_multiple
 
@@ -68,4 +77,3 @@ register_app_multiple(
     configs=apps_to_register,
 )
 ```
-

domovoy/applications/registration.py

@@ -52,7 +52,7 @@ def register_app(
     logging_config_name: str | None = None,
     ignore: bool = False,
 ) -> None:
-    """Registers an app in the current running instance of the Domovy App Engine.
+    """Register an app in the current running instance of the Domovy App Engine.
 
     Args:
     ----
@@ -72,7 +72,7 @@ def register_app(
     if mod is None:
         _logcore.error(
             "Error when trying to retrieve the module which called register_app for app {app_name}."
-            + " App wasn't registered",
+            " App wasn't registered",
             app_name=app_name,
         )
         return
@@ -82,7 +82,7 @@ def register_app(
     if not app_file_path.endswith(f"{get_main_config().app_suffix}.py"):
         get_logger(mod.__name__).error(
             "Attempting to register an app from a regular python file {path}."
-            + " Apps should be registered only in files that end in {suffix}.py",
+            " Apps should be registered only in files that end in {suffix}.py",
             path=app_file_path,
             suffix=get_main_config().app_suffix,
         )
@@ -106,8 +106,7 @@ def register_app_multiple(
     logging_config_name: str | None = None,
     ignore: Literal[True, False] = False,
 ) -> None:
-    """Registers a group of apps in the current running instance of the Domovy App Engine, with each one using its own
-      config.
+    """Register a group of apps in the current running instance of the Domovy App Engine, each one using its own config.
 
     Args:
     ----
@@ -126,7 +125,7 @@ def register_app_multiple(
     if mod is None:
         _logcore.error(
             "Error when trying to retrieve the module which called register_app for apps {app_names}."
-            + " Apps weren't registered",
+            " Apps weren't registered",
             app_name=configs.keys(),
         )
         return
@@ -136,7 +135,7 @@ def register_app_multiple(
     if not app_file_path.endswith(f"{get_main_config().app_suffix}.py"):
         get_logger(mod.__name__).error(
             "Attempting to register apps from a regular python file {path}."
-            + " Apps should be registered only in files that end in {suffix}.py",
+            " Apps should be registered only in files that end in {suffix}.py",
             path=app_file_path,
             suffix=get_main_config().app_suffix,
         )

domovoy/applications/types.py

@@ -11,22 +11,16 @@ class Interval:
     milliseconds: float = 0
 
     def is_valid(self) -> bool:
-        """Checks if an interval has a non-zero duration.
+        """Check if an interval has a non-zero duration.
 
         Returns
         -------
             bool: True if at least one of the fields of the interval is non-zero.
         """
-        return (
-            self.days != 0
-            or self.hours != 0
-            or self.minutes != 0
-            or self.seconds != 0
-            or self.milliseconds != 0
-        )
+        return self.days != 0 or self.hours != 0 or self.minutes != 0 or self.seconds != 0 or self.milliseconds != 0
 
     def to_timedelta(self) -> datetime.timedelta:
-        """Converts the interval to a datetime.timedelta.
+        """Convert the interval to a datetime.timedelta.
 
         Returns
         -------
@@ -41,14 +35,10 @@ def to_timedelta(self) -> datetime.timedelta:
         )
 
     def total_seconds(self) -> float:
-        """The total duration of the interval in fractional seconds.
+        """Get the total duration of the interval in fractional seconds.
 
         Returns
         -------
             float: The total duration of the interval.
         """
-        return (
-            ((self.days * 24 + self.hours) * 60 + self.minutes) * 60
-            + self.seconds
-            + (self.milliseconds / 1000)
-        )
+        return ((self.days * 24 + self.hours) * 60 + self.minutes) * 60 + self.seconds + (self.milliseconds / 1000)

domovoy/core/app_infra.py

@@ -4,7 +4,7 @@
 import datetime
 import inspect
 import logging
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Coroutine
 from dataclasses import dataclass, field
 from enum import StrEnum
 from typing import Any, Concatenate, ParamSpec, TypeVar
@@ -13,15 +13,16 @@
 from apscheduler.triggers.base import BaseTrigger
 
 from domovoy.applications import AppBase, AppConfigBase, EmptyAppConfig
+from domovoy.core.configuration import get_main_config
 from domovoy.core.context import (
     context_callback_id,
     context_logger,
     inside_log_callback,
 )
 from domovoy.core.errors import (
-    DomovoyException,
-    DomovoyLogOnlyOnDebugWhenUncaughtException,
-    DomovoyUnknownPluginException,
+    DomovoyError,
+    DomovoyLogOnlyOnDebugWhenUncaughtError,
+    DomovoyUnknownPluginError,
 )
 from domovoy.core.logging import get_logger
 from domovoy.core.utils import get_callback_name, set_callback_true_information
@@ -86,7 +87,7 @@ class AppWrapper:
     class_name: str
     status: AppStatus
     logger: logging.LoggerAdapter[Any]
-    app: AppBase[Any] = EmptyAppBase()
+    app: AppBase[Any] = field(default_factory=lambda: EmptyAppBase())
     scheduler_callbacks: dict[str, SchedulerCallbackRegistration] = field(
         default_factory=dict,
     )
@@ -97,8 +98,9 @@ def get_pluginx(self, plugin_type: type[T], name: str | None = None) -> T:
         plugin = self.get_plugin(plugin_type, name)
 
         if plugin is None:
-            raise DomovoyUnknownPluginException(
-                f"Unknown plugin of type: {plugin_type}",
+            msg = f"Unknown plugin of type: {plugin_type}"
+            raise DomovoyUnknownPluginError(
+                msg,
             )
 
         return plugin
@@ -112,22 +114,22 @@ def get_plugin(self, plugin_type: type[T], name: str | None = None) -> T | None:
         if name is not None:
             if name not in plugins:
                 return None
-            else:
-                return plugins[name]  # type: ignore
+
+            return plugins[name]  # type: ignore[generaltypeissues]
 
         total_plugins = len(plugins)
 
         if total_plugins == 0:
-            raise DomovoyException(
-                f"There are no plugins registered for type {plugin_type.__name__}",
-            )
-        elif total_plugins >= 2:
-            raise DomovoyException(
+            msg = f"There are no plugins registered for type {plugin_type.__name__}"
+            raise DomovoyError(msg)
+        if total_plugins >= 2:
+            msg = (
                 f"There are multiple plugins registered for type {plugin_type.__name__}."
-                + " You need to include the name of the plugin instance you require",
+                " You need to include the name of the plugin instance you require",
             )
-        else:
-            return next(iter(plugins.values()))  # type: ignore
+            raise DomovoyError(msg)
+
+        return next(iter(plugins.values()))  # type: ignore[generaltypeissues]
 
     def register_plugin(self, plugin: AppPlugin, name: str) -> None:
         plugin_type = type(plugin)
@@ -152,26 +154,26 @@ def prepare_all_plugins(self) -> None:
                 p.post_prepare()
 
     def handle_exception_and_logging(
-        self, true_callback: Callable,
+        self,
+        true_callback: Callable,
     ) -> Callable[
-        [Callable[Concatenate[TStrOrInt, P], Awaitable[None]]],
-        Callable[Concatenate[TStrOrInt, P], Awaitable[None]],
+        [Callable[Concatenate[TStrOrInt, P], Coroutine[Any, Any, None]]],
+        Callable[Concatenate[TStrOrInt, P], Coroutine[Any, Any, None]],
     ]:
         def inner_handle_exception_and_logging(
-            func: Callable[Concatenate[TStrOrInt, P], Awaitable[None]],
-        ) -> Callable[Concatenate[TStrOrInt, P], Awaitable[None]]:
+            func: Callable[Concatenate[TStrOrInt, P], Coroutine[Any, Any, None]],
+        ) -> Callable[Concatenate[TStrOrInt, P], Coroutine[Any, Any, None]]:
             async def wrapper(
-                callback_id: TStrOrInt, *args: P.args, **kwargs: P.kwargs,
+                callback_id: TStrOrInt,
+                *args: P.args,
+                **kwargs: P.kwargs,
             ) -> None:
-                if inside_log_callback.get():
-                    logger = _logcore
-                else:
-                    logger = self.logger
+                logger = _logcore if inside_log_callback.get() else self.logger
 
                 if self.status != AppStatus.RUNNING:
                     _logcore.warning(
                         "Tried to call {function_name} on app `{app_name}` when app's status was `{status}`."
-                        + " -- args: {pargs} -- kwargs: {pkwargs}",
+                        " -- args: {pargs} -- kwargs: {pkwargs}",
                         app_name=self.app_name,
                         status=self.status,
                         function_name=func.__name__,
@@ -191,9 +193,9 @@ async def wrapper(
                 )
 
                 try:
-                    self.scheduler_callbacks
                     await asyncio.create_task(
-                        func(callback_id, *args, **kwargs), name=get_callback_name(true_callback),  # type: ignore
+                        func(callback_id, *args, **kwargs),
+                        name=get_callback_name(true_callback),
                     )
 
                 except asyncio.exceptions.CancelledError as e:
@@ -203,7 +205,7 @@ async def wrapper(
                         app_name=self.app_name,
                     )
 
-                except DomovoyLogOnlyOnDebugWhenUncaughtException as e:
+                except DomovoyLogOnlyOnDebugWhenUncaughtError as e:
                     logger.debug(
                         "Debug Log only Uncaught Exception",
                         e,
@@ -225,31 +227,37 @@ async def wrapper(
         return inner_handle_exception_and_logging
 
     def __get_callback_registration(
-        self, callback_id: str | int,
+        self,
+        callback_id: str | int,
     ) -> CallbackRegistration | None:
         if isinstance(callback_id, int):
             return None
 
         if callback_id.startswith("event-"):
             return self.event_callbacks.get(callback_id, None)
-        elif callback_id.startswith("scheduler-"):
+
+        if callback_id.startswith("scheduler-"):
             return self.scheduler_callbacks.get(callback_id, None)
-        elif callback_id.startswith("ephemeral_callback"):
-            return None
-        else:
-            self.logger.error(
-                "Tried to load invalid callback_id `{callback_id}` from callback registrations",
-                callback_id=callback_id,
-            )
+
+        if callback_id.startswith("ephemeral_callback"):
             return None
 
+        self.logger.error(
+            "Tried to load invalid callback_id `{callback_id}` from callback registrations",
+            callback_id=callback_id,
+        )
+        return None
+
     TReturn = TypeVar("TReturn")
 
     def instrument_app_callback(
-        self, callback: Callable[P, None | Awaitable[None]],
+        self,
+        callback: Callable[P, None | Awaitable[None]],
     ) -> Callable[Concatenate[str | int, P], Awaitable[None]]:
         async def instrumented_call(
-            callback_id: str | int, *args: P.args, **kwargs: P.kwargs,
+            callback_id: str | int,
+            *args: P.args,
+            **kwargs: P.kwargs,
         ) -> None:
             try:
                 self.__callback_called(callback_id)
@@ -268,10 +276,10 @@ def __callback_called(self, callback_id: str | int) -> None:
 
         if registration:
             registration.times_called += 1
-            registration.last_call_datetime = datetime.datetime.now()
+            registration.last_call_datetime = datetime.datetime.now(tz=get_main_config().get_timezone())
 
     def __callback_failed(self, callback_id: str | int) -> None:
         registration = self.__get_callback_registration(callback_id)
 
         if registration:
-            registration.last_error_datetime = datetime.datetime.now()
+            registration.last_error_datetime = datetime.datetime.now(tz=get_main_config().get_timezone())