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

hassl/__init__.py

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

hassl/ast/nodes.py

@@ -58,6 +58,20 @@ class Schedule:
     windows: List[ScheduleWindow] = field(default_factory=list)
     private: bool = False
 
+@dataclass
+class TemplateDecl:
+    kind: str            # "rule" | "sync" | "schedule"
+    name: str
+    params: list = field(default_factory=list) # [{"name": "light", "default": ...}, ...]
+    body: Any = None  # Rule | Sync | Schedule body shape
+    private: bool = False
+
+@dataclass
+class UseTemplate:
+    name: str            # template name being referenced
+    args: list = field(default_factory=list)  # ["pos1", {"name":"kw","value":...}, ...] 
+    as_name: Optional[str] = None
+    
 @dataclass
 class Rule:
     name: str
@@ -75,7 +89,8 @@ class Program:
     def to_dict(self):
         def enc(x):
             if isinstance(x, (Alias, Sync, Rule, IfClause, Schedule,
-                              HolidaySet, ScheduleWindow, PeriodSelector)):
+                              HolidaySet, ScheduleWindow, PeriodSelector,
+                              TemplateDecl, UseTemplate)):
                 d = asdict(x); d["type"] = x.__class__.__name__; return d
             return x
         return {

hassl/cli.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Dict, Tuple, List
 from .parser.loader import load_grammar_text
 from .parser.transform import HasslTransformer
-from .ast.nodes import Program, Alias, Schedule
+from .ast.nodes import Program, Alias, Schedule, TemplateDecl
 from lark import Lark
 from .semantics import analyzer as sem_analyzer
 from .semantics.analyzer import analyze
@@ -85,6 +85,12 @@ def _collect_public_exports(prog: Program, pkg: str) -> Dict[Tuple[str,str,str],
             name = s.get("name")
             if isinstance(name, str) and name.strip():
                 out[(pkg, "schedule", name)] = Schedule(name=name, clauses=s.get("clauses", []) or [], private=False)
+
+        # Templates (public only)
+    for s in prog.statements:
+        if isinstance(s, TemplateDecl) and not getattr(s, "private", False):
+            out[(pkg, "template", s.name)] = s
+            
     return out
 
 def _scan_hassl_files(path: Path) -> List[Path]:
@@ -97,40 +103,62 @@ def _module_to_path(module_root: Path, module: str) -> Path:
 
 def _ensure_imports_loaded(programs, module_root: Path):
     """If imported packages aren't parsed yet, try to load their .hassl files from module_root."""
-    # programs: List[tuple[Path, Program, str]]
+    # Track both package names (from parsed files) and module ids (from import statements)
     known_pkgs = {pkg for _, _, pkg in programs}
+    seen_modules: set[str] = set()  # abs_mod we've already attempted/loaded
+    seen_paths: set[Path] = set(p for p, _, _ in programs)
+
     added = True
     while added:
         added = False
-        for _, prog, importer_pkg in list(programs):
+        # iterate over a snapshot; we'll append to programs
+        for importer_path, prog, importer_pkg in list(programs):
             for imp in getattr(prog, "imports", []) or []:
                 if not isinstance(imp, dict) or imp.get("type") != "import":
                     continue
+
                 raw_mod = imp.get("module", "")
-                if not raw_mod:
+                if not raw_mod or not module_root:
                     continue
-                # resolve relative notation against the importing package
+
                 abs_mod = _normalize_module(importer_pkg, raw_mod)
-                if abs_mod in known_pkgs:
+
+                # guard: avoid re-trying the same module or self-import
+                if abs_mod in seen_modules or abs_mod == importer_pkg:
                     continue
-                if not module_root:
+
+                # If we already have a program whose package == abs_mod, skip
+                if abs_mod in known_pkgs:
+                    seen_modules.add(abs_mod)
                     continue
+
                 candidate = _module_to_path(module_root, abs_mod)
-                if candidate.exists():
-                    print(f"[hasslc] Autoload candidate FOUND for '{abs_mod}': {candidate}")
-                    with open(candidate, "r", encoding="utf-8") as f:
-                        text = f.read()
-                    p = parse_hassl(text)
-                    # force package to declared or derived (declared will win)
-                    # If the file declared a package, keep it. Otherwise, assign the resolved module id.
-                    pkg_name = p.package or abs_mod
-                    p.package = pkg_name
-                    programs.append((candidate, p, pkg_name))
-                    known_pkgs.add(pkg_name)
-                    added = True
-                else:
+                if not candidate.exists():
                     print(f"[hasslc] Autoload candidate MISS for '{abs_mod}': {candidate}")
+                    seen_modules.add(abs_mod)  # mark as tried to avoid spamming
+                    continue
+
+                if candidate in seen_paths:
+                    # We’ve already parsed this exact file; mark its module and move on
+                    print(f"[hasslc] Autoload candidate SKIP (already loaded) for '{abs_mod}': {candidate}")
+                    seen_modules.add(abs_mod)
+                    continue
 
+                print(f"[hasslc] Autoload candidate FOUND for '{abs_mod}': {candidate}")
+                with open(candidate, "r", encoding="utf-8") as f:
+                    text = f.read()
+
+                p = parse_hassl(text)
+                # prefer declared package; otherwise bind to module id
+                pkg_name = p.package or abs_mod
+                p.package = pkg_name
+
+                programs.append((candidate, p, pkg_name))
+                known_pkgs.add(pkg_name)
+                seen_modules.add(abs_mod)
+                seen_paths.add(candidate)
+                added = True
+                
 def main():
     print("[hasslc] Using CLI file:", __file__)
     ap = argparse.ArgumentParser(prog="hasslc", description="HASSL Compiler")
@@ -197,174 +225,12 @@ def main():
 
     # Also drop a cross-project export table for debugging
     with open(out_root / "DEBUG_exports.json", "w", encoding="utf-8") as fp:
-        printable = {f"{k[0]}::{k[1]}::{k[2]}": ("Alias" if isinstance(v, Alias) else "Schedule") for k, v in GLOBAL_EXPORTS.items()}
-        json.dump(printable, fp, indent=2)
-    print(f"[hasslc] Global exports index written to {out_root / 'DEBUG_exports.json'}")
-
-if __name__ == "__main__":
-    main()
-import argparse
-import os, json, glob
-from pathlib import Path
-from typing import Dict, Tuple, List
-from .parser.loader import load_grammar_text
-from .parser.transform import HasslTransformer
-from .ast.nodes import Program, Alias, Schedule
-from lark import Lark
-from .semantics import analyzer as sem_analyzer
-from .semantics.analyzer import analyze
-from .codegen.package import emit_package
-from .codegen import generate as codegen_generate
-
-def parse_hassl(text: str) -> Program:
-    grammar = load_grammar_text()
-    parser = Lark(grammar, start="start", parser="lalr", maybe_placeholders=False)
-    tree = parser.parse(text)
-    program = HasslTransformer().transform(tree)
-    return program
-
-def _derive_package_name(prog: Program, src_path: Path, module_root: Path | None) -> str:
-    """
-    If the source did not declare `package`, derive one from the path:
-    - If module_root is given and src_path is under it: use relative path (dots)
-    - Else: use file stem
-    """
-    if getattr(prog, "package", None):
-        return prog.package  # declared
-    if module_root:
-        try:
-            rel = src_path.resolve().relative_to(module_root.resolve())
-            parts = list(rel.with_suffix("").parts)
-            if parts:
-                return ".".join(parts)
-        except Exception:
-            pass
-    return src_path.stem
-
-def _collect_public_exports(prog: Program, pkg: str) -> Dict[Tuple[str,str,str], object]:
-    """
-    Build (pkg, kind, name) -> node for public alias/schedule in a single Program.
-    Accepts both Schedule nodes and transformer dicts {"type":"schedule_decl",...}.
-    """
-    out: Dict[Tuple[str,str,str], object] = {}
-    # Aliases
-    for s in prog.statements:
-        if isinstance(s, Alias):
-            if not getattr(s, "private", False):
-                out[(pkg, "alias", s.name)] = s
-    # Schedules (either dicts from transformer or Schedule nodes)
-    for s in prog.statements:
-        if isinstance(s, Schedule):
-            if not getattr(s, "private", False):
-                out[(pkg, "schedule", s.name)] = s
-        elif isinstance(s, dict) and s.get("type") == "schedule_decl" and not s.get("private", False):
-            name = s.get("name")
-            if isinstance(name, str) and name.strip():
-                out[(pkg, "schedule", name)] = Schedule(name=name, clauses=s.get("clauses", []) or [], private=False)
-    return out
-
-def _scan_hassl_files(path: Path) -> List[Path]:
-    if path.is_file():
-        return [path]
-    return [Path(p) for p in glob.glob(str(path / "**" / "*.hassl"), recursive=True)]
-
-def _module_to_path(module_root: Path, module: str) -> Path:
-    return (module_root / Path(module.replace(".", "/"))).with_suffix(".hassl")
-
-def _ensure_imports_loaded(programs, module_root: Path):
-    """If imported packages aren't parsed yet, try to load their .hassl files from module_root."""
-    # programs: List[tuple[Path, Program, str]]
-    known_pkgs = {pkg for _, _, pkg in programs}
-    added = True
-    while added:
-        added = False
-        for _, prog, _pkg in list(programs):
-            for imp in getattr(prog, "imports", []) or []:
-                if not isinstance(imp, dict) or imp.get("type") != "import":
-                    continue
-                mod = imp.get("module", "")
-                if not mod or mod in known_pkgs:
-                    continue
-                if not module_root:
-                    continue
-                candidate = _module_to_path(module_root, mod)
-                if candidate.exists():
-                    print(f"[hasslc] Autoload candidate FOUND for '{mod}': {candidate}")
-                    with open(candidate, "r", encoding="utf-8") as f:
-                        text = f.read()
-                    p = parse_hassl(text)
-                    # force package to declared or derived (declared will win)
-                    pkg_name = p.package or mod
-                    p.package = pkg_name
-                    programs.append((candidate, p, pkg_name))
-                    known_pkgs.add(pkg_name)
-                    added = True
-                else:
-                    print(f"[hasslc] Autoload candidate MISS for '{mod}': {candidate}")
-
-def main():
-    ap = argparse.ArgumentParser(prog="hasslc", description="HASSL Compiler")
-    ap.add_argument("input", help="Input .hassl file OR directory")
-    ap.add_argument("-o", "--out", default="./packages/out", help="Output directory root for HA package(s)")
-    ap.add_argument("--module-root", default=None, help="Optional root to derive package names from paths")
-    args = ap.parse_args()
-
-    in_path = Path(args.input)
-    out_root = Path(args.out)
-    module_root = Path(args.module_root).resolve() if args.module_root else None
-
-    src_files = _scan_hassl_files(in_path)
-    if not src_files:
-        raise SystemExit(f"[hasslc] No .hassl files found in {in_path}")
-
-    # Pass 0: parse all and assign/derive package names
-    programs: List[tuple[Path, Program, str]] = []
-    for p in src_files:
-        with open(p, "r", encoding="utf-8") as f:
-            text = f.read()
-        prog = parse_hassl(text)
-        pkg_name = _derive_package_name(prog, p, module_root)
-        try:
-            prog.package = pkg_name
-        except Exception:
-            pass
-        programs.append((p, prog, pkg_name))
-
-    # auto-load any missing imports from --module_root
-    _ensure_imports_loaded(programs, module_root)
-    
-    # Pass 1: collect public exports across all programs
-    GLOBAL_EXPORTS: Dict[Tuple[str,str,str], object] = {}
-    for path, prog, pkg in programs:
-        GLOBAL_EXPORTS.update(_collect_public_exports(prog, pkg))
-
-    # publish global exports to analyzer
-    sem_analyzer.GLOBAL_EXPORTS = GLOBAL_EXPORTS
-
-    # Pass 2: analyze each program with global view
-    os.makedirs(out_root, exist_ok=True)
-    all_ir = []
-    for path, prog, pkg in programs:
-        print(f"[hasslc] Parsing {path}  (package: {pkg})")
-        print("[hasslc] AST:", json.dumps(prog.to_dict(), indent=2))
-        ir = analyze(prog)
-        print("[hasslc] IR:", json.dumps(ir.to_dict(), indent=2))
-        all_ir.append((pkg, ir))
-
-    # Emit: per package subdir
-    for pkg, ir in all_ir:
-        pkg_dir = out_root / pkg.replace(".", "_")
-        os.makedirs(pkg_dir, exist_ok=True)
-        ir_dict = ir.to_dict() if hasattr(ir, "to_dict") else ir
-        codegen_generate(ir_dict, str(pkg_dir))
-        emit_package(ir, str(pkg_dir))
-        with open(pkg_dir / "DEBUG_ir.json", "w", encoding="utf-8") as dbg:
-            dbg.write(json.dumps(ir.to_dict(), indent=2))
-        print(f"[hasslc] Package written to {pkg_dir}")
-
-    # Also drop a cross-project export table for debugging
-    with open(out_root / "DEBUG_exports.json", "w", encoding="utf-8") as fp:
-        printable = {f"{k[0]}::{k[1]}::{k[2]}": ("Alias" if isinstance(v, Alias) else "Schedule") for k, v in GLOBAL_EXPORTS.items()}
+        def _kind(v):
+            if isinstance(v, Alias): return "Alias"
+            if isinstance(v, Schedule): return "Schedule"
+            if isinstance(v, TemplateDecl): return "Template"
+            return type(v).__name__
+        printable = {f"{k[0]}::{k[1]}::{k[2]}": _kind(v) for k, v in GLOBAL_EXPORTS.items()}
         json.dump(printable, fp, indent=2)
     print(f"[hasslc] Global exports index written to {out_root / 'DEBUG_exports.json'}")
 

hassl/codegen/package.py

@@ -812,9 +812,13 @@ def emit_package(ir: IRProgram, outdir: str):
                 if isinstance(ts, dict):
                     return ts
                 if isinstance(ts, str):
+                    v = ts.strip()
                     # 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]}
+                    if len(v) == 5:   # HH:MM
+                        return {"kind":"clock","value": v}
+                    if len(v) == 8:   # HH:MM:SS
+                        return {"kind":"clock","value": v}
+                    return {"kind":"clock","value":"00:00"}
                 return {"kind":"clock","value":"00:00"}
             start_ts = _coerce(raw_start)
             end_ts   = _coerce(raw_end)

hassl/codegen/rules_min.py

@@ -331,10 +331,15 @@ def _collect_schedules(ir: dict):
     inline_by_rule = {}
     use_by_rule = {}
 
-    # top-level declared schedules
+    # top-level declared schedules (legacy clauses)
     schedules_obj = ir.get("schedules") or {}
     if isinstance(schedules_obj, dict):
         declared = {str(k): (v or []) for k, v in schedules_obj.items()}
+    # include window schedules as declared (no legacy clauses, but valid names)
+    windows_obj = ir.get("schedules_windows") or {}
+    if isinstance(windows_obj, dict):
+        for k in windows_obj.keys():
+            declared.setdefault(str(k), [])
 
     # per-rule data
     for rule in ir.get("rules", []):
@@ -359,7 +364,7 @@ def generate_rules(ir, outdir):
     # collect helper keys we must ensure exist
     ctx_inputs = {}
 
-    # package slug for schedule sensor ids
+    # package slug for output file naming
     pkg = _pkg_slug(outdir)
 
     # --- schedules collection ---
@@ -385,16 +390,14 @@ def generate_rules(ir, outdir):
         for nm in (use_by_rule.get(rname, []) or []):
             base = str(nm).split(".")[-1]
             if base not in declared_base_names and (base not in exported_sched_pkgs):
-                expected_sensor = _schedule_sensor(base, pkg)
                 raise ValueError(
                     "HASSL: schedule reference not found. "
                     f"Rule '{rname}' uses schedule '{nm}', but no schedule named '{base}' "
-                    f"was declared in this package '{pkg}'.\n\n"
+                    "was declared in this package.\n\n"
                     "Declare it with:\n"
                     f"  schedule {base}:\n"
                     "    enable from <start> to <end>;\n\n"
                     "Or ensure the schedule is declared in the same package.\n"
-                    f"(If you expected a sensor, codegen looks for: {expected_sensor})"
                 )
 
     # NOTE: No helper creation here — package.py owns schedule sensors.
@@ -415,15 +418,6 @@ def generate_rules(ir, outdir):
         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:
@@ -593,11 +587,11 @@ def generate_rules(ir, outdir):
                         "data": {"entity_id": full, "value": str(val)}
                     })
                 else:
-                    # Try light.turn_on data first; fallback to generic service data
-                    if eid.startswith("light."):
-                        act_list.append({"service": "light.turn_on", "target": {"entity_id": eid}, "data": {attr: val}})
-                    else:
-                        act_list.append({"service": "homeassistant.turn_on", "target": {"entity_id": eid}, "data": {attr: val}})
+                    # Unknown action type: log and skip (keeps generator robust)
+                    act_list.append({
+                        "service": "logbook.log",
+                        "data": {"name": "HASSL", "message": f"Unhandled action type: {act.get('type')}"}
+                    })
 
             conds = [gate_cond] + sched_conds + [cond_ha]
             if qual_cond:

hassl/parser/hassl.lark

@@ -2,6 +2,7 @@
 // + additive schedule support
 // + packages/imports + private visibility
 
+
 start: stmt*
 
 stmt: package_decl
@@ -11,6 +12,8 @@ stmt: package_decl
     | rule
     | schedule_decl
     | holidays_decl
+    | template_decl
+    | use_template_stmt
 
 // --- Aliases ---
 alias: PRIVATE? "alias" CNAME "=" entity //can mark private
@@ -18,11 +21,6 @@ alias: PRIVATE? "alias" CNAME "=" entity //can mark private
 // --- Sync ---
 sync: "sync" synctype "[" entity_list "]" "as" CNAME syncopts?
 
-ONOFF: "onoff"
-DIMMER: "dimmer"
-ATTRIBUTE: "attribute"
-SHARED: "shared"
-ALL: "all"
 synctype: ONOFF | DIMMER | ATTRIBUTE | SHARED | ALL
 
 syncopts: "{" ("invert" ":" entity_list) "}"
@@ -74,7 +72,7 @@ assign: CNAME "=" STATE ("for" dur)?
 attr_assign: CNAME "." CNAME ("." CNAME)* "." CNAME "=" NUMBER
            | CNAME "." CNAME "=" NUMBER
 
-waitact: "wait" "(" condition "for" dur ")" action
+waitact: "wait" "(" condition "for" (dur | CNAME | STRING) ")" action
 // condition used by wait(): allow expr + optional qualifier inside the parens
 condition: expr qualifier?
 
@@ -88,20 +86,6 @@ UNIT: "ms" | "s" | "m" | "h" | "d"
 // Timepoint placeholder (kept simple)
 timepoint: CNAME
 
-SCHEDULE: "schedule"
-USE: "use"
-FROM: "from"
-TO: "to"
-UNTIL: "until"
-ENABLE: "enable"
-DISABLE: "disable"
-SUNRISE: "sunrise"
-SUNSET: "sunset"
-PRIVATE: "private"
-
-TIME_HHMM: /[0-2]?\d:[0-5]\d/
-OFFSET: /[+-]\d+(ms|s|m|h|d)/
-
 // Reusable named schedule declarations
 schedule_decl: PRIVATE? SCHEDULE CNAME ":" schedule_clause+
 
@@ -132,9 +116,6 @@ MMDD: /\d{2}-\d{2}/
 ymd_range: YMD ".." YMD
 YMD: /\d{4}-\d{2}-\d{2}/
 
-WEEKDAYS: "weekdays"
-WEEKENDS: "weekends"
-DAILY:    "daily"
 day_selector: WEEKDAYS | WEEKENDS | DAILY
 time_range: TIME_HHMM "-" TIME_HHMM
 holiday_mod: "except" "holidays" CNAME
@@ -144,7 +125,7 @@ schedule_end: TO time_spec    -> schedule_to
             | UNTIL time_spec -> schedule_until
 
 // Rule-level usage
-rule_schedule_use: SCHEDULE USE name_list ";"
+rule_schedule_use: SCHEDULE USE name_list ";"?
 // allow qualified (pkg.symbol) via existing 'entity' rule
 name_list: name ("," name)*
 name: CNAME | entity
@@ -166,12 +147,41 @@ member: entity | CNAME
 
 entity: CNAME ("." CNAME)+
 
+
 // ---- Lexer ----
-%import common.CNAME
-%import common.WS
+// Order matters: keyword terminals first so they take precedence over CNAME
+SCHEDULE: "schedule"
+USE: "use"
+FROM: "from"
+TO: "to"
+UNTIL: "until"
+ENABLE: "enable"
+DISABLE: "disable"
+SUNRISE: "sunrise"
+SUNSET: "sunset"
+PRIVATE: "private"
+TEMPLATE: "template"
+
+ONOFF: "onoff"
+DIMMER: "dimmer"
+ATTRIBUTE: "attribute"
+SHARED: "shared"
+ALL: "all"
+WEEKDAYS: "weekdays"
+WEEKENDS: "weekends"
+DAILY:    "daily"
+
 %import common.ESCAPED_STRING -> STRING
 %import common.INT
 %import common.SIGNED_NUMBER
+%import common.WS
+
+// Override CNAME after keywords, so keywords win
+CNAME: /[a-zA-Z_][a-zA-Z0-9_]*/
+
+TIME_HHMM: /[0-2]?\d:[0-5]\d/
+OFFSET: /[+-]\d+(ms|s|m|h|d)/
+
 LINE_COMMENT: /\/\/[^\n]*/
 %ignore LINE_COMMENT
 %ignore WS
@@ -192,7 +202,7 @@ import_tail: ".*"
 import_list: import_item ("," import_item)*
 import_item: CNAME ("as" CNAME)?
 
-// ---- Holidays declaration (NEW) ----
+// ---- Holidays declaration ----
 // Example:
 // holidays us_ca:
 //   country="US", province="CA", add=["2025-11-28"], remove=["2025-12-26"]
@@ -207,4 +217,28 @@ daylist: DAY ("," DAY)*
 excludelist: ("sat"|"sun"|"holiday") ("," ("sat"|"sun"|"holiday"))*
 DAY.2: "mon"|"tue"|"wed"|"thu"|"fri"|"sat"|"sun"
 DATESTR: /"\d{4}-\d{2}-\d{2}"/
-datestr_list: DATESTR ("," DATESTR)*
+datestr_list: DATESTR ("," DATESTR)*
+
+// === Template
+template_decl: PRIVATE? TEMPLATE template_kind CNAME "(" template_params? ")" ":" template_body
+template_kind: "rule" | "sync" | "schedule"
+template_params: template_param ("," template_param)*
+template_param: CNAME ("=" template_default)?
+template_default: NUMBER | STRING | CNAME
+
+template_body: rule_body     -> template_rule_body
+             | sync_body     -> template_sync_body
+             | schedule_body -> template_schedule_body
+
+// --- Bodies used by template_body (define these ONCE) ---
+rule_body: rule_clause+                         // clauses without 'rule NAME:'
+sync_body: synctype "[" entity_list "]" syncopts?
+schedule_body: schedule_clause+                 // clauses without 'schedule NAME:'
+
+// Reuse existing pieces parsed elsewhere (no duplicates below this line)
+
+// --- Template invocation ---
+use_template_stmt: "use" "template" CNAME "(" call_args? ")" ("as" CNAME)?
+call_args: call_arg ("," call_arg)*
+call_arg: (CNAME "=" value) | value
+value: NUMBER | STRING | entity | CNAME

hassl/parser/transform.py

@@ -92,6 +92,11 @@ class HasslTransformer(Transformer):
     def import_tail(self, *args):
         if len(args) == 1 and isinstance(args[0], Token) and str(args[0]) == ".*":
             return ("glob", [], None)
+        # Some parses drop the literal "as" token; treat a single CNAME as alias target.
+        if len(args) == 1 and isinstance(args[0], (Token, str)):
+            val = str(args[0])
+            if val and val != ".*":
+                return ("alias", [], val)
         if len(args) == 2:
             a0, a1 = args
             if isinstance(a0, Token) and str(a0) == ":":
@@ -109,6 +114,107 @@ class HasslTransformer(Transformer):
             return {"name": str(parts[0]), "as": None}
         return {"name": str(parts[0]), "as": str(parts[-1])}
 
+    # ============ Templates (NEW) ============
+    # These are no-ops unless your grammar includes template_* rules.
+    # They simply build nodes and push them into self.stmts so the analyzer can expand them.
+
+    # template_decl: PRIVATE? TEMPLATE template_kind CNAME "(" template_params? ")" ":" template_body
+    def template_decl(self, *parts):
+        private = any(isinstance(p, Token) and p.type == "PRIVATE" for p in parts)
+        kind = next((str(p) for p in parts if isinstance(p, str) and p in ("rule","sync","schedule")), "rule")
+        name = None
+        params = []
+        body = None
+        seen_paren = False
+        for p in parts:
+            if isinstance(p, Token) and p.type == "CNAME" and name is None:
+                name = str(p); continue
+            # parameter list arrives as a python list (via template_params)
+            if isinstance(p, list) and p and isinstance(p[0], dict) and "name" in p[0]:
+                params = p; continue
+            # the first non-token/non-list after ':' should be the body node (Rule/Sync/Schedule body)
+            if not isinstance(p, (list, Token, str)) and p is not None:
+                body = p
+        t = nodes.TemplateDecl(kind=kind, name=str(name) if name else "", params=params, body=body, private=private)
+        self.stmts.append(t)
+        return t
+
+    def template_kind(self, *toks):
+        if not toks:
+            return "rule"
+        tok = toks[0]
+        return str(tok)
+
+    def template_params(self, *items):
+        return list(items)
+
+    # template_param: CNAME ("=" template_default)?
+    def template_param(self, name, default=None):
+        return {"name": str(name), "default": default}
+
+    # template_default: NUMBER | STRING | CNAME
+    def template_default(self, val):
+        return _atom(val)
+
+    # template_body variants – just forward the inner node as-is
+    def template_rule_body(self, body): return body
+    def template_sync_body(self, body): return body
+    def template_schedule_body(self, body): return body
+
+    # New: rule_body / schedule_body nodes for templates
+    def rule_body(self, *clauses):
+        # Produce a Rule node with empty name; analyzer will rename on instantiation
+        return nodes.Rule(name="", clauses=list(clauses))
+
+    def schedule_body(self, *clauses):
+        # Produce a Schedule node with empty name; analyzer will rename on instantiation
+        return nodes.Schedule(name="", clauses=list(clauses), windows=[])
+
+    def sync_body(self, synctype, members, syncopts=None):
+        invert = syncopts if isinstance(syncopts, list) else []
+        # name is filled later if you 'use template ... as <name>'
+        return nodes.Sync(kind=str(synctype), members=members, name="", invert=invert)
+
+    # use_template_stmt: "use" "template" CNAME "(" call_args? ")" ("as" CNAME)?
+    def use_template_stmt(self, *parts):
+        name = None
+        as_name = None
+        args = []
+        seen_as = False
+        for p in parts:
+            if isinstance(p, Token) and p.type == "CNAME":
+                if name is None:
+                    name = str(p)
+                elif seen_as and as_name is None:
+                    as_name = str(p)
+                # else: ignore stray CNAMEs (shouldn't happen if grammar is strict)
+                continue
+            if isinstance(p, list):
+                # call_args comes in as a list
+                args = p
+                continue
+            if isinstance(p, str) and p == "as":
+                seen_as = True
+                continue
+        u = nodes.UseTemplate(name=str(name) if name else "", args=args, as_name=as_name)
+        self.stmts.append(u)
+        return u
+
+    # call_args: call_arg ("," call_arg)*
+    def call_args(self, *items):
+        return list(items)
+
+    # call_arg: (CNAME "=" value) | value
+    def call_arg(self, *parts):
+        if len(parts) == 1:
+            return parts[0]
+        # name "=" value
+        return {"name": str(parts[0]), "value": parts[-1]}
+
+    # value: NUMBER | STRING | entity | CNAME
+    def value(self, v):
+        # Normalize to primitives/strings like other atoms; entities are already normalized by entity()
+        return _atom(v)
     # ============ Aliases / Sync ============
     def alias(self, *args):
         private = False
@@ -193,8 +299,11 @@ class HasslTransformer(Transformer):
         return {"type": "attr_assign", "entity": entity, "attr": attr, "value": value}
 
     def waitact(self, cond, dur, action):
-        return {"type": "wait", "condition": cond, "for": dur, "then": action}
+        return {"type": "wait", "condition": cond, "for": _atom(dur), "then": action}
 
+    def dur_arg(self, val):
+        return _atom(val)
+    
     def rulectrl(self, *parts):
         def s(x): return str(x) if isinstance(x, Token) else x
         vals = [s(p) for p in parts]
@@ -296,33 +405,6 @@ class HasslTransformer(Transformer):
     def time_spec(self, *children): return children[0] if children else None
     def rule_clause(self, item): return item
 
-    def sched_holiday_only(self, *args):
-        """
-        Handles:  on holidays <CNAME> HH:MM-HH:MM ;
-        Args arrive as ( 'on', 'holidays', <CNAME token>, time_range_tuple, ';' )
-        """
-        from lark import Token
-        
-        ident = None
-        start = None
-        end = None
-        
-        for a in args:
-            if isinstance(a, Token) and a.type == "CNAME":
-                ident = str(a)
-            elif isinstance(a, tuple) and a and a[0] == "time":
-                # ("time", "HH:MM", "HH:MM")
-                start, end = a[1], a[2]
-                
-        return nodes.ScheduleWindow(
-            start=str(start) if start is not None else "00:00",
-            end=str(end) if end is not None else "00:00",
-            day_selector="daily",
-            period=None,
-            holiday_ref=str(ident) if ident is not None else "",
-            holiday_mode="only",
-        )
-
     # -------- New windows & periods --------
     def schedule_window_clause(self, *parts):
         # Reset sticky day for each clause

hassl/semantics/analyzer.py

@@ -1,8 +1,10 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, is_dataclass, asdict
 from typing import Dict, List, Any, Optional, Tuple
+import copy
 from ..ast.nodes import (
     Program, Alias, Sync, Rule, Schedule,
     HolidaySet, ScheduleWindow, PeriodSelector,
+    TemplateDecl, UseTemplate,
     )
 from .domains import DOMAIN_PROPS, domain_of
 
@@ -60,6 +62,20 @@ class IRProgram:
             "schedules_windows": self.schedules_windows or {},  # NEW
         }
 
+def _resolve_module_id(raw_mod: str) -> str:
+    """
+    Map a raw import like 'hall.aliases' to the actual package id present in GLOBAL_EXPORTS,
+    e.g. 'home.hall.aliases'. If multiple candidates match, keep raw (fail gently).
+    """
+    if 'GLOBAL_EXPORTS' not in globals() or not raw_mod:
+        return raw_mod
+    # exact hit?
+    if any(pkg == raw_mod for (pkg, _k, _n) in globals()['GLOBAL_EXPORTS']):
+        return raw_mod
+    # suffix match (common when files declare 'home.hall.aliases' but source wrote 'hall.aliases')
+    candidates = {pkg for (pkg, _k, _n) in globals()['GLOBAL_EXPORTS'] if pkg.endswith("." + raw_mod)}
+    return next(iter(candidates)) if len(candidates) == 1 else raw_mod
+
 def _resolve_alias(e: str, amap: Dict[str,str]) -> str:
     if "." not in e and e in amap: return amap[e]
     return e
@@ -114,8 +130,148 @@ def analyze(prog: Program) -> IRProgram:
     local_schedule_windows: Dict[str, List[ScheduleWindow]] = {}
     local_holidays: Dict[str, HolidaySet] = {}
 
-    # 1) Collect local declarations (aliases & schedules)
-    for s in prog.statements:
+    # 0) Preprocess: collect templates and expand 'use template' into concrete nodes
+    templates_by_kind: Dict[str, Dict[str, TemplateDecl]] = {"rule": {}, "sync": {}, "schedule": {}}
+
+    # Collect modules this program imports (treat bare "import X" as glob, same as you already do)
+    imported_modules = set()
+    for imp in getattr(prog, "imports", []) or []:
+        if not isinstance(imp, dict) or imp.get("type") != "import":
+            continue
+        raw_mod = imp.get("module", "")
+        mod = _resolve_module_id(raw_mod)
+        
+        if not mod:
+            continue
+        # normalize kind the same way you do later
+        kind = imp.get("kind")
+        if kind not in ("glob", "list", "alias"):
+            if imp.get("items"): kind = "list"
+            elif imp.get("as"):  kind = "alias"
+            else:                kind = "glob"
+
+        if kind in ("glob", "list", "alias"):
+            imported_modules.add(mod)
+
+    # Helper: build arg map (params -> values) using defaults
+    def _bind_args(t: TemplateDecl, call_args: List[Any]) -> Dict[str, Any]:
+        params = list(t.params or [])
+        # normalize params: [{"name":..., "default":...}, ...]
+        pnames = [p.get("name") for p in params]
+        defaults = {p.get("name"): p.get("default") for p in params}
+        bound: Dict[str, Any] = dict(defaults)
+        # split named vs positional args from transformer
+        pos: List[Any] = []
+        named: Dict[str, Any] = {}
+        for a in call_args or []:
+            if isinstance(a, dict) and "name" in a:
+                named[str(a["name"])] = a.get("value")
+            else:
+                pos.append(a)
+        # apply positional
+        for i, v in enumerate(pos):
+            if i < len(pnames):
+                bound[pnames[i]] = v
+        # apply named (wins over positional/default)
+        for k, v in named.items():
+            if k in pnames:
+                bound[k] = v
+        return bound
+
+    # Deep substitute param identifiers appearing as bare strings in nested dict/list trees
+    def _deep_subst(obj: Any, subst: Dict[str, Any]) -> Any:
+        # strings: replace only if exactly matches a parameter name
+        if isinstance(obj, str):
+            return str(subst.get(obj, obj))
+        # dicts/lists: walk recursively
+        if isinstance(obj, dict):
+            return {k: _deep_subst(v, subst) for k, v in obj.items()}
+        if isinstance(obj, list):
+            return [_deep_subst(x, subst) for x in obj]
+        # leave everything else as-is (numbers, bools, None)
+        return obj
+
+    # Expand a single UseTemplate into a concrete node (Rule/Sync/Schedule)
+    def _instantiate(use: UseTemplate) -> Optional[Any]:
+        # Find matching template by name across kinds (prefer rule->sync->schedule)
+        t = None
+        for kind in ("rule", "sync", "schedule"):
+            t = templates_by_kind.get(kind, {}).get(use.name)
+            if t:
+                break
+        if not t:
+            return None
+        argmap = _bind_args(t, list(getattr(use, "args", []) or []))
+
+        if t.body is None:
+            # Provide minimal empty bodies so deep_subst & constructors don’t break
+            if t.kind == "rule":
+                t.body = Rule(name="", clauses=[])
+            elif t.kind == "sync":
+                t.body = Sync(kind="onoff", members=[], name="", invert=[])
+            elif t.kind == "schedule":
+                t.body = Schedule(name="", clauses=[], windows=[], private=False)
+        original = copy.deepcopy(t.body)
+        # Plainify dataclasses/objects so deep_subst can walk them
+        if is_dataclass(original):
+            plain = asdict(original)
+        elif hasattr(original, "__dict__"):
+            # shallow mapping of fields; they will typically be lists/dicts we can walk
+            plain = copy.deepcopy(vars(original))
+        else:
+            plain = original
+        subbed = _deep_subst(plain, argmap)
+
+        # Rename resulting node if caller provided "as <name>"
+        # Rename resulting node if caller provided "as <name>" or passed name= param
+        new_name = getattr(use, "as_name", None) or str(argmap.get("name") or t.name)
+
+        # Construct concrete AST node of same kind
+        if isinstance(t.body, Rule) or (getattr(t.body, "__class__", None).__name__ == "Rule"):
+            # subbed is a dict after plainify/subst
+            return Rule(name=new_name, clauses=subbed.get("clauses", getattr(original, "clauses", [])))
+        if isinstance(t.body, Sync) or (getattr(t.body, "__class__", None).__name__ == "Sync"):
+            return Sync(kind=subbed.get("kind", getattr(original, "kind", "onoff")),
+                        members=subbed.get("members", getattr(original, "members", [])),
+                        name=new_name,
+                        invert=subbed.get("invert", getattr(original, "invert", [])))
+        if isinstance(t.body, Schedule) or (getattr(t.body, "__class__", None).__name__ == "Schedule"):
+            return Schedule(name=new_name,
+                            clauses=subbed.get("clauses", getattr(original, "clauses", [])),
+                            windows=subbed.get("windows", getattr(original, "windows", [])),
+                            private=subbed.get("private", getattr(original, "private", False)))
+        return None
+
+    # Scan once to collect templates
+    for s in getattr(prog, "statements", []) or []:
+        if isinstance(s, TemplateDecl):
+            kind = (s.kind or "rule").lower()
+            if kind in templates_by_kind:
+                templates_by_kind[kind][s.name] = s
+
+    if 'GLOBAL_EXPORTS' in globals():
+        for (pkg, kind, name), node in globals()['GLOBAL_EXPORTS'].items():
+            if kind != "template":
+                continue
+            # bring templates from any imported module
+            if pkg in imported_modules and isinstance(node, TemplateDecl):
+                tkind = (node.kind or "rule").lower()
+                if tkind in templates_by_kind and name not in templates_by_kind[tkind]:
+                    templates_by_kind[tkind][name] = node
+
+    # Build a new statement list with uses expanded
+    expanded_statements: List[Any] = []
+    for s in getattr(prog, "statements", []) or []:
+        if isinstance(s, UseTemplate):
+            inst = _instantiate(s)
+            if inst is not None:
+                expanded_statements.append(inst)
+            # do not append the UseTemplate node itself
+        else:
+            expanded_statements.append(s)
+
+    # 1) Collect local declarations (aliases & schedules) from expanded statements
+    for s in expanded_statements:
         if isinstance(s, Alias):
             local_aliases[s.name] = s.entity
             is_private = getattr(s, "private", False)
@@ -173,7 +329,9 @@ def analyze(prog: Program) -> IRProgram:
         if not isinstance(imp, dict) or imp.get("type") != "import":
             # transformer may also append sentinels to statements; ignore here
             continue
-        mod = imp.get("module", "")
+        raw_mod = imp.get("module", "")
+        mod = _resolve_module_id(raw_mod)
+        
         kind = imp.get("kind")
         # Be generous: if transformer emitted "none" or omitted kind, infer it.
         if kind not in ("glob", "list", "alias"):
@@ -224,7 +382,7 @@ def analyze(prog: Program) -> IRProgram:
 
     # --- Syncs ---
     syncs: List[IRSync] = []
-    for s in prog.statements:
+    for s in expanded_statements:
         if isinstance(s, Sync):
             mem = [_resolve_alias(m,amap) for m in s.members]
             inv = [_resolve_alias(m,amap) for m in s.invert]
@@ -374,8 +532,22 @@ def analyze(prog: Program) -> IRProgram:
             if ent:
                 return ent
         return obj
+
+    # Resolve only qualified aliases (ns.alias) and leave unqualified aliases intact.
+    # This keeps existing IR expectations while making qualified references usable.
+    def _walk_qualified_only(obj: Any) -> Any:
+        if isinstance(obj, dict):
+            return {k: _walk_qualified_only(v) for k, v in obj.items()}
+        if isinstance(obj, list):
+            return [_walk_qualified_only(x) for x in obj]
+        if isinstance(obj, str):
+            if "." in obj:
+                ent = _resolve_qualified_alias(obj)
+                if ent:
+                    return ent
+        return obj
     
-    for s in prog.statements:
+    for s in expanded_statements:
         if isinstance(s, Rule):
             clauses: List[dict] = []
             schedule_uses: List[str] = []
@@ -387,8 +559,9 @@ def analyze(prog: Program) -> IRProgram:
                 # IfClause-like items have .condition/.actions
                 if hasattr(c, "condition") and hasattr(c, "actions"):
                     # Keep alias identifiers intact for tests & codegen (resolve later)
-                    cond = c.condition
-                    acts = c.actions
+                    # But resolve qualified aliases (ns.alias) so codegen gets real entities
+                    cond = _walk_qualified_only(c.condition)
+                    acts = _walk_qualified_only(c.actions)
                     clauses.append({"condition": cond, "actions": acts})
                 elif isinstance(c, dict) and c.get("type") == "schedule_use":
                     # {"type":"schedule_use","names":[...]}
@@ -407,6 +580,10 @@ def analyze(prog: Program) -> IRProgram:
                     for sc in c.get("clauses") or []:
                         if isinstance(sc, dict):
                             schedules_inline.append(sc)
+                elif isinstance(c, dict) and "condition" in c and "actions" in c:
+                    cond = _walk_alias_with_qualified(c["condition"])
+                    acts = _walk_alias_with_qualified(c["actions"])
+                    clauses.append({"condition": cond, "actions": acts})
                 else:
                     # ignore unknown fragments
                     pass

{hassl-0.3.2.dist-info → hassl-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hassl
-Version: 0.3.2
+Version: 0.4.0
 Summary: HASSL: Home Assistant Simple Scripting Language
 Home-page: https://github.com/adanowitz/hassl
 Author: adanowitz
@@ -17,7 +17,7 @@ Dynamic: license-file
 
 > **Home Assistant Simple Scripting Language**
 
-![Version](https://img.shields.io/badge/version-v0.3.1-blue)
+![Version](https://img.shields.io/badge/version-v0.4.0-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/).
 
@@ -30,7 +30,7 @@ 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)
+- **Weekday/weekend/holiday schedules** → full support for Home Assistant’s **Workday integration** (v0.4.0)
 - **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
@@ -148,7 +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)      |
+| `schedules_<pkg>.yaml`     | Time/sun-based schedule sensors (v0.4.0)      |
 
 ---
 
@@ -181,7 +181,7 @@ All schedules are restart-safe:
 
 ---
 
-## 🗓️ Holiday & Workday Integration (v0.3.1)
+## 🗓️ Holiday & Workday Integration (v0.4.0)
 
 HASSL now supports `holidays <id>:` schedules tied to Home Assistant’s **Workday** integration.
 
@@ -238,7 +238,7 @@ Once created, HASSL automatically references them in generated automations.
 
 ## ⚗️ Experimental: Date & Month Range Schedules
 
-HASSL v0.3.1 includes early support for:
+HASSL v0.4.0 includes early support for:
 
 ```hassl
 on months Jun–Aug 07:00–22:00;

hassl-0.4.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+hassl/__init__.py,sha256=42STGor_9nKYXumfeV5tiyD_M8VdcddX7CEexmibPBk,22
+hassl/cli.py,sha256=8y15glAYjHsJChaHefwqvoC5sz-l-pt9E9mWtzrt-Ik,9890
+hassl/ast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hassl/ast/nodes.py,sha256=Z6Ac5RrDEv6KNAAxdKQ3wrnnoHqbgP6-SDvda9Z8CNk,3254
+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=wruN26-wo64RBb94SxyEhG_4NIc6zBFcvOhGpuO_CIA,43289
+hassl/codegen/rules_min.py,sha256=3hiL0dUvlU9uIf1kc_BYcyTsaWGUBS787WkaIh1vZwk,28909
+hassl/codegen/yaml_emit.py,sha256=VTNnR_uvSSqsL7kX5NyXuPUZh5FK36a_sUFsRyrQOS8,2207
+hassl/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hassl/parser/hassl.lark,sha256=aBlZ609bZ-Wnrs5EsFukDqAIo5xLNQ6p2ruS5qmxtI8,6978
+hassl/parser/loader.py,sha256=xwhdoMkmXskanY8IhqIOfkcOkkn33goDnsbjzS66FL8,249
+hassl/parser/transform.py,sha256=xVz1fKjfxHbiTeUFuZJbVwctGWwd4cdvAPhfKgslwbs,25328
+hassl/semantics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hassl/semantics/analyzer.py,sha256=layYd1x_UajNPZN9Up_fp2dfApnBzCyeoG351nutpjU,28641
+hassl/semantics/domains.py,sha256=-OuhA4RkOLVaLnBxhKfJFjiQMYBSTryX9KjHit_8ezI,308
+hassl-0.4.0.dist-info/licenses/LICENSE,sha256=hPNSrn93Btl9sU4BkQlrIK1FpuFPvaemdW6-Scz-Xeo,1072
+hassl-0.4.0.dist-info/METADATA,sha256=Noo52fAx3gT0U5s0hrNMeia8BLnLgXnXsuSkhKpyZZE,9006
+hassl-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+hassl-0.4.0.dist-info/entry_points.txt,sha256=qA8jYPZlESNL6V4fJCTPOBXFeEBtjLGGsftXsSo82so,42
+hassl-0.4.0.dist-info/top_level.txt,sha256=BPuiULeikxMI3jDVLmv3_n7yjSD9Qrq58bp9af_HixI,6
+hassl-0.4.0.dist-info/RECORD,,

{hassl-0.3.2.dist-info → hassl-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

hassl-0.3.2.dist-info/RECORD

@@ -1,23 +0,0 @@
-hassl/__init__.py,sha256=vNiWJ14r_cw5t_7UDqDQIVZvladKFGyHH2avsLpN7Vg,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=7c0hQaGYQ80gNynMghyETFwqYGR3Xp1_RlqWAs9_qw4,43124
-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=73c1wmHaTydRDIcVjIEsQLmfFcylIOfQyqkLvNhFryM,5729
-hassl/parser/loader.py,sha256=xwhdoMkmXskanY8IhqIOfkcOkkn33goDnsbjzS66FL8,249
-hassl/parser/transform.py,sha256=Jg4y7bqrc14aA73SuvrfjyZlc6qs0LqqbNis5vzFqws,21721
-hassl/semantics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hassl/semantics/analyzer.py,sha256=m6AvDVLJPzbRKMXJMcMbRjD1Ppl67NI7WEVN1DLudRo,20220
-hassl/semantics/domains.py,sha256=-OuhA4RkOLVaLnBxhKfJFjiQMYBSTryX9KjHit_8ezI,308
-hassl-0.3.2.dist-info/licenses/LICENSE,sha256=hPNSrn93Btl9sU4BkQlrIK1FpuFPvaemdW6-Scz-Xeo,1072
-hassl-0.3.2.dist-info/METADATA,sha256=K7Da3-A3a0Ih17mfj6wNLy2VYnmRvx21AH4bc9mzqK8,9006
-hassl-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hassl-0.3.2.dist-info/entry_points.txt,sha256=qA8jYPZlESNL6V4fJCTPOBXFeEBtjLGGsftXsSo82so,42
-hassl-0.3.2.dist-info/top_level.txt,sha256=BPuiULeikxMI3jDVLmv3_n7yjSD9Qrq58bp9af_HixI,6
-hassl-0.3.2.dist-info/RECORD,,