wiederverwendbar 0.9.1__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.1"
+__version__ = "0.9.2"
 __author__ = "Julius Koenig"
 __author_email__ = "info@bastelquartier.de"
 __license__ = "GPL-3.0"

wiederverwendbar/branding/settings.py

@@ -23,13 +23,14 @@ class BrandingSettings(BaseModel):
         module_data = self.get_attributes(main_module.__dict__)
         if module_data is None:
             # ToDO: this code is not working for pyprojects.toml [project.scripts]
-            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 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/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)

wiederverwendbar/task_manger/task_manager.py

@@ -1,57 +1,73 @@
 import logging
 import multiprocessing
 import threading
-import time
-from datetime import datetime
-from typing import Any, Optional
+from datetime import datetime as _datetime
+from enum import Enum
+from typing import Optional, Union, TYPE_CHECKING
 
 from wiederverwendbar.task_manger.task import Task
-from wiederverwendbar.task_manger.trigger import Trigger
+from wiederverwendbar.timer import timer_loop
+
+if TYPE_CHECKING:
+    from wiederverwendbar.task_manger.trigger import Trigger
+
+
+class TaskManagerStates(str, Enum):
+    INITIAL = "INITIAL"
+    RUNNING = "RUNNING"
+    STOPPED = "STOPPED"
+
 
 class TaskManager:
+    class States(str, Enum):
+        INITIAL = "INITIAL"
+        RUNNING = "RUNNING"
+        STOPPED = "STOPPED"
+
     lock = threading.Lock()
 
     def __init__(self,
                  name: Optional[str] = None,
                  worker_count: Optional[int] = None,
                  daemon: bool = False,
-                 keep_done_tasks: bool = False,
                  loop_delay: Optional[float] = None,
-                 logger: Optional[logging.Logger] = None,
-                 log_self: bool = True):
+                 logger: Optional[logging.Logger] = None):
+        self._id = id(self)
         if name is None:
             name = self.__class__.__name__
-        self.name = name
+        self._name = name
         self._workers: list[threading.Thread] = []
         self._tasks: list[Task] = []
-        self._stopped: bool = False
-        self._creation_time: datetime = datetime.now()
-        self._keep_done_tasks = keep_done_tasks
-        self.logger = logger or logging.getLogger(self.name)
+        self._state: TaskManagerStates = TaskManagerStates.INITIAL
+        self._creation_time: _datetime = _datetime.now()
+        self._start_time: Optional[_datetime] = None
+        self.logger = logger or logging.getLogger(self._name)
 
         # create workers
         if worker_count is None:
             worker_count = multiprocessing.cpu_count()
-            if worker_count - 2 < 1:
+            worker_count = round(worker_count / 2)
+            if worker_count < 1:
                 worker_count = 1
-            if worker_count > 4:
-                worker_count = 4
         for i in range(worker_count):
-            worker = threading.Thread(name=f"{self.name}.Worker{i}", target=self.loop, daemon=daemon)
+            worker = threading.Thread(name=f"{self._name}.Worker{i}", target=self.loop, daemon=daemon)
             self._workers.append(worker)
 
         # set loop delay
         if loop_delay is None:
-            if self.worker_count > 1:
+            if self.worker_count >= 1:
                 loop_delay = 0.001
         self._loop_delay = loop_delay
 
+    def __str__(self):
+        return f"{self.__class__.__name__}(name={self._name}, id={self._id}, state={self._state.value})"
+
     def __del__(self):
-        if not self.stopped:
+        if self.state == TaskManagerStates.RUNNING:
             self.stop()
 
     @property
-    def worker_count(self):
+    def worker_count(self) -> int:
         """
         Number of workers.
 
@@ -61,19 +77,18 @@ class TaskManager:
         return len(self._workers)
 
     @property
-    def stopped(self):
+    def state(self) -> TaskManagerStates:
         """
-        Manager stopped flag.
+        Manager state
 
-        :return: bool
+        :return: TaskManagerStates
         """
 
         with self.lock:
-            stopped = self._stopped
-        return stopped
+            return self._state
 
     @property
-    def creation_time(self) -> datetime:
+    def creation_time(self) -> _datetime:
         """
         Manager creation time.
 
@@ -81,8 +96,18 @@ class TaskManager:
         """
 
         with self.lock:
-            creation_time = self._creation_time
-        return creation_time
+            return self._creation_time
+
+    @property
+    def start_time(self) -> Optional[_datetime]:
+        """
+        Manager start time.
+
+        :return: datetime or None
+        """
+
+        with self.lock:
+            return self._start_time
 
     def start(self) -> None:
         """
@@ -91,14 +116,24 @@ class TaskManager:
         :return: None
         """
 
-        self.logger.debug(f"Starting manager ...")
+        if self.state != TaskManagerStates.INITIAL:
+            raise ValueError(f"Manager '{self._name}' is not in state '{TaskManagerStates.INITIAL.value}'.")
+
+        self.logger.debug(f"Starting manager {self} ...")
+
+        with self.lock:
+            self._state = TaskManagerStates.RUNNING
 
         # start workers
         for worker in self._workers:
-            self.logger.debug(f"Starting worker '{worker.name}' ...")
+            self.logger.debug(f"{self} -> Starting worker '{worker.name}' ...")
             worker.start()
 
-        self.logger.debug(f"Manager started.")
+        # set the start time
+        with self.lock:
+            self._start_time = _datetime.now()
+
+        self.logger.debug(f"Manager {self} started.")
 
     def stop(self) -> None:
         """
@@ -107,21 +142,24 @@ class TaskManager:
         :return: None
         """
 
-        self.logger.debug(f"Stopping manager ...")
+        if self.state != TaskManagerStates.RUNNING:
+            raise ValueError(f"Manager {self} is not in state '{TaskManagerStates.RUNNING.value}'.")
+
+        self.logger.debug(f"Stopping manager {self} ...")
 
         # set stopped flag
         with self.lock:
-            self._stopped = True
+            self._state = TaskManagerStates.STOPPED
 
         # wait for workers to finish
         for worker in self._workers:
             if worker.is_alive():
-                self.logger.debug(f"Waiting for worker '{worker.name}' to finish ...")
+                self.logger.debug(f"{self} -> Waiting for worker '{worker.name}' to finish ...")
                 worker.join()
 
-        self.logger.debug(f"Manager stopped.")
+        self.logger.debug(f"Manager {self} stopped.")
 
-    def loop(self, stay_in_loop: Optional[bool] = None) -> None:
+    def loop(self, stay_in_loop: bool = True) -> None:
         """
         Manager loop. All workers run this loop. If worker_count is 0, you can run this loop manually.
 
@@ -129,54 +167,48 @@ class TaskManager:
         :return: None
         """
 
-        if stay_in_loop is None:
-            with self.lock:
-                stay_in_loop = bool(self._loop_delay)
-        while not self.stopped:
-            now = datetime.now()
-            current_task = None
-            with self.lock:
-                for i, task in enumerate(self._tasks):
-                    if task.next_run is None:
-                        continue
-                    if task.next_run > now:
-                        continue
-                    current_task = self._tasks.pop(i)
-                    break
-            if current_task is None:
-                with self.lock:
-                    loop_delay = self._loop_delay
-                if loop_delay:
-                    time.sleep(loop_delay)
-                continue
+        if self.state != TaskManagerStates.RUNNING:
+            raise ValueError(f"Manager {self} is not in state '{TaskManagerStates.RUNNING.value}'.")
 
-            self.logger.debug(f"Running task '{current_task.name}' ...")
+        # check if running in a worker thread
+        with self.lock:
+            if threading.current_thread() not in self._workers:
+                if len(self._workers) > 0:
+                    raise ValueError(f"{self} -> Running manager loop outside of worker thread is not allowed, if worker_count > 0.")
 
+        while self.state == TaskManagerStates.RUNNING:
+            # get the next task from the list
+            task = None
             with self.lock:
-                if current_task.time_measurement_before_run:
-                    current_task.set_last_run()
-                    current_task.set_next_run()
-
-            # run task
-            current_task.payload()
-
-            self.logger.debug(f"Task '{current_task.name}' successfully run.")
+                for i, _task in enumerate(self._tasks):
+                    if not _task():
+                        continue
+                    task = self._tasks.pop(i)
+                    break
 
-            with self.lock:
-                if not current_task.time_measurement_before_run:
-                    current_task.set_last_run()
-                    current_task.set_next_run()
-                if not current_task.is_done:
-                    self._tasks.append(current_task)
-                else:
-                    self.logger.debug(f"Task '{current_task.name}' is done.")
-                    if self._keep_done_tasks:
-                        self._tasks.append(current_task)
+            # if a task to run available, run the task
+            if task is not None:
+                self.logger.debug(f"{self} -> Running task {task} ...")
+                if task.time_measurement == Task.TimeMeasurement.START:
+                    task._last_run = _datetime.now()
+                try:
+                    task.payload()
+                    self.logger.debug(f"{self} -> Task {task} successfully run.")
+                except Exception as e:
+                    self.logger.error(f"{self} -> Task {task} failed: {e}")
+                if task.time_measurement == Task.TimeMeasurement.END:
+                    task._last_run = _datetime.now()
+
+                # put the task back to list
+                with self.lock:
+                    self._tasks.append(task)
 
             if not stay_in_loop:
                 break
+            if self._loop_delay:
+                timer_loop(name=f"{self._name}_{self._id}_LOOP", seconds=self._loop_delay, loop_delay=self._loop_delay)
 
-    def add_task(self, task: Task):
+    def add_task(self, task: Task) -> None:
         """
         Add task to manager.
 
@@ -184,12 +216,9 @@ class TaskManager:
         :return:
         """
 
-        task.init(self)
-        with self.lock:
-            self._tasks.append(task)
-        self.logger.debug(f"Task '{task.name}' added.")
+        task.manager = self
 
-    def remove_task(self, task: Task):
+    def remove_task(self, task: Task) -> None:
         """
         Remove task from manager.
 
@@ -197,40 +226,34 @@ class TaskManager:
         :return:
         """
 
-        with self.lock:
-            self._tasks.remove(task)
-        self.logger.debug(f"Task '{task.name}' removed.")
+        if task.manager is not self:
+            raise ValueError(f"Task {task} is not assigned to manager {self}.")
+        task.manager = None
 
     def task(self,
+             *triggers: "Trigger",
              name: Optional[str] = None,
-             trigger: Optional[Trigger] = None,
-             time_measurement_before_run: bool = True,
-             return_func: bool = True,
-             *args,
-             **kwargs) -> Any:
+             time_measurement: Optional[Task.TimeMeasurement] = None,
+             task_args: Optional[Union[list, tuple]] = None,
+             task_kwargs: Optional[dict] = None):
         """
         Task decorator.
 
+        :param triggers: The trigger of the task.
         :param name: The name of the task.
-        :param trigger: The trigger of the task.
-        :param time_measurement_before_run: Time measurement before run flag.
-        :param return_func: Return function flag. If True, the function will be returned instead of the task.
-        :param args: Args for the task payload.
-        :param kwargs: Kwargs for the task payload.
+        :param time_measurement: Time measurement for the task.
+        :param task_args: Args for the task payload.
+        :param task_kwargs: Kwargs for the task payload.
         :return: Task or function
         """
 
         def decorator(func):
-            task = Task(name=name,
-                        manager=self,
-                        trigger=trigger,
-                        time_measurement_before_run=time_measurement_before_run,
-                        payload=func,
-                        auto_add=True,
-                        *args,
-                        **kwargs)
-            return task if not return_func else func
+            self.add_task(task=Task(func,
+                                    *triggers,
+                                    name=name,
+                                    time_measurement=time_measurement,
+                                    task_args=task_args,
+                                    task_kwargs=task_kwargs))
+            return func
 
         return decorator
-
-