updated period time trigger to use the date from

the first argument as the default date for the 3rd
argument if it is just a time

Author: craigbarratt

custom_components/pyscript/__init__.py

@@ -572,7 +572,7 @@ def glob_read_files(
         for global_ctx_name, global_ctx in ctx_all.items():
             if global_ctx_name not in ctx2files:
                 ctx_delete.add(global_ctx_name)
-        # delete all global_ctxs that have changeed source or mtime
+        # delete all global_ctxs that have changed source or mtime
         for global_ctx_name, src_info in ctx2files.items():
             if global_ctx_name in ctx_all:
                 ctx = ctx_all[global_ctx_name]

custom_components/pyscript/trigger.py

@@ -136,15 +136,15 @@ def init(cls, hass):
         cls.hass = hass
 
         def wait_until_factory(ast_ctx):
-            """Return wapper to call to astFunction with the ast context."""
+            """Return wrapper to call to astFunction with the ast context."""
 
             async def wait_until_call(*arg, **kw):
                 return await cls.wait_until(ast_ctx, *arg, **kw)
 
             return wait_until_call
 
         def user_task_create_factory(ast_ctx):
-            """Return wapper to call to astFunction with the ast context."""
+            """Return wrapper to call to astFunction with the ast context."""
 
             async def user_task_create(func, *args, **kwargs):
                 """Implement task.create()."""
@@ -610,6 +610,7 @@ async def parse_date_time(cls, date_time_str, day_offset, now, startup_time):
         year = now.year
         month = now.month
         day = now.day
+        fixed_date = False
 
         dt_str_orig = dt_str = date_time_str.strip().lower()
         #
@@ -623,6 +624,7 @@ async def parse_date_time(cls, date_time_str, day_offset, now, startup_time):
             else:
                 month, day = int(match0[1]), int(match0[2])
             day_offset = 0  # explicit date means no offset
+            fixed_date = True
             dt_str = dt_str[len(match0.group(0)) :]
         elif match1:
             skip = True
@@ -632,11 +634,17 @@ async def parse_date_time(cls, date_time_str, day_offset, now, startup_time):
                     day_offset = dow - (now.isoweekday() % 7)
                 else:
                     day_offset = 7 + dow - (now.isoweekday() % 7)
+                fixed_date = True
             elif match1[1] == "today":
                 day_offset = 0
+                fixed_date = True
             elif match1[1] == "tomorrow":
                 day_offset = 1
+                fixed_date = True
             else:
+                if match1[1] == "now":
+                    day_offset = 0
+                    fixed_date = True
                 skip = False
             if skip:
                 dt_str = dt_str[len(match1.group(0)) :]
@@ -649,7 +657,7 @@ async def parse_date_time(cls, date_time_str, day_offset, now, startup_time):
             now = dt.datetime(year, month, day)
         dt_str = dt_str.strip()
         if len(dt_str) == 0:
-            return now
+            return now, fixed_date
 
         #
         # parse the time
@@ -682,7 +690,7 @@ async def parse_date_time(cls, date_time_str, day_offset, now, startup_time):
             except Exception:
                 _LOGGER.warning("'%s' not defined at this latitude", dt_str)
                 # return something in the past so it is ignored
-                return now - dt.timedelta(days=100)
+                return now - dt.timedelta(days=100), fixed_date
             now += time_sun.date() - now.date()
             hour, mins, sec = time_sun.hour, time_sun.minute, time_sun.second
         elif dt_str.startswith("noon"):
@@ -707,7 +715,7 @@ async def parse_date_time(cls, date_time_str, day_offset, now, startup_time):
         dt_str = dt_str.strip()
         if len(dt_str) > 0:
             now = now + dt.timedelta(seconds=parse_time_offset(dt_str))
-        return now
+        return now, fixed_date
 
     @classmethod
     async def timer_active_check(cls, time_spec, now, startup_time):
@@ -737,8 +745,8 @@ async def timer_active_check(cls, time_spec, now, startup_time):
                     _LOGGER.error("Invalid range expression: %s", exc)
                     return False
 
-                start = await cls.parse_date_time(dt_start.strip(), 0, now, startup_time)
-                end = await cls.parse_date_time(dt_end.strip(), 0, start, startup_time)
+                start, _ = await cls.parse_date_time(dt_start.strip(), 0, now, startup_time)
+                end, _ = await cls.parse_date_time(dt_end.strip(), 0, start, startup_time)
 
                 if start <= end:
                     this_match = start <= now <= end
@@ -802,20 +810,20 @@ async def timer_trigger_next(cls, time_spec, now, startup_time):
                     next_time_adj = now + delta
 
             elif len(match1) == 3:
-                this_t = await cls.parse_date_time(match1[1].strip(), 0, now, startup_time)
+                this_t, _ = await cls.parse_date_time(match1[1].strip(), 0, now, startup_time)
                 day_offset = (now - this_t).days + 1
                 if day_offset != 0 and this_t != startup_time:
                     #
                     # Try a day offset (won't make a difference if spec has full date)
                     #
-                    this_t = await cls.parse_date_time(match1[1].strip(), day_offset, now, startup_time)
+                    this_t, _ = await cls.parse_date_time(match1[1].strip(), day_offset, now, startup_time)
                 startup = now == this_t and now == startup_time
                 if (now < this_t or startup) and (next_time is None or this_t < next_time):
                     next_time_adj = next_time = this_t
 
             elif len(match2) == 5:
                 start_str, period_str = match2[1].strip(), match2[2].strip()
-                start = await cls.parse_date_time(start_str, 0, now, startup_time)
+                start, fixed_date_start = await cls.parse_date_time(start_str, 0, now, startup_time)
                 period = parse_time_offset(period_str)
                 if period <= 0:
                     _LOGGER.error("Invalid non-positive period %s in period(): %s", period, time_spec)
@@ -832,12 +840,17 @@ async def timer_trigger_next(cls, time_spec, now, startup_time):
                             next_time_adj = next_time = this_t
                     continue
                 end_str = match2[3].strip()
-                end = await cls.parse_date_time(end_str, 0, now, startup_time)
-                end_offset = 1 if end < start else 0
-                for day in [-1, 0, 1]:
-                    start = await cls.parse_date_time(start_str, day, now, startup_time)
-                    end = await cls.parse_date_time(end_str, day + end_offset, now, startup_time)
-                    if now < start or (now == start and now == startup_time):
+                end, fixed_date_end = await cls.parse_date_time(end_str, 0, now, startup_time)
+                if not fixed_date_start and not fixed_date_end:
+                    end_offset = 1 if end < start else 0
+                    day_dither = [-1, 0, 1]
+                else:
+                    end_offset = 0
+                    day_dither = [0]
+                for day in day_dither:
+                    start, _ = await cls.parse_date_time(start_str, day, now, startup_time)
+                    end, _ = await cls.parse_date_time(end_str, day + end_offset, now, startup_time)
+                    if (now < start or (now == start and now == startup_time)) and start <= end:
                         if next_time is None or start < next_time:
                             next_time_adj = next_time = start
                         break

tests/test_unit_trigger.py

@@ -89,7 +89,7 @@ async def test_parse_date_time(hass, caplog):
     ):
         for test_data in parseDateTimeTests:
             spec, date_offset, expect = test_data
-            out = await TrigTime.parse_date_time(spec, date_offset, now, now)
+            out, _ = await TrigTime.parse_date_time(spec, date_offset, now, now)
             assert out == expect
     await Function.waiter_sync()
     await Function.waiter_stop()
@@ -128,7 +128,7 @@ async def test_parse_date_time_day_names(hass, caplog):
     ):
         for test_data in parseDateTimeTestsDayNames:
             spec, date_offset, expect = test_data
-            out = await TrigTime.parse_date_time(spec, date_offset, now, now)
+            out, _ = await TrigTime.parse_date_time(spec, date_offset, now, now)
             assert out == expect
     await Function.waiter_sync()
     await Function.waiter_stop()
@@ -358,6 +358,44 @@ async def test_timer_active_check(hass, spec, now, expected):
             None,
         ],
     ],
+    # see #714 for these two cases - in 1.6.4 and prior, they keep triggering since the
+    # end time is considered tomorrow
+    [
+        ["period(now, 1 hours, 15:00.1)"],
+        [
+            dt(2019, 9, 1, 13, 0, 0, 100000),
+            dt(2019, 9, 1, 14, 0, 0, 100000),
+            dt(2019, 9, 1, 15, 0, 0, 100000),
+            None,
+        ],
+    ],
+    [
+        ["period(now, 1 hours, 10:00)"],
+        [
+            None,
+        ],
+    ],
+    [
+        ["period(now, 1 hours, today 15:01)"],
+        [
+            dt(2019, 9, 1, 13, 0, 0, 100000),
+            dt(2019, 9, 1, 14, 0, 0, 100000),
+            dt(2019, 9, 1, 15, 0, 0, 100000),
+            None,
+        ],
+    ],
+    [
+        ["period(now, 1 hours, 10:00)"],
+        [
+            None,
+        ],
+    ],
+    [
+        ["period(today 11:00, 1 hours, today 10:00)"],
+        [
+            None,
+        ],
+    ],
     [
         ["cron(0 14 * * *)"],
         [