hassl 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

hassl/__init__.py

@@ -1 +1 @@
-__version__ = "0.3.0"
+__version__ = "0.3.2"

hassl/ast/nodes.py

@@ -19,11 +19,43 @@ class IfClause:
     condition: Dict[str, Any]
     actions: List[Dict[str, Any]]
 
+# ---- NEW: Holiday sets & structured schedule windows ----
+@dataclass
+class HolidaySet:
+    id: str
+    country: str
+    province: Optional[str] = None
+    add: List[str] = field(default_factory=list)       # YYYY-MM-DD
+    remove: List[str] = field(default_factory=list)
+    workdays: List[str] = field(default_factory=lambda: ["mon","tue","wed","thu","fri"])
+    excludes: List[str] = field(default_factory=lambda: ["sat","sun","holiday"])
+
+@dataclass
+class PeriodSelector:
+    # kind = 'months' | 'dates' | 'range'
+    kind: str
+    # data:
+    #  - months: {"list":[Mon,...]} or {"range":[Mon,Mon]}
+    #  - dates:  {"start":"MM-DD","end":"MM-DD"}
+    #  - range:  {"start":"YYYY-MM-DD","end":"YYYY-MM-DD"}
+    data: Dict[str, Any]
+
+@dataclass
+class ScheduleWindow:
+    start: str                    # "HH:MM"
+    end: str                      # "HH:MM"
+    day_selector: str             # "weekdays" | "weekends" | "daily"
+    period: Optional[PeriodSelector] = None
+    holiday_ref: Optional[str] = None   # id from HolidaySet (for 'except'/'only')
+    holiday_mode: Optional[str] = None  # "except" | "only" | None
+
 @dataclass
 class Schedule:
     name: str
-    # raw clauses as produced by the transformer, e.g. {"type":"schedule_clause", ...}
+    # raw clauses as produced by the transformer (legacy form)
     clauses: List[Dict[str, Any]]
+    # structured windows for the new 'on ...' syntax (optional)
+    windows: List[ScheduleWindow] = field(default_factory=list)
     private: bool = False
 
 @dataclass
@@ -42,7 +74,8 @@ class Program:
     imports: List[Dict[str, Any]] = field(default_factory=list)    
     def to_dict(self):
         def enc(x):
-            if isinstance(x, (Alias, Sync, Rule, IfClause, Schedule)):
+            if isinstance(x, (Alias, Sync, Rule, IfClause, Schedule,
+                              HolidaySet, ScheduleWindow, PeriodSelector)):
                 d = asdict(x); d["type"] = x.__class__.__name__; return d
             return x
         return {

hassl/codegen/package.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Iterable, Any
+from typing import Dict, List, Iterable, Any, Tuple, Optional
 import os, re
 from dataclasses import dataclass, field
 from ..semantics.analyzer import IRProgram, IRSync
@@ -78,6 +78,13 @@ def _context_entity(entity: str, prop: str = None) -> str:
 def _domain(entity: str) -> str:
     return entity.split(".", 1)[0]
 
+def _gate_entity_for_schedule(resolved: str, is_window: bool) -> str:
+    # resolved is "pkg.name" (your analyzer already normalizes)
+    pkg, name = resolved.rsplit(".", 1) if "." in resolved else ("", resolved)
+    if is_window:
+        return f"input_boolean.hassl_sched_{_safe(pkg)}_{_safe(name)}"
+    return f"binary_sensor.hassl_schedule_{_safe(pkg)}_{_safe(name)}_active"
+
 def _turn_service(domain: str, state_on: bool) -> str:
     if domain in ("light","switch","fan","media_player","cover"):
         return f"{domain}.turn_on" if state_on else f"{domain}.turn_off"
@@ -92,7 +99,8 @@ class ScheduleRegistry:
     pkg: str
     created: Dict[str, str] = field(default_factory=dict)   # name -> entity_id
     sensors: List[Dict] = field(default_factory=list)       # collected template sensors (for YAML)
-
+    period_cache: Dict[Tuple[str,str], str] = field(default_factory=dict)  # (sched, key)-> entity_id
+    
     def eid_for(self, name: str) -> str:
         return f"binary_sensor.hassl_schedule_{self.pkg}_{_safe(name)}_active".lower()
 
@@ -105,6 +113,141 @@ class ScheduleRegistry:
         self.created[name] = eid
         return eid
 
+    # New: create/reuse a period template sensor for a schedule window
+    def ensure_period_sensor(self, sched_name: str, period: Dict[str, Any] | None) -> str | None:
+        if not period:
+            return None
+        key = (sched_name, str(period))
+        if key in self.period_cache:
+            return self.period_cache[key]
+        # Build a compact name with hash for stability
+        eid_name = f"hassl_period_{self.pkg}_{_safe(sched_name)}_{abs(hash(str(period)))%100000}"
+        entity_id = f"binary_sensor.{eid_name}"
+        tpl = _period_template(period)
+        self.sensors.append({"name": eid_name, "unique_id": eid_name, "state": f"{{{{ {tpl} }}}}"})
+        self.period_cache[key] = entity_id
+        return entity_id
+
+# ---------- NEW: window helpers (mirrors rules_min logic) ----------
+def _parse_offset(off: str) -> str:
+    if not off: return "00:00:00"
+    m = re.fullmatch(r"([+-])(\d+)(ms|s|m|h|d)", str(off).strip())
+    if not m: return "00:00:00"
+    sign, n, unit = m.group(1), int(m.group(2)), m.group(3)
+    seconds = {"ms": 0, "s": n, "m": n*60, "h": n*3600, "d": n*86400}[unit]
+    h = seconds // 3600
+    m_ = (seconds % 3600) // 60
+    s = seconds % 60
+    return f"{sign}{h:02d}:{m_:02d}:{s:02d}"
+
+def _wrap_tpl(expr: str) -> str:
+    """Ensure a Jinja expression is wrapped safely in {{ … }}."""
+    expr = expr.strip()
+    if expr.startswith("{{") and expr.endswith("}}"):
+        return expr
+    return "{{ " + expr + " }}"
+
+def _clock_between_cond(hhmm_start: str, hhmm_end: str):
+    # Pure expression (no {% %} / inner {{ }}), safe to embed in {{ ... }}
+    ns = "now().strftime('%H:%M')"
+    s  = hhmm_start
+    e  = hhmm_end
+
+    expr = (
+        f"( ('{s}' < '{e}' and ({ns} >= '{s}' and {ns} < '{e}')) "
+        f"or ('{s}' >= '{e}' and ({ns} >= '{s}' or {ns} < '{e}')) )"
+    )
+    
+    return {
+        "condition": "template",
+        "value_template": _wrap_tpl(expr)
+    }
+
+def _sun_edge_cond(edge: str, ts: dict):
+    event = ts.get("event", "sunrise")
+    off = _parse_offset(ts.get("offset", "0s"))
+    cond = {"condition": "sun", edge: event}
+    if off and off != "00:00:00":
+        cond["offset"] = off
+    return cond
+
+def _window_condition_from_specs(start_ts, end_ts):
+    # clock → clock
+    if isinstance(start_ts, dict) and start_ts.get("kind") == "clock" and \
+       isinstance(end_ts, dict) and end_ts.get("kind") == "clock":
+        s = start_ts.get("value", "00:00")
+        e = end_ts.get("value", "00:00")
+        return _clock_between_cond(s, e)
+    # sun → sun
+    if isinstance(start_ts, dict) and start_ts.get("kind") == "sun" and \
+       isinstance(end_ts, dict) and end_ts.get("kind") == "sun":
+        after_start = _sun_edge_cond("after", start_ts)
+        before_end  = _sun_edge_cond("before", end_ts)
+        wrap = (start_ts.get("event") == "sunset" and end_ts.get("event") == "sunrise")
+        if wrap:
+            return {"condition": "or", "conditions": [after_start, before_end]}
+        return {"condition": "and", "conditions": [after_start, before_end]}
+    # mixed → minute-of-day template (pure expression, no {% %})
+    NOWM = "(now().hour*60 + now().minute)"
+    SM = "(((start.value[0:2]|int)*60 + (start.value[3:5]|int)) if start.kind == 'clock' else (as_local(state_attr('sun.sun','next_' ~ start.event)).hour*60 + as_local(state_attr('sun.sun','next_' ~ start.event)).minute))"
+    EM = "(((end.value[0:2]|int)*60 + (end.value[3:5]|int)) if end.kind == 'clock' else (as_local(state_attr('sun.sun','next_' ~ end.event)).hour*60 + as_local(state_attr('sun.sun','next_' ~ end.event)).minute))"
+    return {
+        "condition": "template",
+        "value_template": (
+            f"( ({SM} < {EM} and ({NOWM} >= {SM} and {NOWM} < {EM})) "
+            f"or ({SM} >= {EM} and ({NOWM} >= {SM} or {NOWM} < {EM})) )"
+        ),
+        "variables": {"start": start_ts or {}, "end": end_ts or {}}
+    }
+    
+
+def _day_selector_condition(sel: Optional[str]):
+    if sel == "weekdays":
+        return {"condition": "time", "weekday": ["mon","tue","wed","thu","fri"]}
+    if sel == "weekends":
+        return {"condition": "time", "weekday": ["sat","sun"]}
+    # daily / None
+    return None
+
+def _holiday_condition(mode: Optional[str], hol_id: Optional[str]):
+    if not (mode and hol_id):
+        return None
+    # True when today is a holiday for 'only', false when 'except'
+    eid = f"binary_sensor.hassl_holiday_{hol_id}"
+    return {"condition": "state", "entity_id": eid, "state": "on" if mode == "only" else "off"}
+
+def _norm_hmode(raw: Optional[str]) -> Optional[str]:
+    """Coerce analyzer-provided holiday_mode variants to {'only','except',None}."""
+    if not raw:
+        return None
+    v = str(raw).strip().lower().replace("_", " ").replace("-", " ")
+    # Accept a bunch of user/analyzer phrasings
+    if any(k in v for k in ("except", "exclude", "unless", "not")):
+        return "except"
+    if any(k in v for k in ("only", "holiday only", "holidays only")):
+        return "only"
+    # Unknown → leave as-is to avoid surprising behavior
+    return raw
+
+def _trigger_for(ts: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Build a HA trigger for a time-spec dict:
+      - {"kind":"clock","value":"HH:MM"}  -> time at HH:MM:00
+      - {"kind":"sun","event":"sunrise|sunset","offset":"+15m"} -> sun trigger (with offset)
+    """
+    if isinstance(ts, dict) and ts.get("kind") == "clock":
+        hhmm = ts.get("value", "00:00")
+        at = hhmm if len(hhmm) == 8 else (hhmm + ":00" if len(hhmm) == 5 else "00:00:00")
+        return {"platform": "time", "at": str(at)}
+    if isinstance(ts, dict) and ts.get("kind") == "sun":
+        trig = {"platform": "sun", "event": ts.get("event", "sunrise")}
+        off = _parse_offset(ts.get("offset", "0s"))
+        if off and off != "00:00:00":
+           trig["offset"] = off
+        return trig
+    # Fallback: evaluate soon; maintenance automation will correct state anyway
+    return {"platform": "time_pattern", "minutes": "/1"}
+
 def _jinja_offset(offset: str) -> str:
     """
     Convert '+15m'/'-10s'/'2h' to a Jinja timedelta expression snippet:
@@ -236,6 +379,49 @@ def _emit_schedule_helper_yaml(entity_id: str, pkg: str, name: str, clauses: Lis
         "state": f"{{{{ {state_tpl} }}}}"
     }
 
+# ---------- NEW: period sensor template builders ----------
+def _period_template(period: Dict[str, Any]) -> str:
+    """
+    period is a dict of shape:
+      {"kind":"months","data":{"list":[Mon,...]}} or {"kind":"months","data":{"range":[A,B]}}
+      {"kind":"dates","data":{"start":"MM-DD","end":"MM-DD"}}   # can wrap year
+      {"kind":"range","data":{"start":"YYYY-MM-DD","end":"YYYY-MM-DD"}}
+    Returns a Jinja boolean expression.
+    """
+    kind = period.get("kind")
+    data = period.get("data", {})
+    
+    if kind == "months":
+        def m2n(m: str) -> int:
+            order = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]
+            return order.index(m)+1
+        if "list" in data:
+            months = [m2n(m) for m in data["list"]]
+            return f"( now().month in {months} )"
+        if "range" in data:
+            a, b = [m2n(x) for x in data["range"]]
+            return (
+                f"( ({a} <= now().month <= {b}) or "
+                f"  ({a} > {b} and (now().month >= {a} or now().month <= {b})) )"
+            )
+
+    if kind == "dates":
+        # Compare zero-padded strings '%m-%d' (lexicographic works).
+        start = data.get("start"); end = data.get("end")
+        d = "now().strftime('%m-%d')"
+        return (
+            f"( ('{start}' <= {d} <= '{end}') or "
+            f"  ('{start}' > '{end}' and ({d} >= '{start}' or {d} <= '{end}')) )"
+        )
+    if kind == "range":
+        start = data.get("start"); end = data.get("end")
+        # Keep this as a pure expression using filters.
+        return (
+            f"( now().date() >= '{start}'|as_datetime|date and "
+            f"  now().date() <= '{end}'|as_datetime|date )"
+        )
+    return "true"
+
 def _collect_named_schedules(ir: IRProgram) -> Iterable[Dict]:
     """
     Collect named schedules from IR in either object, list, or dict form.
@@ -295,7 +481,6 @@ def _collect_named_schedules(ir: IRProgram) -> Iterable[Dict]:
 def emit_package(ir: IRProgram, outdir: str):
     ensure_dir(outdir)
 
-    print("DEBUG:", getattr(ir, "schedules", None))
     # derive package slug early; use IR package if present
     pkg = getattr(ir, "package", None) or _pkg_slug(outdir)
     sched_reg = ScheduleRegistry(pkg)
@@ -304,12 +489,33 @@ def emit_package(ir: IRProgram, outdir: str):
     scripts: Dict = {"script": {}}
     automations: List[Dict] = []
 
+    # We no longer emit legacy YAML 'platform: workday' sections.
+    # Only emit template sensors that reference UI-defined Workday entities.
+    holiday_tpl_defs: List[Dict] = []
+    
     # ---------- PASS 1: create named schedule helpers ONCE per (pkg, name) ----------
     for s in _collect_named_schedules(ir):
         if not s.get("name"):
             continue
         sched_reg.register_decl(s["name"], s.get("clauses", []))
 
+    # ---------- PASS 1b: Holidays -> (template only; Workday via UI) ----------
+    # ir.holidays is {"id": {...}}; we only need the id to reference UI entities.
+    holidays_ir = getattr(ir, "holidays", {}) or {}
+    if holidays_ir:
+        for hid, h in holidays_ir.items():
+            # Template: holiday = NOT(not_holiday)
+            # Assumes you configured a UI Workday instance that:
+            #   - has workdays = Mon..Sun
+            #   - excludes = ['holiday']
+            # and renamed it to: binary_sensor.hassl_<id>_not_holiday
+            eid_name = f"hassl_holiday_{hid}"
+            holiday_tpl_defs.append({
+                "name": eid_name,
+                "unique_id": eid_name,
+                "state": "{{ is_state('binary_sensor.hassl_" + hid + "_not_holiday', 'off') }}"
+            })
+
     # ---------- Context helpers for entities & per-prop contexts ----------
     sync_entities = set(); entity_props = {}
     for s in ir.syncs:
@@ -436,11 +642,13 @@ def emit_package(ir: IRProgram, outdir: str):
                     )
                 })
                 
-                proxy_e = (
-                    f"input_text.hassl_{_safe(s.name)}_{prop}"
-                    if PROP_CONFIG.get(prop,{}).get("proxy",{}).get("type") == "input_text"
-                    else f"input_number.hassl_{_safe(s.name)}_{prop}"
-                )
+                ptype = PROP_CONFIG.get(prop, {}).get("proxy", {}).get("type")
+                if ptype == "input_text":
+                    proxy_e = f"input_text.hassl_{_safe(s.name)}_{prop}"
+                elif ptype == "input_boolean":
+                    proxy_e = f"input_boolean.hassl_{_safe(s.name)}_{prop}"
+                else:
+                    proxy_e = f"input_number.hassl_{_safe(s.name)}_{prop}"
 
                 if prop == "mute":
                     actions = [{
@@ -513,11 +721,14 @@ def emit_package(ir: IRProgram, outdir: str):
                     })
                 automations.append({"alias": f"HASSL sync {s.name} downstream onoff","mode":"queued","max":10,"trigger": trigger,"action": actions})
             else:
-                proxy_e = (
-                    f"input_text.hassl_{_safe(s.name)}_{prop}"
-                    if PROP_CONFIG.get(prop,{}).get("proxy",{}).get("type") == "input_text"
-                    else f"input_number.hassl_{_safe(s.name)}_{prop}"
-                )
+                ptype = PROP_CONFIG.get(prop, {}).get("proxy", {}).get("type")
+                if ptype == "input_text":
+                    proxy_e = f"input_text.hassl_{_safe(s.name)}_{prop}"
+                elif ptype == "input_boolean":
+                    proxy_e = f"input_boolean.hassl_{_safe(s.name)}_{prop}"
+                else:
+                    proxy_e = f"input_number.hassl_{_safe(s.name)}_{prop}"
+
                 trigger = [{"platform": "state","entity_id": proxy_e}]
                 actions = []
                 cfg = PROP_CONFIG.get(prop, {})
@@ -551,6 +762,136 @@ def emit_package(ir: IRProgram, outdir: str):
                     })
                 automations.append({"alias": f"HASSL sync {s.name} downstream {prop}","mode":"queued","max":10,"trigger": trigger,"action": actions})
 
+    # ---------- New schedule windows (emit input_boolean + minute/sun maintenance automation) ----------
+    # IR provides schedules_windows: { name: [ {start,end,day_selector,period,holiday_*} ] }
+    sched_windows_ir = getattr(ir, "schedules_windows", {}) or {}
+    per_schedule_automations: Dict[str, List[Dict]] = {}
+    for sched_name, wins in sched_windows_ir.items():
+        # Ensure schedule boolean exists in helpers (include pkg prefix!)
+        sched_bool_key = f"hassl_sched_{_safe(pkg)}_{_safe(sched_name)}"
+        helpers["input_boolean"][sched_bool_key] = {
+            "name": f"HASSL Schedule {pkg}.{sched_name}"
+        }
+        bool_eid = f"input_boolean.{sched_bool_key}"
+
+        # --- Back-compat: emit '_active' template mirrors that follow the input_boolean ---
+        # 1) Primary mirror: binary_sensor.hassl_schedule_<pkg>_<name>_active
+        pkg_safe = _safe(pkg)
+        mirror_name = f"hassl_schedule_{pkg_safe}_{_safe(sched_name)}_active"
+        sched_reg.sensors.append({
+            "name": mirror_name,
+            "unique_id": mirror_name,
+            "state": "{{ is_state('" + bool_eid + "', 'on') }}"
+        })
+        # 2) Legacy alias (no pkg): binary_sensor.hassl_schedule_automations_<name>_active
+        # Some existing rulegen referenced this older name; keep it as a thin mirror.
+        legacy_alias = f"hassl_schedule_automations_{_safe(sched_name)}_active"
+        sched_reg.sensors.append({
+            "name": legacy_alias,
+            "unique_id": legacy_alias,
+            "state": "{{ is_state('" + bool_eid + "', 'on') }}"
+        })
+
+        # Build OR-of-windows condition bundles
+        or_conditions: List[Dict[str, Any]] = []
+        need_sun_triggers = False
+
+        for idx, w in enumerate(wins):
+
+            ds = w.get("day_selector")
+            href = w.get("holiday_ref")
+            hmode = _norm_hmode(w.get("holiday_mode"))
+            period = w.get("period")
+            if href and hmode is None and ds in ("weekdays", "weekends"):
+                hmode = "except"
+
+            # Coerce time specs to dicts compatible with _trigger_for/_window_condition_from_specs
+            raw_start = w.get("start")
+            raw_end   = w.get("end")
+            def _coerce(ts):
+                if isinstance(ts, dict):
+                    return ts
+                if isinstance(ts, str):
+                    # accept "HH:MM" or "HH:MM:SS"
+                    v = ts if len(ts) in (5,8) else "00:00"
+                    return {"kind":"clock","value": v[:5] if len(v)==5 else v[:8]}
+                return {"kind":"clock","value":"00:00"}
+            start_ts = _coerce(raw_start)
+            end_ts   = _coerce(raw_end)
+
+            # window condition (handles clock↔sun and wrap)
+            window_cond = _window_condition_from_specs(start_ts, end_ts)
+            if start_ts.get("kind") == "sun" or end_ts.get("kind") == "sun":
+                need_sun_triggers = True
+
+            # day selector & holiday & period
+            conds_and = [ c for c in (_day_selector_condition(ds),
+                                      _holiday_condition(hmode, href),
+                                      window_cond)
+                          if c is not None ]
+            period_eid = sched_reg.ensure_period_sensor(sched_name, period)
+            if period_eid:
+                conds_and.append({"condition":"state", "entity_id": period_eid, "state":"on"})
+            or_conditions.append({ "condition": "and", "conditions": conds_and })
+
+            # --- Per-window explicit ON/OFF automations (edges only) ---
+            edge_conds = [ _day_selector_condition(ds), _holiday_condition(hmode, href) ]
+            if period_eid:
+                edge_conds.append({"condition": "state", "entity_id": period_eid, "state": "on"})
+                edge_conds = [c for c in edge_conds if c]
+
+            on_auto = {
+                "alias": f"HASSL schedule {pkg}.{sched_name} on_{idx}",
+                "mode": "single",
+                "trigger": [ _trigger_for(start_ts) ],
+                "action": [ { "service": "input_boolean.turn_on", "target": {"entity_id": bool_eid} } ]
+            }
+            ec = [c for c in edge_conds if c]
+            if ec:
+                on_auto["condition"] = ec
+            per_schedule_automations.setdefault(sched_name, []).append(on_auto)
+
+            off_auto = {
+                "alias": f"HASSL schedule {pkg}.{sched_name} off_{idx}",
+                "mode": "single",
+                "trigger": [ _trigger_for(end_ts) ],
+                "action": [ { "service": "input_boolean.turn_off", "target": {"entity_id": bool_eid} } ]
+            }
+            if ec:
+                off_auto["condition"] = ec
+            per_schedule_automations.setdefault(sched_name, []).append(off_auto)
+            
+        # Composite choose: ON when any window matches, else OFF
+        choose_block = [{
+            "conditions": [{ "condition": "or", "conditions": or_conditions }] if or_conditions else [{"condition":"template","value_template":"false"}],
+            "sequence": [{"service": "input_boolean.turn_on", "target": {"entity_id": bool_eid}}]
+        }]
+        
+
+        triggers = [
+            {"platform": "time_pattern", "minutes": "/1"},
+            # Re-evaluate on HA restart so the boolean is correct immediately
+            {"platform": "homeassistant", "event": "start"},
+        ]
+        if need_sun_triggers:
+            # Nudge immedately at edges so the boolean flips promptly
+            triggers.extend([
+                {"platform": "sun", "event": "sunrise"},
+                {"platform": "sun", "event": "sunset"}
+            ])
+
+        per_schedule_automations.setdefault(sched_name, []).append({
+            "alias": f"HASSL schedule {pkg}.{sched_name} maint",
+            "mode": "single",
+            "trigger": triggers,
+            "condition": [],
+            "action": [
+                {"choose": choose_block,
+                 "default": [{"service": "input_boolean.turn_off", "target": {"entity_id": bool_eid}}]
+                }
+            ]
+        })
+
     # ---------- Write YAML ----------
     # helpers & scripts
     _dump_yaml(os.path.join(outdir, f"helpers_{pkg}.yaml"), helpers, ensure_sections=True)
@@ -563,8 +904,22 @@ def emit_package(ir: IRProgram, outdir: str):
             {"template": [{"binary_sensor": sched_reg.sensors}]}
         )
 
+    # Holidays file: emit only the template sensors; Workday instances are created via UI
+    if holiday_tpl_defs:
+        hol_doc: Dict[str, Any] = {}
+        hol_doc["template"] = [{"binary_sensor": holiday_tpl_defs}]
+        _dump_yaml(os.path.join(outdir, f"holidays_{pkg}.yaml"), hol_doc)
+
     # automations per sync
     for s in ir.syncs:
         doc = [a for a in automations if a["alias"].startswith(f"HASSL sync {s.name}")]
         if doc:
             _dump_yaml(os.path.join(outdir, f"sync_{pkg}_{_safe(s.name)}.yaml"), {"automation": doc})
+
+    # automations per schedule (new windows)
+    for sched_name, autos in per_schedule_automations.items():
+        if autos:
+            _dump_yaml(
+                os.path.join(outdir, f"schedule_{pkg}_{_safe(sched_name)}.yaml"),
+                {"automation": autos}
+            )

hassl/codegen/rules_min.py

@@ -404,14 +404,52 @@ def generate_rules(ir, outdir):
         rname = rule["name"]
         gate = _gate_entity(rname)
 
-        # gather schedule conditions for this rule
-        cond_schedule_entities = []
-
-        # 1) named schedules used by this rule → state('on') of the schedule sensor
-        for nm in use_by_rule.get(rname, []) or []:
-            base = str(nm).split(".")[-1]
-            decl_pkg = exported_sched_pkgs.get(base, pkg)
-            cond_schedule_entities.append(_schedule_sensor(base, decl_pkg))
+        # Build per-schedule gate conditions.
+         # For each referenced schedule, OR together its possible gate entities
+         # (e.g., input_boolean.hassl_sched_* OR binary_sensor.hassl_schedule_*_active).
+        schedule_gate_conditions = []
+ 
+        rule_gates = list(rule.get("schedule_gates") or []) if isinstance(rule, dict) else []
+        used_names = list(use_by_rule.get(rname, []) or [])
+ 
+        if rule_gates:
+            for g in rule_gates:
+                ents = [e for e in (g.get("entities") or []) if isinstance(e, str)]
+                # Also include the legacy, current-outdir slug binary_sensor expected by older tests/code
+                # Determine the base schedule name, then synthesize the local sensor id.
+                resolved = str(g.get("resolved", "")) if isinstance(g.get("resolved", ""), str) else ""
+                base = resolved.rsplit(".", 1)[-1] if resolved else None
+                if base:
+                    legacy_local = _schedule_sensor(base, pkg)  # e.g., binary_sensor.hassl_schedule_out_std_<base>_active
+                    if legacy_local not in ents:
+                        ents.append(legacy_local)
+                        
+                if not ents:
+                    continue
+                if len(ents) == 1:
+                    schedule_gate_conditions.append({
+                        "condition": "state",
+                        "entity_id": ents[0],
+                        "state": "on"
+                    })
+                else:
+                    schedule_gate_conditions.append({
+                        "condition": "or",
+                        "conditions": [
+                            {"condition": "state", "entity_id": e, "state": "on"}
+                            for e in ents
+                        ]
+                    })
+        else:
+            # Legacy fallback: only the template binary_sensor is known.
+            for nm in used_names:
+                base = str(nm).split(".")[-1]
+                decl_pkg = exported_sched_pkgs.get(base, pkg)
+                schedule_gate_conditions.append({
+                    "condition": "state",
+                    "entity_id": _schedule_sensor(base, decl_pkg),
+                    "state": "on"
+                })
 
         # 2) inline schedule clauses → compile directly to HA conditions (no helpers)
         inline_clauses = inline_by_rule.get(rname, []) or []
@@ -420,9 +458,6 @@ def generate_rules(ir, outdir):
             if isinstance(cl, dict) and cl.get("type") == "schedule_clause":
                 inline_schedule_conditions.append(_schedule_clause_to_condition(cl))
 
-        # de-dup schedule conditions
-        cond_schedule_entities = sorted(set(cond_schedule_entities))
-
         # Now process each 'if' clause
         for idx, clause in enumerate(rule["clauses"]):
             # Each clause is {"condition": ..., "actions": [...]}
@@ -440,8 +475,10 @@ def generate_rules(ir, outdir):
             cond_ha = _condition_to_ha(cond_in)
             gate_cond = {"condition": "state", "entity_id": gate, "state": "on"}
 
-            # schedule gate conditions (all must be satisfied)
-            sched_conds = [{"condition":"state","entity_id": e,"state":"on"} for e in cond_schedule_entities]
+            # schedule gate conditions (all must be satisfied);
+            # each item in schedule_gate_conditions is already either a state check
+            # or an OR of multiple state checks for a single schedule.
+            sched_conds = list(schedule_gate_conditions)
             if inline_schedule_conditions:
                 sched_conds.extend(inline_schedule_conditions)