hassl 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

hassl/semantics/analyzer.py

@@ -1,6 +1,9 @@
-from dataclasses import dataclass
-from typing import Dict, List, Any, Optional
-from ..ast.nodes import Program, Alias, Sync, Rule
+from dataclasses import dataclass, field
+from typing import Dict, List, Any, Optional, Tuple
+from ..ast.nodes import (
+    Program, Alias, Sync, Rule, Schedule,
+    HolidaySet, ScheduleWindow, PeriodSelector,
+    )
 from .domains import DOMAIN_PROPS, domain_of
 
 @dataclass
@@ -21,13 +24,21 @@ class IRRule:
     clauses: List[dict]
     schedule_uses: Optional[List[str]] = None
     schedules_inline: Optional[List[dict]] = None
-
+    # NEW: for each schedule use, the emitter can gate on ANY of these entity ids.
+    # List of {"resolved": "pkg.name", "entities": [entity_id, ...]}
+    schedule_gates: Optional[List[Dict[str, Any]]] = None
+    
 @dataclass
 class IRProgram:
     aliases: Dict[str, str]
     syncs: List[IRSync]
     rules: List[IRRule]
+    # Legacy schedule clauses (enable/disable from …)
     schedules: Optional[Dict[str, List[dict]]] = None
+    # NEW: declared holiday sets (by id)
+    holidays: Optional[Dict[str, dict]] = None
+    # NEW: structured windows keyed by schedule name
+    schedules_windows: Optional[Dict[str, List[dict]]] = None  # NEW
     
     def to_dict(self):
         return {
@@ -40,9 +51,13 @@ class IRProgram:
                 "name": r.name,
                 "clauses": r.clauses,
                 "schedule_uses": r.schedule_uses or [],
-                "schedules_inline": r.schedules_inline or []
+                "schedules_inline": r.schedules_inline or [],
+                # surface gates so codegen can choose correct binary_sensor/input_boolean
+                "schedule_gates": r.schedule_gates or [],
             } for r in self.rules],
             "schedules": self.schedules or {},
+            "holidays": self.holidays or {},
+            "schedules_windows": self.schedules_windows or {},  # NEW
         }
 
 def _resolve_alias(e: str, amap: Dict[str,str]) -> str:
@@ -78,11 +93,134 @@ def _props_for_sync(kind: str, members: List[str]) -> List[IRSyncedProp]:
     return []
 
 def analyze(prog: Program) -> IRProgram:
-    # --- Aliases ---
-    amap: Dict[str,str] = {}
+    """
+    Import + package semantics
+    -------------------------
+    - Supports:
+        import pkg.*                      # glob injects public aliases & schedules
+        import pkg: a, b as c             # list import (with optional renames)
+        import pkg as ns                  # qualified access via 'ns.x'
+    - Resolution uses a global export registry if provided by the build:
+        GLOBAL_EXPORTS: Dict[(pkg, kind, name), node]
+      where kind ∈ {"alias","schedule"} and node is Alias|Schedule.
+      Falls back to intra-file visibility if GLOBAL_EXPORTS absent.
+    """
+    package_name: str = prog.package or ""
+
+    # Local (this file) exports — public only (private stays local)
+    local_aliases: Dict[str, str] = {}
+    local_schedules: Dict[str, List[dict]] = {}
+    local_public: Dict[Tuple[str, str, str], Any] = {}  # (pkg, kind, name) -> node
+    local_schedule_windows: Dict[str, List[ScheduleWindow]] = {}
+    local_holidays: Dict[str, HolidaySet] = {}
+
+    # 1) Collect local declarations (aliases & schedules)
     for s in prog.statements:
         if isinstance(s, Alias):
-            amap[s.name] = s.entity
+            local_aliases[s.name] = s.entity
+            is_private = getattr(s, "private", False)
+            if not is_private:
+                local_public[(package_name, "alias", s.name)] = s
+        elif isinstance(s, dict) and s.get("type") == "schedule_decl":
+            name = s.get("name")
+            if isinstance(name, str) and name.strip():
+                local_schedules.setdefault(name, []).extend(s.get("clauses", []) or [])
+                if not s.get("private", False):
+                    # wrap in a lightweight Schedule node shape for export table parity
+                    local_public[(package_name, "schedule", name)] = Schedule(name=name, clauses=s.get("clauses", []), private=False)
+        elif isinstance(s, Schedule):
+            # Only treat as "legacy" if there are actual legacy clauses.
+            if getattr(s, "clauses", None):
+                local_schedules.setdefault(s.name, []).extend(s.clauses or [])
+            # Always collect windows if present.
+            if getattr(s, "windows", None):
+                local_schedule_windows.setdefault(s.name, []).extend(s.windows or [])
+            # Export the schedule either way (legacy or windows) if public.
+            if not getattr(s, "private", False):
+                local_public[(package_name, "schedule", s.name)] = s
+        elif isinstance(s, HolidaySet):
+            local_holidays[s.id] = s
+
+    # 2) Build import view
+    # Maps for analysis:
+    injected_aliases: Dict[str, str] = {}      # local name -> entity id (from imports)
+    imported_schedules: Dict[str, Tuple[str, str]] = {}  # local name -> (pkg, name)
+    qualified_prefixes: Dict[str, str] = {}    # ns -> module path (for "import X as ns")
+
+    # Helper to resolve from global exports if available; otherwise, from locals only
+    def _get_export(mod: str, kind: str, name: str) -> Optional[Any]:
+        key = (mod, kind, name)
+        if 'GLOBAL_EXPORTS' in globals():
+            return globals()['GLOBAL_EXPORTS'].get(key)
+        # intra-file fallback: only resolve if the target module == this file's package
+        if mod == package_name:
+            return local_public.get(key)
+        return None
+
+        # Warn or raise if imported modules aren't in GLOBAL_EXPORTS
+    def _check_import_exists(mod: str):
+        """Emit a warning if module not found in GLOBAL_EXPORTS (user likely compiled only a subdir)."""
+        if 'GLOBAL_EXPORTS' not in globals():
+            return  # single-file compile, skip
+        exists = any(pkg == mod for (pkg, _kind, _name) in globals()['GLOBAL_EXPORTS'])
+        if not exists:
+            import sys
+            print(f"[hasslc] WARNING: imported module '{mod}' not found in build inputs "
+                  f"(run hasslc from a directory that includes it)", file=sys.stderr)
+        
+    # Dig through Program.imports if present (transformer supplies a normalized list)
+    for imp in getattr(prog, "imports", []) or []:
+        if not isinstance(imp, dict) or imp.get("type") != "import":
+            # transformer may also append sentinels to statements; ignore here
+            continue
+        mod = imp.get("module", "")
+        kind = imp.get("kind")
+        # Be generous: if transformer emitted "none" or omitted kind, infer it.
+        if kind not in ("glob", "list", "alias"):
+            if imp.get("items"):
+                kind = "list"
+            elif imp.get("as"):
+                kind = "alias"
+            else:
+                kind = "glob"
+        
+        _check_import_exists(mod)
+        if kind == "glob":
+            # bring in all public aliases & schedules from 'mod'
+            source = globals().get('GLOBAL_EXPORTS', local_public)
+            for (pkg, k, nm), node in source.items():
+                if pkg != mod or k not in ("alias", "schedule"):
+                    continue
+                if k == "alias" and isinstance(node, Alias):
+                    injected_aliases[nm] = node.entity
+                elif k == "schedule":
+                    imported_schedules[nm] = (pkg, nm)
+        elif kind == "list":
+            for it in imp.get("items") or []:
+                nm = it.get("name")
+                as_nm = it.get("as") or nm
+                # prefer alias, then schedule
+                node = _get_export(mod, "alias", nm)
+                if isinstance(node, Alias):
+                    injected_aliases[as_nm] = node.entity
+                    continue
+                node = _get_export(mod, "schedule", nm)
+                if isinstance(node, Schedule) or (isinstance(node, dict) and node.get("type") == "schedule_decl"):
+                    imported_schedules[as_nm] = (mod, nm)
+                    continue
+                raise KeyError(f"ImportError: module '{mod}' has no public symbol '{nm}'")
+        elif kind == "alias":
+            # import mod as ns  -> track mapping for qualified access
+            ns = imp.get("as")
+            if not ns:
+                raise KeyError(f"ImportError: missing alias name for module '{mod}'")
+            qualified_prefixes[str(ns)] = mod
+        else:
+            # ignore unknown import kinds gracefully
+            pass
+
+    # 3) Merge alias maps: imported first, then local (locals win)
+    amap: Dict[str, str] = {**injected_aliases, **local_aliases}
 
     # --- Syncs ---
     syncs: List[IRSync] = []
@@ -93,34 +231,141 @@ def analyze(prog: Program) -> IRProgram:
             props = _props_for_sync(s.kind, mem)
             syncs.append(IRSync(s.name, s.kind, mem, inv, props))
 
-    # --- Top-level schedules (from transformer) ---
+    # --- Top-level schedules (from transformer or Schedule nodes) ---
     scheds: Dict[str, List[dict]] = {}
-    for st in prog.statements:
-        # transformer emits: {"type":"schedule_decl","name":..., "clauses":[...]}
-        if isinstance(st, dict) and st.get("type") == "schedule_decl":
-            name = st.get("name")
-            clauses = st.get("clauses", []) or []
-            if isinstance(name, str) and name.strip():
-                # no aliasing inside time specs
-                scheds.setdefault(name, []).extend(clauses)
+    # seed with locals collected earlier (so we keep a single source of truth)
+    for nm, cls in local_schedules.items():
+        scheds.setdefault(nm, []).extend(cls)
+
+    # NEW: collect structured windows (serialize to plain dicts)
+    sched_windows: Dict[str, List[dict]] = {}
+    for nm, wins in local_schedule_windows.items():
+        out: List[dict] = []
+        for w in wins:
+            if not isinstance(w, ScheduleWindow):
+                continue
+            # flatten PeriodSelector to dict for IR portability
+            period = None
+            if getattr(w, "period", None):
+                p = w.period  # PeriodSelector
+                period = {"kind": p.kind, "data": dict(p.data)}
+            out.append({
+                "start": w.start,
+                "end": w.end,
+                "day_selector": w.day_selector,
+                "period": period,
+                "holiday_ref": w.holiday_ref,
+                "holiday_mode": w.holiday_mode,
+           })
+        if out:
+            sched_windows[nm] = out
 
     # --- Rules (with schedule use/inline) ---
     rules: List[IRRule] = []
+
+    def _safe(s: str) -> str:
+        return (s or "").replace(".", "_")
+
+    def _gate_entities_for(resolved: str) -> List[str]:
+        """
+        Return both possible entity ids for a resolved schedule name 'pkg.name'.
+        - Legacy (template binary_sensor): binary_sensor.hassl_schedule_<pkg>_<name>_active
+        - New windows (input_boolean):     input_boolean.hassl_sched_<pkg>_<name>
+        We include BOTH so downstream rule emitters can OR them safely.
+        """
+        if "." in resolved:
+            pkg, nm = resolved.rsplit(".", 1)
+        else:
+            pkg, nm = (prog.package or ""), resolved
+        legacy = f"binary_sensor.hassl_schedule_{_safe(pkg)}_{_safe(nm)}_active".lower()
+        window = f"input_boolean.hassl_sched_{_safe(pkg)}_{_safe(nm)}".lower()
+        return [window, legacy]
+
+    def _resolve_qualified_alias(name: str) -> Optional[str]:
+        """
+        Resolve a dotted alias reference like 'ns.light_alias' via 'import pkg as ns'.
+        Returns the entity string if found, else None.
+        """
+        if "." not in name:
+            return None
+        head, tail = name.split(".", 1)
+        mod = qualified_prefixes.get(head)
+        if not mod:
+            return None
+        node = _get_export(mod, "alias", tail)
+        if isinstance(node, Alias):
+            return node.entity
+        return None
+
+    def _resolve_schedule_name(nm: str) -> str:
+        """
+        Normalize a schedule identifier to a friendly resolved string:
+        - local name: keep as-is
+        - imported list/glob: keep local alias (as imported), but if we know the
+          source package, annotate as 'pkg.name' for consistency
+        - qualified 'ns.x': resolve 'ns' to module and return 'module.x' if found
+        """
+        # local schedule? (either legacy clauses OR window-only)
+        if nm in local_schedules or nm in local_schedule_windows:
+            return f"{package_name+'.' if package_name else ''}{nm}"
+        # imported by name (list or glob)
+        if nm in imported_schedules:
+            pkg, base = imported_schedules[nm]
+            return f"{pkg}.{base}"
+        # qualified via ns
+        if "." in nm:
+            head, tail = nm.split(".", 1)
+            mod = qualified_prefixes.get(head)
+            if mod:
+                node = _get_export(mod, "schedule", tail)
+                if node is not None:
+                    return f"{mod}.{tail}"
+        # unknown — leave as-is (analyzer will not fail here; emitter/runner can)
+        return nm
+
+    # Upgrade alias resolution to support qualified 'ns.aliasName' in expr/actions
+    def _walk_alias_with_qualified(obj: Any) -> Any:
+        if isinstance(obj, dict):
+            return {k: _walk_alias_with_qualified(v) for k, v in obj.items()}
+        if isinstance(obj, list):
+            return [_walk_alias_with_qualified(x) for x in obj]
+        if isinstance(obj, str):
+            # first try local/unqualified map
+            if "." not in obj and obj in amap:
+                return amap[obj]
+            # then try qualified import alias
+            ent = _resolve_qualified_alias(obj)
+            if ent:
+                return ent
+        return obj
+    
     for s in prog.statements:
         if isinstance(s, Rule):
             clauses: List[dict] = []
             schedule_uses: List[str] = []
             schedules_inline: List[dict] = []
+            # Per-rule collection of precomputed gate entities
+            schedule_gates: List[Dict[str, Any]] = []
 
             for c in s.clauses:
                 # IfClause-like items have .condition/.actions
                 if hasattr(c, "condition") and hasattr(c, "actions"):
-                    cond = _walk_alias(c.condition, amap)
-                    acts = _walk_alias(c.actions, amap)
+                    # Keep alias identifiers intact for tests & codegen (resolve later)
+                    cond = c.condition
+                    acts = c.actions
                     clauses.append({"condition": cond, "actions": acts})
                 elif isinstance(c, dict) and c.get("type") == "schedule_use":
                     # {"type":"schedule_use","names":[...]}
-                    schedule_uses.extend([str(n) for n in (c.get("names") or []) if isinstance(n, str)])
+                    raw = [str(n) for n in (c.get("names") or []) if isinstance(n, str)]
+
+                    # The IR should keep base names (tests assert on this)
+                    schedule_uses.extend(raw)
+                    # But also compute resolved names for gate entities (pkg.name when known)
+                    resolved = [_resolve_schedule_name(n) for n in raw]
+                    # precompute gates for emitters (binary_sensor + input_boolean forms)
+                    for rname in resolved:
+                        schedule_gates.append({"resolved": rname, "entities": _gate_entities_for(rname)})
+
                 elif isinstance(c, dict) and c.get("type") == "schedule_inline":
                     # {"type":"schedule_inline","clauses":[...]}
                     for sc in c.get("clauses") or []:
@@ -134,12 +379,43 @@ def analyze(prog: Program) -> IRProgram:
                 name=s.name,
                 clauses=clauses,
                 schedule_uses=schedule_uses,
-                schedules_inline=schedules_inline
+                schedules_inline=schedules_inline,
+                schedule_gates=schedule_gates
             ))
 
+    # -------- NEW: validate schedule windows --------
+    allowed_days = {"weekdays", "weekends", "daily"}
+    for sched_name, wins in sched_windows.items():
+        for w in wins:
+            ds = w.get("day_selector")
+            if ds not in allowed_days:
+                raise ValueError(f"schedule '{sched_name}': invalid day selector '{ds}'")
+            href = w.get("holiday_ref")
+            hmode = w.get("holiday_mode")
+            if href:
+                if hmode not in ("except", "only"):
+                    raise ValueError(f"schedule '{sched_name}': holiday ref '{href}' requires 'except' or 'only'")
+                if href not in local_holidays:
+                    raise ValueError(f"schedule '{sched_name}': unknown holidays '{href}'")
+
+    # materialize holidays into plain dicts for IR
+    holidays_ir: Dict[str, dict] = {}
+    for hid, h in local_holidays.items():
+        holidays_ir[hid] = {
+            "id": h.id,
+            "country": h.country,
+            "province": h.province,
+            "add": list(h.add),
+            "remove": list(h.remove),
+            "workdays": list(h.workdays),
+            "excludes": list(h.excludes),
+        }
+
     return IRProgram(
         aliases=amap,
         syncs=syncs,
         rules=rules,
-        schedules=scheds
+        schedules=scheds,
+        schedules_windows=sched_windows,
+        holidays=holidays_ir
     )

{hassl-0.2.1.dist-info → hassl-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hassl
-Version: 0.2.1
+Version: 0.3.1
 Summary: HASSL: Home Assistant Simple Scripting Language
 Home-page: https://github.com/adanowitz/hassl
 Author: adanowitz
@@ -17,6 +17,8 @@ Dynamic: license-file
 
 > **Home Assistant Simple Scripting Language**
 
+![Version](https://img.shields.io/badge/version-v0.3.1-blue)
+
 HASSL is a human-friendly domain-specific language (DSL) for building **loop-safe**, **deterministic**, and **composable** automations for [Home Assistant](https://www.home-assistant.io/).
 
 It compiles lightweight `.hassl` scripts into fully functional YAML packages that plug directly into Home Assistant, replacing complex automations with a clean, readable syntax.
@@ -28,16 +30,20 @@ It compiles lightweight `.hassl` scripts into fully functional YAML packages tha
 - **Readable DSL** → write logic like natural language (`if motion && lux < 50 then light = on`)
 - **Sync devices** → keep switches, dimmers, and fans perfectly in sync
 - **Schedules** → declare time-based gates (`enable from 08:00 until 19:00`)
+- **Weekday/weekend/holiday schedules** → full support for Home Assistant’s **Workday integration** (v0.3.1)
 - **Loop-safe** → context ID tracking prevents feedback loops
 - **Per-rule enable gates** → `disable rule` or `enable rule` dynamically
 - **Inline waits** → `wait (!motion for 10m)` works like native HA triggers
 - **Color temperature in Kelvin** → `light.kelvin = 2700`
+- **Modular packages/imports** → split automations across files with public/private exports
 - **Auto-reload resilience** → schedules re-evaluate automatically on HA restart
 
 ---
 
 ## 🧰 Example
 
+### Basic standalone script
+
 ```hassl
 alias light  = light.wesley_lamp
 alias motion = binary_sensor.wesley_motion_motion
@@ -64,6 +70,45 @@ Produces a complete Home Assistant package with:
 - Sync automations for linked devices
 - Rule-based automations with schedules and `not_by` guards
 
+### Using imports across packages
+
+```hassl
+# packages/std/shared.hassl
+package std.shared
+
+alias light  = light.wesley_lamp
+alias motion = binary_sensor.wesley_motion_motion
+alias lux    = sensor.wesley_motion_illuminance
+
+schedule wake_hours:
+  enable from 08:00 until 19:00;
+```
+
+```hassl
+# packages/home/landing.hassl
+package home.landing
+import std.shared.*
+
+rule wesley_motion_light:
+  schedule use wake_hours;
+  if (motion && lux < 50)
+  then light = on;
+  wait (!motion for 10m) light = off
+
+rule landing_manual_off:
+  if (light == off) not_by any_hassl
+  then disable rule wesley_motion_light for 3m
+```
+
+This setup produces:
+- One **shared package** defining reusable aliases and schedules  
+- A **landing package** importing and reusing those exports  
+
+Together, they generate:
+- ✅ Shared schedule sensor (`binary_sensor.hassl_schedule_std_shared_wake_hours_active`)  
+- ✅ Cross-package rule automations gated by that schedule  
+- ✅ Context-safe helpers and syncs for both packages  
+
 ---
 
 ## 🏗 Installation
@@ -103,6 +148,7 @@ Each `.hassl` file compiles into an isolated package — no naming collisions, n
 | `scripts_<pkg>.yaml`       | Writer scripts with context stamping          |
 | `sync_<pkg>_*.yaml`        | Sync automations for each property            |
 | `rules_bundled_<pkg>.yaml` | Rule logic automations + schedules            |
+| `schedules_<pkg>.yaml`     | Time/sun-based schedule sensors (v0.3.1)      |
 
 ---
 
@@ -120,7 +166,7 @@ Each `.hassl` file compiles into an isolated package — no naming collisions, n
 
 ## 🔒 Loop Safety & Context Tracking
 
-HASSL automatically writes the **parent context ID** into helper entities before performing actions.\
+HASSL automatically writes the **parent context ID** into helper entities before performing actions.  
 This ensures `not_by any_hassl` and `not_by rule("name")` guards work flawlessly, preventing infinite feedback.
 
 ---
@@ -129,23 +175,91 @@ This ensures `not_by any_hassl` and `not_by rule("name")` guards work flawlessly
 
 All schedules are restart-safe:
 
-- `input_boolean.hassl_schedule_<name>` automatically re-evaluates on startup.
-- Triggers are set for both start and end times.
+- `binary_sensor.hassl_schedule_<package>_<name>_active` automatically re-evaluates on startup.
+- Clock and sun-based windows update continuously through HA’s template engine.
 - Missed events (like mid-day restarts) are recovered automatically.
 
 ---
 
-## 📚 Documentation
+## 🗓️ Holiday & Workday Integration (v0.3.1)
+
+HASSL now supports `holidays <id>:` schedules tied to Home Assistant’s **Workday** integration.
+
+To enable holiday and weekday/weekend-aware schedules:
+
+### 1️⃣ Create two Workday sensors in Home Assistant
+
+You must create **two Workday integrations** through the Home Assistant UI.
+
+#### Sensor 1 — `binary_sensor.hassl_<id>_workday`
+- **Workdays:** Mon–Fri  
+- **Excludes:** `holiday`  
+- **Meaning:** ON only on real workdays (Mon–Fri that are not holidays).
+
+#### Sensor 2 — `binary_sensor.hassl_<id>_not_holiday`
+- **Workdays:** Mon–Sun  
+- **Excludes:** `holiday`  
+- **Meaning:** ON every day except official holidays (including weekends).
+
+> In both, set your **Country** and optional **Province/Region** as needed for your locale (e.g., `US`, `CA`, `GB`, etc.).  
+> After setup, rename the entity IDs to exactly match:
+> - `binary_sensor.hassl_<id>_workday`
+> - `binary_sensor.hassl_<id>_not_holiday`  
+> where `<id>` matches the identifier used in your `.hassl` file (e.g., `us_ca`).
+
+HASSL derives:
+- `binary_sensor.hassl_holiday_<id>` → ON on holidays (even when they fall on weekends).
+
+### Truth table
+
+| Day type                     | `hassl_<id>_workday` | `hassl_<id>_not_holiday` | `hassl_holiday_<id>` (derived) |
+|------------------------------|-----------------------|---------------------------|---------------------------------|
+| Tue (normal)                | on                    | on                        | off                             |
+| Sat (normal weekend)        | off                   | on                        | off                             |
+| Mon that’s an official holiday | off                 | off                       | on                              |
+| Sat that’s an official holiday | off                 | off                       | on                              |
+
+This distinction lets you build precise schedules like:
+```hassl
+holidays us_ca:
+    country="US", province="CA"
+
+schedule master_wake:
+  on weekdays 06:00–22:00 except holidays us_ca;
+  on weekends 08:00–22:00;
+  on holidays us_ca 09:00–22:00;
+```
+
+🧩 **Note:**  
+Both sensors must be created manually in the Home Assistant UI — integrations can’t be defined in YAML.  
+Once created, HASSL automatically references them in generated automations.
+
+---
+
+## ⚗️ Experimental: Date & Month Range Schedules
+
+HASSL v0.3.1 includes early support for:
+
+```hassl
+on months Jun–Aug 07:00–22:00;
+on dates 12-24..01-02 06:00–20:00;
+```
 
-For full grammar and detailed semantics, see the [HASSL Language Specification](./HASSL_Specification.md).
+These may compile successfully but are **not yet validated in production**.  
+They’re marked **experimental** and will be verified after template automation support (v0.4 milestone).
 
-For a hands-on guide, check out the [Quickstart](./quickstart.md).
+---
+
+## 📚 Documentation
+
+- [Quickstart Guide](./quickstart.md)
+- [Language Specification](./Hassl_spec.md)
 
 ---
 
 ## 🧩 Contributing
 
-Contributions, tests, and ideas welcome!\
+Contributions, tests, and ideas welcome!  
 To run tests locally:
 
 ```bash
@@ -158,10 +272,9 @@ Please open pull requests for grammar improvements, new device domains, or sched
 
 ## 📄 License
 
-MIT License © 2025\
+MIT License © 2025  
 Created and maintained by [@adanowitz](https://github.com/adanowitz)
 
 ---
 
 **HASSL** — simple, reliable, human-readable automations for Home Assistant.
-

hassl-0.3.1.dist-info/RECORD

@@ -0,0 +1,23 @@
+hassl/__init__.py,sha256=r4xAFihOf72W9TD-lpMi6ntWSTKTP2SlzKP1ytkjRbI,22
+hassl/cli.py,sha256=TSUvkoAg7ck1vlDUhC2sv_1NSetksdVGuOv-P9wrKxA,15762
+hassl/ast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hassl/ast/nodes.py,sha256=U_UTmWS87laFuFX39mmzkk43JnGx7NEyNbkSomfTzSM,2704
+hassl/codegen/__init__.py,sha256=NgEw86oHlsk7cQrHz8Ttrtp68Cm7WKceTWRr02SDfjo,854
+hassl/codegen/generate.py,sha256=JmVBz8xhuPHosch0lhh8xU6tmdCsAl-qVWoY7hQxjow,206
+hassl/codegen/init.py,sha256=kMfi_Us_7c_T35OK_jo8eqb79lxNV-dToO9-iAb5fHI,55
+hassl/codegen/package.py,sha256=sGG40gonOoK3QJphO62Bju6WqFqfTT3XNx37QPHlb2w,42457
+hassl/codegen/rules_min.py,sha256=LbLrpJ_2TV_FJlHB17TcuBaqfbLl97VUKzLck3s9KXo,29557
+hassl/codegen/yaml_emit.py,sha256=VTNnR_uvSSqsL7kX5NyXuPUZh5FK36a_sUFsRyrQOS8,2207
+hassl/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hassl/parser/hassl.lark,sha256=-At0mQQiUXxQU2aB1pxrk1WfQdQiUJeH7Ev8ada7kLg,5637
+hassl/parser/loader.py,sha256=xwhdoMkmXskanY8IhqIOfkcOkkn33goDnsbjzS66FL8,249
+hassl/parser/transform.py,sha256=UXiUQBT3oMkFVJwFWA8X3L_Ds7PzZle7ZMBVVNSmp7Y,26332
+hassl/semantics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hassl/semantics/analyzer.py,sha256=M8pQTFRYSpAyBo-ctIRuT1DBb_WZsGs7hjT4-pHPLjA,18066
+hassl/semantics/domains.py,sha256=-OuhA4RkOLVaLnBxhKfJFjiQMYBSTryX9KjHit_8ezI,308
+hassl-0.3.1.dist-info/licenses/LICENSE,sha256=hPNSrn93Btl9sU4BkQlrIK1FpuFPvaemdW6-Scz-Xeo,1072
+hassl-0.3.1.dist-info/METADATA,sha256=TYCCs2uU-7mRXyvq2_pkMLbVMQY_VTqW5Oi5i0msaJg,9006
+hassl-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hassl-0.3.1.dist-info/entry_points.txt,sha256=qA8jYPZlESNL6V4fJCTPOBXFeEBtjLGGsftXsSo82so,42
+hassl-0.3.1.dist-info/top_level.txt,sha256=BPuiULeikxMI3jDVLmv3_n7yjSD9Qrq58bp9af_HixI,6
+hassl-0.3.1.dist-info/RECORD,,

hassl-0.2.1.dist-info/RECORD

@@ -1,21 +0,0 @@
-hassl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hassl/cli.py,sha256=yCtfMQHzKCmORDypwxtbGQywLvdERLo3BLYSC2WUxu8,1522
-hassl/ast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hassl/ast/nodes.py,sha256=HINbu3o_hEMDD5G9TgYeqAev-Af0Vacqc_gwQQnpiy0,762
-hassl/codegen/__init__.py,sha256=NgEw86oHlsk7cQrHz8Ttrtp68Cm7WKceTWRr02SDfjo,854
-hassl/codegen/package.py,sha256=9dcIjszhGXV26Hwr_rKHLz6yYbElyIegfhlXGi5Q0sY,16612
-hassl/codegen/rules_min.py,sha256=2ko9bFRZujXw7lt5k8L6UbfmTwS2PCWfub5M6Lwkg4I,28330
-hassl/codegen/yaml_emit.py,sha256=VTNnR_uvSSqsL7kX5NyXuPUZh5FK36a_sUFsRyrQOS8,2207
-hassl/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hassl/parser/hassl.lark,sha256=YIeY8ncd6nwBzS54A5JbvLhRiQd0u6ftea4nZac4_cA,3361
-hassl/parser/loader.py,sha256=xwhdoMkmXskanY8IhqIOfkcOkkn33goDnsbjzS66FL8,249
-hassl/parser/transform.py,sha256=dNTyPW9sOw09vBfvWMFSRRiTnOzZQWJvISV1o1aouD4,9481
-hassl/semantics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hassl/semantics/analyzer.py,sha256=1x2bAJXj8hsT_IBoxgfTFV0MmVMXcfjqzl_gWo-WuI8,5195
-hassl/semantics/domains.py,sha256=-OuhA4RkOLVaLnBxhKfJFjiQMYBSTryX9KjHit_8ezI,308
-hassl-0.2.1.dist-info/licenses/LICENSE,sha256=hPNSrn93Btl9sU4BkQlrIK1FpuFPvaemdW6-Scz-Xeo,1072
-hassl-0.2.1.dist-info/METADATA,sha256=Z43GbkiT3Sy-Lx3O5eQv8iUdcadYiIx73xac624-sMU,4929
-hassl-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hassl-0.2.1.dist-info/entry_points.txt,sha256=qA8jYPZlESNL6V4fJCTPOBXFeEBtjLGGsftXsSo82so,42
-hassl-0.2.1.dist-info/top_level.txt,sha256=BPuiULeikxMI3jDVLmv3_n7yjSD9Qrq58bp9af_HixI,6
-hassl-0.2.1.dist-info/RECORD,,