wiederverwendbar 0.9.0__py3-none-any.whl → 0.9.2__py3-none-any.whl

wiederverwendbar/__init__.py

@@ -1,6 +1,6 @@
 __title__ = "wiederverwendbar"
 __description__ = "A collection of scripts, classes and tools they are \\\"wiederverwendbar\\\"."
-__version__ = "0.9.0"
+__version__ = "0.9.2"
 __author__ = "Julius Koenig"
 __author_email__ = "info@bastelquartier.de"
 __license__ = "GPL-3.0"

wiederverwendbar/branding/settings.py

@@ -22,13 +22,15 @@ class BrandingSettings(BaseModel):
         main_module = sys.modules["__main__"]
         module_data = self.get_attributes(main_module.__dict__)
         if module_data is None:
-            init_file = Path(main_module.__file__).parent / "__init__.py"
-            if init_file.is_file():
-                init_file_module_spec = importlib.util.spec_from_file_location("__main__.__init__", init_file)
-                init_file_module = importlib.util.module_from_spec(init_file_module_spec)
-                sys.modules["__main__.__init__"] = init_file_module
-                init_file_module_spec.loader.exec_module(init_file_module)
-                module_data = self.get_attributes(init_file_module.__dict__)
+            # ToDO: this code is not working for pyprojects.toml [project.scripts]
+            if hasattr(main_module, "__file__"):
+                init_file = Path(main_module.__file__).parent / "__init__.py"
+                if init_file.is_file():
+                    init_file_module_spec = importlib.util.spec_from_file_location("__main__.__init__", init_file)
+                    init_file_module = importlib.util.module_from_spec(init_file_module_spec)
+                    sys.modules["__main__.__init__"] = init_file_module
+                    init_file_module_spec.loader.exec_module(init_file_module)
+                    module_data = self.get_attributes(init_file_module.__dict__)
         if module_data is None:
             module_data = {}
 

wiederverwendbar/fastapi/app.py

@@ -367,7 +367,10 @@ class FastAPI(_FastAPI):
                 "terms_of_service": self.terms_of_service}
 
     async def get_version(self, request: Request) -> dict[str, Any]:
-        return {"version": self.version}
+        version = self.version
+        if version.startswith("v"):
+            version = version[1:]
+        return {"version": version}
 
     async def get_root_redirect(self, request: Request) -> RedirectResponse:
         root_path = request.scope.get("root_path", "").rstrip("/")

wiederverwendbar/sqlalchemy/db.py

@@ -172,13 +172,13 @@ class SqlalchemyDb:
                 else:
                     connection_string += self.password
             if self.host is None:
-                raise RuntimeError(f"No host specified for {self}")
+                raise RuntimeError(f"No host specified for {self.__class__.__name__}")
             connection_string += f"@{self.host}"
             if self.port is None:
-                raise RuntimeError(f"No port specified for {self}")
+                raise RuntimeError(f"No port specified for {self.__class__.__name__}")
             connection_string += f":{self.port}"
             if self.name is None:
-                raise RuntimeError(f"No name specified for {self}")
+                raise RuntimeError(f"No name specified for {self.__class__.__name__}")
             connection_string += f"/{self.name}"
         return connection_string
 

wiederverwendbar/task_manger/__init__.py

@@ -1,4 +1,17 @@
-from wiederverwendbar.task_manger.task_manager import TaskManager
-from wiederverwendbar.task_manger.singleton import ManagerSingleton
-from wiederverwendbar.task_manger.task import Task
-from wiederverwendbar.task_manger.trigger import Interval, EverySeconds, EveryMinutes, EveryHours, EveryDays, EveryWeeks, EveryMonths, EveryYears, At, AtNow, AtCreation
+from wiederverwendbar.task_manger.task_manager import (TaskManager)
+from wiederverwendbar.task_manger.singleton import (ManagerSingleton)
+from wiederverwendbar.task_manger.task import (Task)
+from wiederverwendbar.task_manger.trigger import (Trigger,
+                                                  Interval,
+                                                  EverySeconds,
+                                                  EveryMinutes,
+                                                  EveryHours,
+                                                  EveryDays,
+                                                  EveryWeeks,
+                                                  EveryMonths,
+                                                  EveryYears,
+                                                  At,
+                                                  AtDatetime,
+                                                  AtNow,
+                                                  AtManagerCreation,
+                                                  AtManagerStart)

wiederverwendbar/task_manger/task.py

@@ -1,104 +1,147 @@
-from datetime import datetime
-from typing import Optional
+from datetime import datetime as _datetime
+from enum import Enum
+from typing import Any, Optional, Callable, Union, TYPE_CHECKING
 
-from wiederverwendbar.task_manger.trigger import Trigger, Interval, At
+from wiederverwendbar.functions.is_coroutine_function import is_coroutine_function
+from wiederverwendbar.task_manger.trigger import Trigger
+
+if TYPE_CHECKING:
+    from wiederverwendbar.task_manger.task_manager import TaskManager
 
 
 class Task:
+    class TimeMeasurement(str, Enum):
+        START = "START"
+        END = "END"
+
     def __init__(self,
-                 payload,
-                 manager=None,
+                 payload: Callable[..., None],
+                 *triggers: Trigger,
                  name: Optional[str] = None,
-                 trigger: Optional[Trigger] = None,
-                 time_measurement_before_run: bool = True,
-                 auto_add: Optional[bool] = None,
-                 *args,
-                 **kwargs):
-        # set task name
+                 time_measurement: Optional[TimeMeasurement] = None,
+                 task_args: Optional[Union[list, tuple]] = None,
+                 task_kwargs: Optional[dict] = None):
+        self._manager = None
+
+        # set the task name
         if name is None:
             name = payload.__name__
-        self.name = name
-
-        self.manager = None
-
-        # set task trigger
-        if not isinstance(trigger, (Interval, At)):
-            raise ValueError("Invalid trigger object.")
-        self.trigger = trigger
+        self._name = name
+
+        # set task triggers
+        self._triggers = []
+        for trigger in triggers:
+            if not isinstance(trigger, Trigger):
+                raise ValueError("Trigger must be an instance of Trigger.")
+            if trigger.task is not None:
+                raise ValueError("Trigger already assigned to a task.")
+            trigger._task = self
+            self._triggers.append(trigger)
+        self._triggers = tuple(self._triggers)
 
         # set task payload
         if not callable(payload):
             raise ValueError("Payload must be callable.")
+        if is_coroutine_function(payload):
+            raise ValueError("Coroutine functions are not supported.")
         self._payload = payload
 
+        # indicates when the last run time should be measured
+        if time_measurement is None:
+            time_measurement = self.TimeMeasurement.START
+        if not isinstance(time_measurement, self.TimeMeasurement):
+            raise ValueError("Time measurement must be an instance of TaskTimeMeasurement.")
+        self._time_measurement = time_measurement
+
         # set payload args and kwargs
-        self.args = []
-        self.kwargs = {}
-        if not iter(args):
-            raise ValueError("Args must be iterable.")
-        for arg in args:
-            self.args.append(arg)
-        if not isinstance(kwargs, dict):
-            raise ValueError("Kwargs must be dict.")
-        self.kwargs = kwargs
-
-        self.time_measurement_before_run = time_measurement_before_run
-
-        self._last_run: Optional[datetime] = None
-        self._next_run: Optional[datetime] = None
-
-        # indicate if task is done
+        if task_args is None:
+            task_args = []
+        if not iter(task_args):
+            raise ValueError("Task args must be iterable.")
+        self._task_args = tuple(task_args)
+        if task_kwargs is None:
+            task_kwargs = {}
+        if not isinstance(task_kwargs, dict):
+            raise ValueError("Task kwargs must be dict.")
+        self._task_kwargs = task_kwargs
+
+        # indicate last run
+        self._last_run = None
+
+        # indicate if the task is done
         self._done = False
 
-        # auto add task to manager
-        if auto_add is None:
-            auto_add = True if manager else False
+    def __str__(self):
+        return (f"{self.__class__.__name__}("
+                f"name={self.name}, "
+                f"trigger=[{', '.join([str(trigger) for trigger in self._triggers])}], "
+                f"last_run={self.last_run})")
 
-        if auto_add:
-            if not manager:
-                raise ValueError("Manager object is required.")
-            manager.add_task(self)
+    def __call__(self, *args, **kwargs) -> bool:
+        if self.manager is None:
+            raise ValueError(f"Task {self} is not assigned to a manager.")
+        for trigger in self.triggers:
+            if trigger():
+                return True
+        return False
 
-    def init(self, manager):
-        self.manager = manager
-        self.trigger.init(manager)
-        self.set_next_run()
+    @property
+    def manager(self) -> Optional["TaskManager"]:
+        return self._manager
+
+    @manager.setter
+    def manager(self, manager: "TaskManager") -> None:
+        if manager is None:
+            if self._manager is None:
+                return
+            manager = self._manager
+            with manager.lock:
+                # noinspection PyProtectedMember
+                manager._tasks.remove(self)
+            self.manager_removed()
+        else:
+            if self._manager is not None:
+                raise ValueError(f"Task {self} is already assigned to manager {self._manager}.")
+            self._manager = manager
 
-        # log task creation
-        self.manager.logger.debug(f"Task created.")
+            with manager.lock:
+                # noinspection PyProtectedMember
+                manager._tasks.append(self)
+            self.manager_added()
 
     @property
-    def last_run(self) -> Optional[datetime]:
-        if self._last_run is None:
-            return datetime.fromtimestamp(0)
-        return self._last_run
+    def name(self) -> str:
+        return self._name
 
     @property
-    def next_run(self) -> Optional[datetime]:
-        if self.is_done:
-            return None
-        return self._next_run
+    def triggers(self) -> tuple[Trigger, ...]:
+        return self._triggers
 
     @property
-    def is_done(self) -> bool:
-        return self._done
-
-    def set_next_run(self):
-        if isinstance(self.trigger, Interval):
-            next_run = self.trigger.next(self.last_run)
-        elif isinstance(self.trigger, At):
-            next_run = self.trigger.next()
-            if next_run == self._next_run:
-                self.done()
-        else:
-            raise ValueError("Invalid trigger object.")
-        self._next_run = next_run
+    def time_measurement(self) -> TimeMeasurement:
+        return self._time_measurement
+
+    @property
+    def task_args(self) -> tuple[Any]:
+        return self._task_args
+
+    @property
+    def task_kwargs(self) -> dict[str, Any]:
+        return self._task_kwargs
+
+    @property
+    def last_run(self) -> Optional[_datetime]:
+        return self._last_run
 
-    def set_last_run(self):
-        self._last_run = datetime.now()
+    def manager_added(self) -> None:
+        for trigger in self.triggers:
+            trigger.manager_added()
+        self.manager.logger.debug(f"{self.manager} -> Task {self} added.")
 
-    def done(self):
-        self._done = True
+    def manager_removed(self) -> None:
+        for trigger in self.triggers:
+            trigger.manager_removed()
+        self.manager.logger.debug(f"{self.manager} -> Task {self} removed.")
 
-    def payload(self):
-        self._payload(*self.args, **self.kwargs)
+    def payload(self) -> None:
+        self._payload(*self.task_args, **self.task_kwargs)