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

wiederverwendbar/task_manger/trigger.py

@@ -1,24 +1,43 @@
+import threading
 from abc import ABC, abstractmethod
-from datetime import datetime, timedelta
-from typing import Optional
+from datetime import datetime as _datetime, timedelta
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from wiederverwendbar.task_manger.task import Task
 
 
 class Trigger(ABC):
     def __init__(self):
-        self.manager = None
+        self.lock = threading.Lock()
+        self._task = None
 
-    @abstractmethod
-    def init(self, manager):
+    def __str__(self):
+        return f"{self.__class__.__name__}()"
+
+    def __call__(self):
+        if self.task is None:
+            raise ValueError(f"Trigger {self} is not assigned to a task.")
+        return self.check()
+
+    def manager_added(self) -> None:
         ...
 
+    def manager_removed(self) -> None:
+        ...
+
+    @property
+    def task(self) -> Optional["Task"]:
+        return self._task
+
     @abstractmethod
-    def next(self, *args, **kwargs) -> datetime:
+    def check(self) -> bool:
         ...
 
 
 class Interval(Trigger):
     def __init__(self,
-                 seconds: int = 0,
+                 seconds: float = 0,
                  minutes: int = 0,
                  hours: int = 0,
                  days: int = 0,
@@ -27,30 +46,18 @@ class Interval(Trigger):
                  years: int = 0):
         super().__init__()
 
-        self.interval: Optional[int] = None
-        self.seconds: int = seconds
-        self.minutes: int = minutes
-        self.hours: int = hours
-        self.days: int = days
-        self.weeks: int = weeks
-        self.months: int = months
-        self.years: int = years
-
-    def init(self, manager):
-        self.manager = manager
-
-        # calculate interval in seconds
-        self.interval = self.seconds
-        self.interval += self.minutes * 60
-        self.interval += self.hours * 60 * 60
-        self.interval += self.days * 60 * 60 * 24
-        self.interval += self.weeks * 60 * 60 * 24 * 7
-        self.interval += self.months * 60 * 60 * 24 * 30
-        self.interval += self.years * 60 * 60 * 24 * 365
+        # calculate the interval in seconds
+        self._interval = float(seconds)
+        self._interval += minutes * 60
+        self._interval += hours * 60 * 60
+        self._interval += days * 60 * 60 * 24
+        self._interval += weeks * 60 * 60 * 24 * 7
+        self._interval += months * 60 * 60 * 24 * 30
+        self._interval += years * 60 * 60 * 24 * 365
 
     def __str__(self):
         interval = self.interval
-        interval_str = "Every "
+        interval_str = f"{self.__class__.__name__}(Every "
         if interval >= 60 * 60 * 24 * 365:
             years = interval // (60 * 60 * 24 * 365)
             interval_str += f"{years}y "
@@ -77,24 +84,40 @@ class Interval(Trigger):
             interval -= minutes * 60
         if interval > 0:
             interval_str += f"{interval}s "
-        interval_str = interval_str.strip()
+        interval_str = interval_str.strip() + ")"
         return interval_str
 
     def __int__(self):
+        return round(self.interval)
+
+    def __float__(self):
         return self.interval
 
     def __add__(self, other):
         if isinstance(other, (Interval, int, float)):
-            return Interval(seconds=int(self) + int(other))
-        else:
-            raise ValueError(f"Can't add Interval and '{type(other)}'.")
+            return Interval(seconds=float(self) + float(other))
+        raise ValueError("Only Interval, int and float are supported.")
 
-    def next(self, last: datetime) -> datetime:
-        return last + timedelta(seconds=int(self))
+    @property
+    def interval(self) -> float:
+        with self.lock:
+            return self._interval
+
+    @interval.setter
+    def interval(self, value: float):
+        with self.lock:
+            self._interval = value
+
+    def check(self) -> bool:
+        if self.task.last_run is None:
+            return True
+        if _datetime.now() - self.task.last_run > timedelta(seconds=self.interval):
+            return True
+        return False
 
 
 class EverySeconds(Interval):
-    def __init__(self, seconds: int):
+    def __init__(self, seconds: float):
         super().__init__(seconds=seconds)
 
 
@@ -135,28 +158,80 @@ class At(Trigger):
                  hour: Optional[int] = None,
                  day: Optional[int] = None,
                  month: Optional[int] = None,
-                 year: Optional[int] = None,
-                 delay_for_seconds: int = 0,
-                 delay_for_minutes: int = 0,
-                 delay_for_hours: int = 0,
-                 delay_for_days: int = 0):
+                 year: Optional[int] = None):
         super().__init__()
 
-        self.second: Optional[int] = second
-        self.minute: Optional[int] = minute
-        self.hour: Optional[int] = hour
-        self.day: Optional[int] = day
-        self.month: Optional[int] = month
-        self.year: Optional[int] = year
-        self.delay_for_seconds: int = delay_for_seconds
-        self.delay_for_minutes: int = delay_for_minutes
-        self.delay_for_hours: int = delay_for_hours
-        self.delay_for_days: int = delay_for_days
-
-    def init(self, manager):
-        self.manager = manager
-
-        # check if some of the values are set
+        self._second: Optional[int] = second
+        self._minute: Optional[int] = minute
+        self._hour: Optional[int] = hour
+        self._day: Optional[int] = day
+        self._month: Optional[int] = month
+        self._year: Optional[int] = year
+
+    @property
+    def second(self) -> Optional[int]:
+        with self.lock:
+            return self._second
+
+    @second.setter
+    def second(self, value: Optional[int]):
+        with self.lock:
+            self._second = value
+
+    @property
+    def minute(self) -> Optional[int]:
+        with self.lock:
+            return self._minute
+
+    @minute.setter
+    def minute(self, value: Optional[int]):
+        with self.lock:
+            self._minute = value
+
+    @property
+    def hour(self) -> Optional[int]:
+        with self.lock:
+            return self._hour
+
+    @hour.setter
+    def hour(self, value: Optional[int]):
+        with self.lock:
+            self._hour = value
+
+    @property
+    def day(self) -> Optional[int]:
+        with self.lock:
+            return self._day
+
+    @day.setter
+    def day(self, value: Optional[int]):
+        with self.lock:
+            self._day = value
+
+    @property
+    def month(self) -> Optional[int]:
+        with self.lock:
+            return self._month
+
+    @month.setter
+    def month(self, value: Optional[int]):
+        with self.lock:
+            self._month = value
+
+    @property
+    def year(self) -> Optional[int]:
+        with self.lock:
+            return self._year
+
+    @year.setter
+    def year(self, value: Optional[int]):
+        with self.lock:
+            self._year = value
+
+    def manager_added(self) -> None:
+        super().manager_added()
+
+        # check if some values are set
         if not any([self.second is not None, self.minute is not None, self.hour is not None, self.day is not None, self.month is not None, self.year is not None]):
             raise ValueError("At least one of the values must be set.")
 
@@ -179,108 +254,215 @@ class At(Trigger):
         if self.year is not None:
             at_str += f"year {self.year:04} "
         if self.month is not None:
-            if at_str:
+            if at_str != "At ":
                 at_str += "and "
             at_str += f"month {self.month:02} "
         if self.day is not None:
-            if at_str:
+            if at_str != "At ":
                 at_str += "and "
             at_str += f"day {self.day:02} "
         if self.hour is not None:
-            if at_str:
+            if at_str != "At ":
                 at_str += "and "
             at_str += f"hour {self.hour:02} "
         if self.minute is not None:
-            if at_str:
+            if at_str != "At ":
                 at_str += "and "
             at_str += f"minute {self.minute:02} "
         if self.second is not None:
-            if at_str:
+            if at_str != "At ":
                 at_str += "and "
             at_str += f"second {self.second:02} "
         at_str = at_str.strip()
-        return at_str
+        return f"{self.__class__.__name__}({at_str})"
+
+    def check(self) -> bool:
+        next_run = _datetime.now().replace(microsecond=0)
 
-    def next(self) -> datetime:
-        n = datetime.now().replace(microsecond=0)
         second = 0
         if self.second is not None:
             second = self.second
-            second_n = n.replace(second=second)
-            if second_n < n:
-                n += timedelta(minutes=1)
-            n = n.replace(second=second)
+            second_n = next_run.replace(second=second)
+            if second_n < next_run:
+                next_run += timedelta(minutes=1)
+            if self.task.last_run is not None:
+                if second_n < self.task.last_run:
+                    next_run += timedelta(minutes=1)
+            next_run = next_run.replace(second=second)
+
         minute = 0
         if self.minute is not None:
             minute = self.minute
-            minute_n = n.replace(minute=minute)
-            if minute_n < n:
-                n += timedelta(hours=1)
-            n = n.replace(minute=minute, second=second)
+            minute_n = next_run.replace(minute=minute)
+            if minute_n < next_run:
+                next_run += timedelta(hours=1)
+            if self.task.last_run is not None:
+                if minute_n < self.task.last_run:
+                    next_run += timedelta(hours=1)
+            next_run = next_run.replace(minute=minute, second=second)
+
         hour = 0
         if self.hour is not None:
             hour = self.hour
-            hour_n = n.replace(hour=hour)
-            if hour_n < n:
-                n += timedelta(days=1)
-            n = n.replace(hour=hour, minute=minute, second=second)
+            hour_n = next_run.replace(hour=hour)
+            if hour_n < next_run:
+                next_run += timedelta(days=1)
+            if self.task.last_run is not None:
+                if hour_n < self.task.last_run:
+                    next_run += timedelta(days=1)
+            next_run = next_run.replace(hour=hour, minute=minute, second=second)
+
         day = 1
         if self.day is not None:
             day = self.day
-            day_n = n.replace(day=day)
-            if day_n < n:
+            day_n = next_run.replace(day=day)
+            if day_n < next_run:
                 while True:
-                    n += timedelta(days=1)
-                    if n.day == day:
+                    next_run += timedelta(days=1)
+                    if next_run.day == day:
                         break
-            n = n.replace(day=day, hour=hour, minute=minute, second=second)
+            if self.task.last_run is not None:
+                if day_n < self.task.last_run:
+                    while True:
+                        next_run += timedelta(days=1)
+                        if next_run.day == day:
+                            break
+            next_run = next_run.replace(day=day, hour=hour, minute=minute, second=second)
+
         month = 1
         if self.month is not None:
             month = self.month
-            month_n = n.replace(month=month)
-            if month_n < n:
+            month_n = next_run.replace(month=month)
+            if month_n < next_run:
                 while True:
-                    n += timedelta(days=1)
-                    if n.month == month:
+                    next_run += timedelta(days=1)
+                    if next_run.month == month:
                         break
-            n = n.replace(month=month, day=day, hour=hour, minute=minute, second=second)
+            if self.task.last_run is not None:
+                if month_n < self.task.last_run:
+                    while True:
+                        next_run += timedelta(days=1)
+                        if next_run.month == month:
+                            break
+            next_run = next_run.replace(month=month, day=day, hour=hour, minute=minute, second=second)
+
         if self.year is not None:
-            n = n.replace(year=self.year, month=month, day=day, hour=hour, minute=minute, second=second)
+            next_run = next_run.replace(year=self.year, month=month, day=day, hour=hour, minute=minute, second=second)
 
-        return n
+        if next_run <= _datetime.now():
+            return True
+        return False
 
 
-class AtNow(At):
-    def init(self, manager):
-        self.manager = manager
+class AtDatetime(Trigger):
+    def __init__(self,
+                 datetime: Optional[_datetime] = None,
+                 delay_for_seconds: int = 0,
+                 delay_for_minutes: int = 0,
+                 delay_for_hours: int = 0,
+                 delay_for_days: int = 0):
+        super().__init__()
+
+        self._datetime = datetime
+        self._delay_for_seconds = delay_for_seconds
+        self._delay_for_minutes = delay_for_minutes
+        self._delay_for_hours = delay_for_hours
+        self._delay_for_days = delay_for_days
+
+    @property
+    def datetime(self) -> Optional[_datetime]:
+        with self.lock:
+            return self._datetime
+
+    @datetime.setter
+    def datetime(self, value: Optional[_datetime]):
+        with self.lock:
+            self._datetime = value
+
+    @property
+    def delay_for_seconds(self) -> int:
+        with self.lock:
+            return self._delay_for_seconds
+
+    @delay_for_seconds.setter
+    def delay_for_seconds(self, value: int):
+        with self.lock:
+            self._delay_for_seconds = value
+
+    @property
+    def delay_for_minutes(self) -> int:
+        with self.lock:
+            return self._delay_for_minutes
+
+    @delay_for_minutes.setter
+    def delay_for_minutes(self, value: int):
+        with self.lock:
+            self._delay_for_minutes = value
+
+    @property
+    def delay_for_hours(self) -> int:
+        with self.lock:
+            return self._delay_for_hours
+
+    @delay_for_hours.setter
+    def delay_for_hours(self, value: int):
+        with self.lock:
+            self._delay_for_hours = value
+
+    @property
+    def delay_for_days(self) -> int:
+        with self.lock:
+            return self._delay_for_days
+
+    @delay_for_days.setter
+    def delay_for_days(self, value: int):
+        with self.lock:
+            self._delay_for_days = value
+
+    def manager_added(self) -> None:
+        super().manager_added()
+
+        if self.datetime is None:
+            raise ValueError("Datetime must be set.")
+        if not isinstance(self.datetime, _datetime):
+            raise ValueError("Datetime must be an instance of datetime.")
+
+        self.datetime = self.datetime + timedelta(seconds=self.delay_for_seconds,
+                                                  minutes=self.delay_for_minutes,
+                                                  hours=self.delay_for_hours,
+                                                  days=self.delay_for_days)
+
+    def check(self) -> bool:
+        if self.task.last_run is None:
+                return True
+        return False
+
+
+class _AtPredefinedDatetime(AtDatetime):
+    def __init__(self,
+                 delay_for_seconds: int = 0,
+                 delay_for_minutes: int = 0,
+                 delay_for_hours: int = 0,
+                 delay_for_days: int = 0):
+        super().__init__(delay_for_seconds=delay_for_seconds,
+                         delay_for_minutes=delay_for_minutes,
+                         delay_for_hours=delay_for_hours,
+                         delay_for_days=delay_for_days)
 
-        now = datetime.now() + timedelta(seconds=self.delay_for_seconds,
-                                         minutes=self.delay_for_minutes,
-                                         hours=self.delay_for_hours,
-                                         days=self.delay_for_days)
-        self.second = now.second
-        self.minute = now.minute
-        self.hour = now.hour
-        self.day = now.day
-        self.month = now.month
-        self.year = now.year
 
-        super().init(manager)
+class AtNow(_AtPredefinedDatetime):
+    def manager_added(self) -> None:
+        self.datetime = _datetime.now()
+        super().manager_added()
 
 
-class AtCreation(At):
-    def init(self, manager):
-        self.manager = manager
+class AtManagerCreation(AtDatetime):
+    def manager_added(self) -> None:
+        self.datetime = self.task.manager.creation_time
+        super().manager_added()
 
-        creation_time = self.manager.creation_time + timedelta(seconds=self.delay_for_seconds,
-                                                               minutes=self.delay_for_minutes,
-                                                               hours=self.delay_for_hours,
-                                                               days=self.delay_for_days)
-        self.second = creation_time.second
-        self.minute = creation_time.minute
-        self.hour = creation_time.hour
-        self.day = creation_time.day
-        self.month = creation_time.month
-        self.year = creation_time.year
 
-        super().init(manager)
+class AtManagerStart(AtDatetime):
+    def manager_added(self) -> None:
+        self.datetime = self.task.manager.start_time
+        super().manager_added()

wiederverwendbar/timer.py

@@ -0,0 +1,61 @@
+import asyncio
+import threading
+import time
+from typing import Union
+
+_TIMERS: dict[str, float] = {}
+_lock = threading.Lock()
+
+
+def timer(name: str, seconds: Union[float, int]) -> bool:
+    global _TIMERS
+
+    seconds = float(seconds)
+
+    if name not in _TIMERS:
+        with _lock:
+            _TIMERS[name] = time.perf_counter() + seconds
+        wait = True
+    else:
+        with _lock:
+            delta = time.perf_counter() - _TIMERS[name]
+        wait = delta < 0
+    if wait:
+        ...
+    else:
+        clear_timer(name=name)
+    return wait
+
+
+def timer_loop(name: str, seconds: Union[float, int], loop_delay: float = 0.001) -> None:
+    while timer(name, seconds):
+        time.sleep(loop_delay)
+
+
+async def timer_loop_async(name: str, seconds: Union[float, int], loop_delay: float = 0.001) -> None:
+    while timer(name, seconds):
+        await asyncio.sleep(loop_delay)
+
+
+def clear_timer(name: str) -> None:
+    global _TIMERS
+    if name in _TIMERS:
+        with _lock:
+            del _TIMERS[name]
+
+
+def clear_all_timers() -> None:
+    global _TIMERS
+    with _lock:
+        _TIMERS = {}
+
+
+if __name__ == '__main__':
+    try:
+        while True:
+            print(time.time())
+            timer_loop("test-loop", 1)
+    except KeyboardInterrupt:
+        ...
+
+    print("end")

wiederverwendbar/typer/app.py

@@ -136,11 +136,15 @@ class Typer(_Typer):
         # register the main callback
         self.callback()(self.main_callback)
 
+    @property
+    def title_header(self) -> str:
+        return text2art(self.title)
+
     def main_callback(self, *args, **kwargs):
         ...
 
     def info_command(self) -> Optional[int]:
-        card_body = [text2art(self.title)]
+        card_body = [self.title_header]
         second_section = ""
         if self.description is not None:
             second_section += f"{self.description}"