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

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
-
-