Merge branch 'datetime-testing'

Author: jsl12

appdaemon/adapi.py

@@ -14,8 +14,9 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal, TypeVar, overload
 
-from appdaemon import dependency, utils
+from appdaemon import dependency
 from appdaemon import exceptions as ade
+from appdaemon import utils
 from appdaemon.appdaemon import AppDaemon
 from appdaemon.entity import Entity
 from appdaemon.events import EventCallback
@@ -2979,7 +2980,7 @@ async def run_at(
                 _, 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)
+                start = await self.AD.sched.parse_datetime(start, aware=True)
                 func = functools.partial(
                     self.AD.sched.insert_schedule,
                     name=self.name,
@@ -3069,18 +3070,19 @@ async def run_daily(
 
                 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)
+                func = functools.partial(func, callback, *args, repeat=True, offset=offset)
             case _:
                 func = functools.partial(
                     self.run_every,
-                    start=start,
-                    interval=timedelta(days=1).total_seconds()
+                    callback,
+                    start,
+                    timedelta(days=1).total_seconds(),
+                    *args,
                 )  # fmt: skip
 
+        # Add additional kwargs here
         func = functools.partial(
             func,
-            callback=callback,
-            *args,
             random_start=random_start,
             random_end=random_end,
             pin=pin,

appdaemon/scheduler.py

@@ -619,7 +619,8 @@ async def loop(self):  # noqa: C901
                             time_to_run = timestamp <= self.now
                             args = self.schedule.get(name, {}).get(uuid_, False)
                             if time_to_run and args:
-                                self.logger.debug("Firing scheduled callback %s for '%s'", args["callback"].func.__name__, name)
+                                func = utils.unwrapped(args["callback"])
+                                self.logger.debug("Firing scheduled callback %s for '%s'", func.__name__, name)
                                 await self.exec_schedule(name, args, uuid_)
                         case _:
                             raise ValueError(f"Unknown entry format: {entry}")

appdaemon/utility_loop.py

@@ -265,7 +265,7 @@ async def _loop_iteration_context(self) -> AsyncGenerator[LoopTiming]:
             if self.AD.real_time and timing.timedelta("total") > self.AD.max_utility_skew:
                 self.logger.warning(
                     "Excessive time spent in utility loop: %s, %s in check_app_updates(), %s in other",
-                    timing.get_time_strs()
+                    *timing.get_time_strs()
                 )
                 if self.AD.check_app_updates_profile:
                     self.logger.info("Profile information for Utility Loop")

appdaemon/utils.py

@@ -22,7 +22,8 @@
 from logging import Logger
 from pathlib import Path
 from time import perf_counter
-from typing import TYPE_CHECKING, Any, Callable, Coroutine, Literal, ParamSpec, Protocol, TypeVar
+from typing import (TYPE_CHECKING, Any, Callable, Coroutine, Literal,
+                    ParamSpec, Protocol, TypeVar)
 
 import dateutil.parser
 import pytz
@@ -34,10 +35,8 @@
 from pydantic import BaseModel, ValidationError
 from pytz import BaseTzInfo
 
-from appdaemon.version import (
-    __version__,  # noqa: F401
-    __version_comments__,  # noqa: F401
-)
+from appdaemon.version import __version__  # noqa: F401
+from appdaemon.version import __version_comments__  # noqa: F401
 
 from . import exceptions as ade
 
@@ -609,6 +608,7 @@ def parse_datetime(
             pass
         case time():
             result = datetime.combine(now.date(), result)
+            result += timedelta(days=days_offset)
         case _:
             raise TypeError(f"Unsupported result type: {result}")
 
@@ -638,6 +638,16 @@ def parse_datetime(
     return result
 
 
+def parse_offset(input_: str) -> timedelta:
+    if m := re.search(r"\s+(?P<sign>[+-])\s+", input_):
+        offset = parse_timedelta(input_[m.span()[1]:])
+        match m.group("sign"):
+            case "-":
+                offset *= -1
+            case "+":
+                pass
+    return offset
+
 def now_is_between(
     now: datetime,
     start_time: str | time | datetime,

tests/unit/conftest.py

@@ -5,11 +5,12 @@
 from functools import partial
 
 import pytest
-from appdaemon import utils
 from astral import LocationInfo
 from astral.location import Location
 from pytz import BaseTzInfo, timezone
 
+from appdaemon import utils
+
 
 @pytest.fixture
 def tz(location: Location) -> BaseTzInfo:

tests/unit/datetime/test_parse_datetime.py

@@ -1,17 +1,140 @@
+import itertools
+import re
 from datetime import date, datetime, timedelta
 from functools import partial
+from typing import Literal
 
 import pytest
-from appdaemon import utils
 from astral import SunDirection
 from astral.location import Location
 from pytz import BaseTzInfo
 
+from appdaemon import utils
+
 pytestmark = [
     pytest.mark.ci,
     pytest.mark.unit,
 ]
 
+hour_params = {
+    "input_": [f"{i:02}:00" for i in range(0, 24, 6)],
+    "aware": [True, False],
+    "today": [True, False]
+}
+hour_params = (tuple(hour_params.keys()), list(itertools.product(*hour_params.values())))
+
+
+offsets = [str(utils.parse_timedelta(t)) for t in [1, timedelta(minutes=30), timedelta(hours=1)]]
+src = {
+    "str_offset": offsets,
+    "sign": [True, False],
+    "today": [True, False],
+    "aware": [True, False],
+}
+sunrise_params = list(itertools.product(*src.values()))
+sunrise_params = (
+    (f"sunrise {'+' if sign else '-'} {offset}", today, aware)
+    for offset, sign, today, aware in sunrise_params
+)
+sunrise_params = (("input_", "today", "aware"), list(sunrise_params))
+
+offsets = [timedelta(seconds=1), timedelta(minutes=1), timedelta(hours=1.5)]
+offsets = [td.total_seconds() for td in offsets]
+offsets = [(n * s) for n, s in itertools.product(offsets, [1, -1])]
+offsets = sorted(offsets)
+
+sun_params = itertools.product(["sunrise", "sunset"], offsets)
+sun_params = {
+    "now_str": ["early", "midday", "late"],
+    "when": ["today", "next"],
+    "input_": [f'{type_} {'+' if str_offset > 0 else '-'} {utils.parse_timedelta(abs(str_offset))}' for type_, str_offset in sun_params],
+}
+
+class TestParseDatetime:
+    @pytest.mark.parametrize(*hour_params)
+    def test_parse_hour(
+        self,
+        input_: str,
+        aware: bool,
+        today: bool,
+        default_now: datetime,
+        parser: partial[datetime],
+    ) -> None:
+        result = parser(input_, aware=aware, today=today)
+        if default_now.time() > result.time():
+            if not today:
+                assert result.date() == (default_now + timedelta(days=1)).date()
+                return
+
+        assert result.date() == default_now.date()
+
+    @pytest.mark.parametrize(tuple(sun_params.keys()), itertools.product(*sun_params.values()))
+    def test_parse_sun_offsets(
+        self,
+        now_str: str,
+        input_: str,
+        when: Literal["today", "next"],
+        default_now: datetime,
+        location: Location,
+        parser: partial[datetime],
+    ) -> None:
+        today_sunrise = location.sunrise(date=default_now.date(), local=True)
+        assert today_sunrise.isoformat() == "2025-06-20T05:25:07.925165-04:00"
+
+        tomorrow_sunrise = location.sunrise(date=(default_now + timedelta(days=1)).date(), local=True)
+        assert tomorrow_sunrise.isoformat() == "2025-06-21T05:25:20.585440-04:00"
+
+        today_sunset = location.sunset(date=default_now.date(), local=True)
+        assert today_sunset.isoformat() == "2025-06-20T20:30:19.662056-04:00"
+
+        tomorrow_sunset = location.sunset(date=(default_now + timedelta(days=1)).date(), local=True)
+        assert tomorrow_sunset.isoformat() == "2025-06-21T20:30:31.933561-04:00"
+
+        match now_str:
+            case "early":
+                now = default_now.replace(hour=3)
+            case "midday":
+                now = default_now.replace(hour=12)
+            case "late":
+                now = default_now.replace(hour=23)
+
+        parser.keywords["now"] = now
+
+        if when == "today":
+            parser.keywords["today"] = True
+
+        result = parser(input_, location=location, aware=True)
+        assert result.tzinfo is not None
+
+        type_ = input_.split()[0]
+        offset = utils.parse_offset(input_)
+
+        match now_str, when, type_:
+            case (_, "today", "sunrise"):
+                assert result == (today_sunrise + offset)
+            case (_, "today", "sunset"):
+                assert result == (today_sunset + offset)
+
+            case ("early", _, "sunrise"):
+                assert result == (today_sunrise + offset)
+            case ("midday" | "late", _, "sunrise"):
+                assert result == (tomorrow_sunrise + offset)
+
+            case ("early" | "midday", _, "sunset"):
+                assert result == (today_sunset + offset)
+            case ("late", "next", "sunset"):
+                assert result == (tomorrow_sunset + offset)
+
+            case _:
+                # This makes sure all the cases get handled.
+                assert False
+
+        match when:
+            case "today":
+                assert result.date() == now.date()
+            case "next":
+                assert result > now
+
 
 def test_time_parse(default_now: datetime, parser: partial[datetime]) -> None:
     test_time = default_now.replace(hour=20)
@@ -210,3 +333,5 @@ def test_exact_sun_event(default_date: date, location: Location, tz: BaseTzInfo)
     today_sunset = location.sunset(date=default_date, local=True)
     next_sunset = parser("sunset", now=today_sunset)
     assert next_sunset.date() != default_date, "Next sunset should be tomorrow"
+    assert next_sunset.date() != default_date, "Next sunset should be tomorrow"
+    assert next_sunset.date() != default_date, "Next sunset should be tomorrow"