started tests and reworked datetime parsing and timer resetting

Author: jsl12

appdaemon/adapi.py

@@ -2506,7 +2506,7 @@ async def parse_datetime(
             2019-08-16 06:33:17
         """
         return await self.AD.sched.parse_datetime(
-            time_str=time_str,
+            input_=time_str,
             name=name or self.name,
             aware=aware,
             today=today,
@@ -2551,10 +2551,10 @@ async def now_is_between(self, start_time: str, end_time: str, now: str) -> bool
     @utils.sync_decorator
     async def now_is_between(
         self,
-        start_time: str | dt.datetime,
-        end_time: str | dt.datetime,
+        start_time: str | dt.time | dt.datetime,
+        end_time: str | dt.time | dt.datetime,
         name: str | None = None,
-        now: str | None = None,
+        now: dt.datetime | None = None,
     ) -> bool:
         """Determine if the current `time` is within the specified start and end times.
 
@@ -2590,7 +2590,7 @@ async def now_is_between(
             >>>     #do something
 
         """
-        return await self.AD.sched.now_is_between(start_time, end_time, name or self.name, now)
+        return await self.AD.sched.now_is_between(start_time=start_time, end_time=end_time, now=now)
 
     @utils.sync_decorator
     async def sunrise(self, aware: bool = False, today: bool = False, days_offset: int = 0) -> dt.datetime:
@@ -2791,7 +2791,7 @@ async def run_in(
             callback: Function that will be called after the specified delay. It must conform to the standard scheduler
                 callback format documented `here <APPGUIDE.html#scheduler-callbacks>`__.
             delay (str, int, float, datetime.timedelta): Delay before the callback is executed. Numbers will be
-                interpreted as seconds. Strings can be in the format of ``HH:MM``, ``HH:MM:SS``, or
+                interpreted as seconds. Strings can be in the format of ``SS``, ``MM:SS``, ``HH:MM:SS``, or
                 ``DD days, HH:MM:SS``. If a ``timedelta`` object is given, it will be used as is.
             *args: Arbitrary positional arguments to be provided to the callback function when it is triggered.
             random_start (int, optional): Start of range of the random time.
@@ -2822,9 +2822,8 @@ async def run_in(
 
 
         """
-        delay = delay if isinstance(delay, timedelta) else utils.parse_timedelta(delay)
-        assert isinstance(delay, timedelta), f"Invalid delay: {delay}"
-        self.logger.debug(f"Registering run_in in {delay.total_seconds():.1f}s for {self.name}")
+        delay = utils.parse_timedelta(delay)
+        self.logger.debug(f"Registering run_in in {utils.format_timedelta(delay)} for {self.name}")
         exec_time = (await self.get_now()) + delay
         sched_func = functools.partial(callback, *args, **kwargs)
         return await self.AD.sched.insert_schedule(
@@ -2911,7 +2910,7 @@ async def run_once(
     async def run_at(
         self,
         callback: Callable,
-        start: str | dt.time | dt.datetime | None = None,
+        start: str | dt.time | dt.datetime,
         *args,
         random_start: int | None = None,
         random_end: int | None = None,
@@ -2948,49 +2947,55 @@ async def run_at(
             Run at 10:30am today, or 10:30am tomorrow if it is already after 10:30am.
 
             >>> def delayed_callback(self, **kwargs): ...  # example callback
-            >>> handle = self.run_once(self.delayed_callback, datetime.time(10, 30, 0))
+            >>> handle = self.run_at(self.delayed_callback, datetime.time(10, 30, 0))
 
             Run today at 04:00pm using the `parse_time()` function.
 
             >>> def delayed_callback(self, **kwargs): ...  # example callback
-            >>> handle = self.run_once(self.delayed_callback, "04:00:00 PM")
+            >>> handle = self.run_at(self.delayed_callback, "04:00:00 PM")
 
             Run at sunset.
 
             >>> def delayed_callback(self, **kwargs): ...  # example callback
-            >>> handle = self.run_once(self.delayed_callback, "sunset")
+            >>> handle = self.run_at(self.delayed_callback, "sunset")
 
             Run an hour after sunrise.
 
             >>> def delayed_callback(self, **kwargs): ...  # example callback
-            >>> handle = self.run_once(self.delayed_callback, "sunrise + 01:00:00")
+            >>> handle = self.run_at(self.delayed_callback, "sunrise + 01:00:00")
 
         """
+        start = "now" if start is None else start
         match start:
-            case str():
-                info = await self.AD.sched._parse_time(start, self.name)
-                start = info["datetime"]
-            case dt.time():
-                if start.tzinfo is None:
-                    start = start.replace(tzinfo=self.AD.tz)
-                date = await self.date()
-                start = dt.datetime.combine(date, start)
-            case dt.datetime():
-                ...
-            case _:
-                raise ValueError("Invalid type for start")
-
-        self.logger.debug("Registering run_at at %s for %s", start, self.name)
+            case str() as start_str if start.startswith("sun"):
+                if start.startswith("sunrise"):
+                    func = self.run_at_sunrise
+                elif start.startswith("sunset"):
+                    func = self.run_at_sunset
+                else:
+                    raise ValueError(f"Invalid sun event: {start_str}")
 
-        return await self.AD.sched.insert_schedule(
-            name=self.name,
-            aware_dt=start,
+                now = await self.get_now() # type: ignore
+                _, offset = utils.parse_time_str(start_str, now=now, location=self.AD.sched.location)
+                func = functools.partial(func, *args, repeat=True, offset=offset)
+            case _:
+                start = await self.AD.sched.parse_datetime(start)
+                func = functools.partial(
+                    self.AD.sched.insert_schedule,
+                    name=self.name,
+                    aware_dt=start,
+                    interval=timedelta(days=1).total_seconds()
+                )  # fmt: skip
+
+        func = functools.partial(
+            func,
             callback=functools.partial(callback, *args, **kwargs),
             random_start=random_start,
             random_end=random_end,
             pin=pin,
             pin_thread=pin_thread,
         )
+        return await func()  # type: ignore
 
     @utils.sync_decorator
     async def run_daily(
@@ -3052,36 +3057,37 @@ async def run_daily(
             >>> handle = self.run_daily(self.daily_callback, "sunset + 01:00:00")
 
         """
-        offset = 0
-        sun: Literal["sunrise", "sunset"] | None = None
+        start = "now" if start is None else start
         match start:
-            case str():
-                info = await self.AD.sched._parse_time(start, self.name)
-                start, offset, sun = info["datetime"], info["offset"], info["sun"]
-            case dt.time():
-                if start.tzinfo is None:
-                    start = start.replace(tzinfo=self.AD.tz)
-                date = await self.date()
-                start = dt.datetime.combine(date, start)
-            case dt.datetime():
-                ...
-            case _:
-                raise ValueError("Invalid type for start")
+            case str() as start_str if start.startswith("sun"):
+                if start.startswith("sunrise"):
+                    func = self.run_at_sunrise
+                elif start.startswith("sunset"):
+                    func = self.run_at_sunset
+                else:
+                    raise ValueError(f"Invalid sun event: {start_str}")
 
-        ad_kwargs = dict(
+                now = await self.get_now() # type: ignore
+                _, offset = utils.parse_time_str(start_str, now=now, location=self.AD.sched.location)
+                func = functools.partial(func, *args, repeat=True, offset=offset)
+            case _:
+                func = functools.partial(
+                    self.run_every,
+                    start=start,
+                    interval=timedelta(days=1).total_seconds()
+                )  # fmt: skip
+
+        func = functools.partial(
+            func,
+            callback=callback,
+            *args,
             random_start=random_start,
             random_end=random_end,
             pin=pin,
             pin_thread=pin_thread,
-        )
-
-        match sun:
-            case None:
-                return await self.run_every(callback, start, timedelta(days=1), *args, **ad_kwargs, **kwargs)
-            case "sunrise":
-                return await self.run_at_sunrise(callback, *args, repeat=True, offset=offset, **ad_kwargs, **kwargs)
-            case "sunset":
-                return await self.run_at_sunset(callback, *args, repeat=True, offset=offset, **ad_kwargs, **kwargs)
+            **kwargs
+        )  # fmt: skip
+        return await func() # type: ignore
 
     @utils.sync_decorator
     async def run_hourly(
@@ -3211,7 +3217,7 @@ async def run_every(
         self,
         callback: Callable,
         start: str | dt.time | dt.datetime | None = None,
-        interval: str | int | float | dt.timedelta = 0,
+        interval: str | int | float | timedelta = 0,
         *args,
         random_start: int | None = None,
         random_end: int | None = None,
@@ -3298,31 +3304,12 @@ def timed_callback(self, **kwargs): ...  # example callback
 
         """
         interval = utils.parse_timedelta(interval)
-        assert isinstance(interval, dt.timedelta)
-
-        match start:
-            case str():
-                if not start.startswith("now"):
-                    info = await self.AD.sched._parse_time(start, self.name)
-                    start = info["datetime"]
-            case dt.time():
-                if start.tzinfo is None:
-                    start = start.replace(tzinfo=self.AD.tz)
-                date = await self.date()
-                start = dt.datetime.combine(date, start)
-            case dt.datetime():
-                ...
-            case None:
-                pass  # This will be handled by get_next_period
-            case _:
-                raise ValueError("Invalid type for start")
-
         next_period = await self.AD.sched.get_next_period(interval, start)
 
         self.logger.debug(
             "Registering %s for run_every in %s intervals, starting %s",
             callback.__name__,
-            interval,
+            utils.format_seconds(interval),
             next_period,
         )
 
@@ -3344,7 +3331,7 @@ async def run_at_sunset(
         callback: Callable,
         *args,
         repeat: bool = True,
-        offset: int | None = None,
+        offset: str | int | float | timedelta | None = None,
         random_start: int | None = None,
         random_end: int | None = None,
         pin: bool | None = None,
@@ -3417,7 +3404,7 @@ async def run_at_sunrise(
         callback: Callable,
         *args,
         repeat: bool = True,
-        offset: int | None = None,
+        offset: str | int | float | timedelta | None = None,
         random_start: int | None = None,
         random_end: int | None = None,
         pin: bool | None = None,
@@ -3468,7 +3455,7 @@ async def run_at_sunrise(
             >>> self.run_at_sunrise(self.sun, random_start = -60*60, random_end = 30*60)
 
         """
-        sunrise = await self.AD.sched.sunrise(today=False, aware=True)
+        sunrise = await self.AD.sched.next_sunrise()
         td = utils.parse_timedelta(offset)
         self.logger.debug(f"Registering run_at_sunrise at {sunrise + td} with {args}, {kwargs}")
         return await self.AD.sched.insert_schedule(

appdaemon/models/internal/scheduler.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from functools import partial
+from typing import Literal
+
+
+@dataclass(slots=True)
+class ScheduleEntry:
+    name: str
+    """Name of the app that registered the callback"""
+    id: str
+    """Unique identifier (handle) for the scheduled callback"""
+    callback: partial = field(repr=False)
+    """Callable to be executed when the callback is triggered"""
+    basetime: datetime
+    """Base time for the callback, without any offset applied"""
+    timestamp: datetime
+    """The resolved time when the callback will be executed, including any offset"""
+    offset: float | None = None
+    """Offset in seconds to be applied to the base time"""
+    interval: float | None = None
+    """Time interval in seconds between executions when it's being restarted"""
+    repeat: bool = False
+    """Whether the callback should be restarted after execution"""
+    type: Literal["next_rising", "next_setting"] | None = None
+    pin_app: bool | None = None
+    pin_thread: int | None = None
+    kwargs: dict = field(default_factory=dict)
+
+    random_start: float | None = None
+    random_end: float | None = None