hassl 0.2.0__py3-none-any.whl

hassl/codegen/yaml_emit.py

@@ -0,0 +1,77 @@
+# yaml_emit.py
+from typing import Any, Dict, Union
+from pathlib import Path
+import os
+
+HEADER = "# Generated by HASSL codegen\n"
+
+def ensure_dir(path: Union[str, Path]) -> None:
+    Path(path).mkdir(parents=True, exist_ok=True)
+
+def _deep_update(dst: Dict, src: Dict) -> Dict:
+    """Recursively merge src into dst (in-place) and return dst."""
+    for k, v in src.items():
+        if isinstance(v, dict) and isinstance(dst.get(k), dict):
+            _deep_update(dst[k], v)
+        else:
+            dst[k] = v
+    return dst
+
+def _load_yaml_or_empty(path: Path) -> Dict:
+    if not path.exists():
+        return {}
+    try:
+        import yaml
+        data = yaml.safe_load(path.read_text()) or {}
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        # If existing file is not valid YAML, ignore/overwrite
+        return {}
+
+def _dump_yaml(
+    path: Union[str, Path],
+    data: Any,
+    *,
+    header: bool = True,
+    merge: bool = True,
+    ensure_sections: bool = False,
+) -> None:
+    """
+    Write YAML to `path`.
+
+    - merge=True: deep-merge into existing file (if any) instead of overwriting.
+    - header=True: prepend the standard HASSL header line.
+    - ensure_sections=True: guarantee HA helper sections exist (input_text/input_boolean/input_number).
+
+    Backward compatible with previous signature: _dump_yaml(path, data)
+    """
+    p = Path(path)
+    ensure_dir(p.parent)
+
+    out: Dict = {}
+    if merge:
+        out = _load_yaml_or_empty(p)
+
+    # Deep-merge user data into 'out'
+    if isinstance(data, dict):
+        _deep_update(out, data)
+    else:
+        # If non-dict, just replace (can still honor header)
+        out = data
+
+    if ensure_sections and isinstance(out, dict):
+        out.setdefault("input_text", {})
+        out.setdefault("input_boolean", {})
+        out.setdefault("input_number", {})
+
+    try:
+        import yaml
+        body = yaml.safe_dump(out, sort_keys=False)
+        p.write_text((HEADER if header else "") + body)
+    except Exception:
+        # Fallback to JSON if PyYAML not available
+        import json
+        p.write_text(
+            (HEADER if header else "")
+            + json.dumps(out, indent=2)
+        )

hassl/parser/transform.py

@@ -0,0 +1,272 @@
+from lark import Transformer, v_args, Token
+from ..ast import nodes
+
+def _atom(val):
+    if isinstance(val, Token):
+        t = val.type
+        s = str(val)
+        if t in ("INT",):
+            return int(s)
+        if t in ("SIGNED_NUMBER","NUMBER"):
+            try:
+                return int(s)
+            except ValueError:
+                return float(s)
+        if t in ("CNAME", "STATE", "UNIT", "ONOFF", "DIMMER", "ATTRIBUTE", "SHARED", "ALL"):
+            return s
+        if t == "STRING":
+            return s[1:-1]
+    return val
+
+def _to_str(x):
+    return str(x) if not isinstance(x, Token) else str(x)
+
+@v_args(inline=True)
+class HasslTransformer(Transformer):
+    def __init__(self):
+        super().__init__()
+        self.stmts = []
+
+    # --- Program / Aliases / Syncs ---
+    def start(self, *stmts):
+        # We’ve been accumulating into self.stmts to preserve order.
+        return nodes.Program(statements=self.stmts)
+
+    def alias(self, name, entity):
+        a = nodes.Alias(name=str(name), entity=str(entity))
+        self.stmts.append(a)
+        return a
+
+    def sync(self, synctype, members, name, syncopts=None):
+        invert = []
+        if isinstance(syncopts, list):
+            invert = syncopts
+        s = nodes.Sync(kind=str(synctype), members=members, name=str(name), invert=invert)
+        self.stmts.append(s)
+        return s
+
+    def synctype(self, tok): return str(tok)
+    def syncopts(self, *args): return list(args)[-1] if args else []
+    def entity_list(self, *entities): return [str(e) for e in entities]
+    def member(self, val): return val
+    def entity(self, *parts): return ".".join(str(p) for p in parts)
+
+    # --- Rules / if_clause ---
+    def rule(self, name, *clauses):
+        # clauses may include IfClause nodes AND schedule_* dicts (we keep both).
+        r = nodes.Rule(name=str(name), clauses=list(clauses))
+        self.stmts.append(r)
+        return r
+
+    # if_clause: "if" "(" expr qualifier? ")" qualifier? "then" actions
+    def if_clause(self, *parts):
+        actions = parts[-1]
+        core = list(parts[:-1])
+        expr = core[0]
+        quals = [q for q in core[1:] if isinstance(q, dict) and "not_by" in q]
+
+        cond = {"expr": expr}
+        if quals:
+            cond.update(quals[-1])  # prefer last qualifier
+        return nodes.IfClause(condition=cond, actions=actions)
+
+    # --- Condition & boolean ops ---
+    def condition(self, expr, qual=None):
+        cond = {"expr": expr}
+        if qual is not None:
+            cond.update(qual)
+        return cond
+
+    def qualifier(self, *args):
+        sargs = [str(a) for a in args]
+        if len(sargs) == 1:
+            return {"not_by": sargs[0]}
+        if len(sargs) == 2 and sargs[0] == "rule":
+            return {"not_by": {"rule": sargs[1]}}
+        return {"not_by": "this"}
+
+    def or_(self, left, right):  return {"op": "or", "left": left, "right": right}
+    def and_(self, left, right): return {"op": "and", "left": left, "right": right}
+    def not_(self, term):        return {"op": "not", "value": term}
+
+    def comparison(self, left, op=None, right=None):
+        if op is None:
+            return left
+        return {"op": str(op), "left": left, "right": right}
+
+    def bare_operand(self, val): return _atom(val)
+    def operand(self, val): return _atom(val)
+    def OP(self, tok): return str(tok)
+
+    # --- Actions ---
+    def actions(self, *acts): return list(acts)
+    def action(self, act): return act
+
+    def dur(self, n, unit):
+        return f"{int(str(n))}{str(unit)}"
+
+    def assign(self, name, state, *for_parts):
+        act = {"type": "assign", "target": str(name), "state": str(state)}
+        if for_parts:
+            act["for"] = for_parts[0]
+        return act
+
+    def attr_assign(self, *parts):
+        value = _atom(parts[-1])
+        cnames = [str(p) for p in parts[:-1]]
+        attr = cnames[-1]
+        entity = ".".join(cnames[:-1])
+        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}
+
+    # Robust rule control
+    def rulectrl(self, *parts):
+        from lark import Token
+
+        def s(x):  # normalize tokens -> str/primitive
+            return str(x) if isinstance(x, Token) else x
+
+        vals = [s(p) for p in parts]
+
+        # op
+        op = None
+        for v in vals:
+            if isinstance(v, str) and v.lower() in ("disable", "enable"):
+                op = v.lower()
+                break
+        if not op:
+            op = "disable"
+
+        # name
+        name = None
+        keywords = {"rule", "for", "until", "disable", "enable"}
+        if "rule" in [str(v).lower() for v in vals if isinstance(v, str)]:
+            rs = [i for i, v in enumerate(vals) if isinstance(v, str) and v.lower() == "rule"]
+            for i in rs:
+                if i + 1 < len(vals):
+                    name = vals[i + 1]
+                    break
+        if name is None:
+            for v in vals:
+                if isinstance(v, str) and v.lower() not in keywords:
+                    name = v
+                    break
+        if name is None:
+            raise ValueError(f"rulectrl: could not determine rule name from parts={vals!r}")
+
+        # tail
+        payload = {}
+        try:
+            start_idx = vals.index(name) + 1
+        except ValueError:
+            start_idx = 1
+
+        i = start_idx
+        while i < len(vals):
+            v = vals[i]
+            vlow = str(v).lower() if isinstance(v, str) else ""
+            if vlow == "for" and i + 1 < len(vals):
+                payload["for"] = vals[i + 1]
+                i += 2
+                continue
+            if vlow == "until" and i + 1 < len(vals):
+                payload["until"] = vals[i + 1]
+                i += 2
+                continue
+            i += 1
+
+        if not payload:
+            units = ("ms", "s", "m", "h", "d")
+            for v in vals[start_idx:]:
+                if isinstance(v, str) and any(v.endswith(u) for u in units):
+                    payload["for"] = v
+                    break
+
+        if not payload:
+            payload["for"] = "0s"
+
+        return {"type": "rule_ctrl", "op": op, "rule": str(name), **payload}
+
+    def tagact(self, name, val):
+        return {"type": "tag", "name": str(name), "value": _atom(val)}
+
+    # ======================
+    # Schedules (composable)
+    # ======================
+
+    # schedule_decl: SCHEDULE CNAME ":" schedule_clause+
+    def schedule_decl(self, *parts):
+        # parts may look like:
+        #   (Token('SCHEDULE','schedule'), Token('CNAME','wake_hours'), <clause>...)
+        # or, depending on Lark settings, possibly without the SCHEDULE token.
+        idx = 0
+
+        # Skip leading SCHEDULE token if present
+        if idx < len(parts) and isinstance(parts[idx], Token) and parts[idx].type == "SCHEDULE":
+            idx += 1
+
+        # Grab the name (must be CNAME)
+        if idx >= len(parts):
+            raise ValueError("schedule_decl: missing schedule name")
+        name_tok = parts[idx]
+        name = str(name_tok)
+        idx += 1
+        
+        # Some setups might surface ':' as a token—skip if present
+        if idx < len(parts) and isinstance(parts[idx], Token) and str(parts[idx]) == ":":
+            idx += 1
+            
+            # Remaining items are (already-transformed) schedule_clause dicts
+        clauses = [c for c in parts[idx:] if isinstance(c, dict) and c.get("type") == "schedule_clause"]
+            
+        node = {"type": "schedule_decl", "name": name, "clauses": clauses}
+        self.stmts.append(node)
+        return node
+
+    # rule_schedule_use: SCHEDULE USE name_list ";"
+    def rule_schedule_use(self, _sched_kw, _use_kw, names, _semi=None):
+        return {"type": "schedule_use", "names": [str(n) for n in names]}
+
+    # rule_schedule_inline: SCHEDULE schedule_clause+
+    def rule_schedule_inline(self, _sched_kw, *clauses):
+        clist = [c for c in clauses if isinstance(c, dict) and c.get("type") == "schedule_clause"]
+        return {"type": "schedule_inline", "clauses": clist}
+
+    # schedule_clause: schedule_op FROM time_spec schedule_end? ";"
+    def schedule_clause(self, op, _from_kw, start, end=None, _semi=None):
+        d = {"type": "schedule_clause", "op": str(op), "from": start}
+        if isinstance(end, dict):
+            d.update(end)  # {"to": ...} or {"until": ...}
+        return d
+
+    # schedule_op: ENABLE | DISABLE
+    def schedule_op(self, tok):
+        return str(tok).lower()
+
+    # schedule_end: TO time_spec -> schedule_to
+    def schedule_to(self, _to_kw, ts):
+        return {"to": ts}
+
+    # schedule_end: UNTIL time_spec -> schedule_until
+    def schedule_until(self, _until_kw, ts):
+        return {"until": ts}
+
+    # name_list: CNAME ("," CNAME)*
+    def name_list(self, *names):
+        return [str(n) for n in names]
+
+    # time_spec: TIME_HHMM -> time_clock
+    def time_clock(self, tok):
+        return {"kind": "clock", "value": str(tok)}
+
+    # sun_spec: (SUNRISE|SUNSET) OFFSET? -> time_sun
+    def time_sun(self, event_tok, offset_tok=None):
+        event = str(event_tok).lower()
+        off = str(offset_tok) if offset_tok is not None else "0s"
+        return {"kind": "sun", "event": event, "offset": off}
+
+    # Unwrap rule_clause so clauses list contains IfClause nodes and/or dicts
+    def rule_clause(self, item):
+        return item

hassl/semantics/analyzer.py

@@ -0,0 +1,145 @@
+from dataclasses import dataclass
+from typing import Dict, List, Any, Optional
+from ..ast.nodes import Program, Alias, Sync, Rule
+from .domains import DOMAIN_PROPS, domain_of
+
+@dataclass
+class IRSyncedProp:
+    name: str
+
+@dataclass
+class IRSync:
+    name: str
+    kind: str
+    members: List[str]
+    invert: List[str]
+    properties: List[IRSyncedProp]
+
+@dataclass
+class IRRule:
+    name: str
+    clauses: List[dict]
+    schedule_uses: Optional[List[str]] = None
+    schedules_inline: Optional[List[dict]] = None
+
+@dataclass
+class IRProgram:
+    aliases: Dict[str, str]
+    syncs: List[IRSync]
+    rules: List[IRRule]
+    schedules: Optional[Dict[str, List[dict]]] = None
+    
+    def to_dict(self):
+        return {
+            "aliases": self.aliases,
+            "syncs": [{
+                "name": s.name, "kind": s.kind, "members": s.members,
+                "invert": s.invert, "properties": [p.name for p in s.properties]
+            } for s in self.syncs],
+            "rules": [{
+                "name": r.name,
+                "clauses": r.clauses,
+                "schedule_uses": r.schedule_uses or [],
+                "schedules_inline": r.schedules_inline or []
+            } for r in self.rules],
+            "schedules": self.schedules or {},
+        }
+
+def _resolve_alias(e: str, amap: Dict[str,str]) -> str:
+    if "." not in e and e in amap: return amap[e]
+    return e
+
+def _walk_alias(obj: Any, amap: Dict[str,str]) -> Any:
+    if isinstance(obj, dict): return {k:_walk_alias(v,amap) for k,v in obj.items()}
+    if isinstance(obj, list): return [_walk_alias(x,amap) for x in obj]
+    if isinstance(obj, str) and "." not in obj and obj in amap: return amap[obj]
+    return obj
+
+def _props_for_sync(kind: str, members: List[str]) -> List[IRSyncedProp]:
+    domains = [domain_of(m) for m in members]
+    prop_sets = [DOMAIN_PROPS.get(d, set()) for d in domains]
+    if kind == "shared":
+        if not prop_sets: return []
+        shared = set.intersection(*map(set, prop_sets))
+        return [IRSyncedProp(p) for p in sorted(shared)]
+    if kind == "all":
+        from collections import Counter
+        c = Counter()
+        for s in prop_sets:
+            for p in s: c[p]+=1
+        return [IRSyncedProp(p) for p,n in c.items() if n>=2]
+    if kind == "onoff":
+        return [IRSyncedProp("onoff")]
+    if kind == "dimmer":
+        base = {"onoff","brightness"}
+        if all("color_temp" in s for s in prop_sets):
+            base.add("color_temp")
+        return [IRSyncedProp(p) for p in sorted(base)]
+    return []
+
+def analyze(prog: Program) -> IRProgram:
+    # --- Aliases ---
+    amap: Dict[str,str] = {}
+    for s in prog.statements:
+        if isinstance(s, Alias):
+            amap[s.name] = s.entity
+
+    # --- Syncs ---
+    syncs: List[IRSync] = []
+    for s in prog.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]
+            props = _props_for_sync(s.kind, mem)
+            syncs.append(IRSync(s.name, s.kind, mem, inv, props))
+
+    # --- Top-level schedules (from transformer) ---
+    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)
+
+    # --- Rules (with schedule use/inline) ---
+    rules: List[IRRule] = []
+    for s in prog.statements:
+        if isinstance(s, Rule):
+            clauses: List[dict] = []
+            schedule_uses: List[str] = []
+            schedules_inline: List[dict] = []
+
+            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)
+                    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)])
+                elif isinstance(c, dict) and c.get("type") == "schedule_inline":
+                    # {"type":"schedule_inline","clauses":[...]}
+                    for sc in c.get("clauses") or []:
+                        if isinstance(sc, dict):
+                            schedules_inline.append(sc)
+                else:
+                    # ignore unknown fragments
+                    pass
+
+            rules.append(IRRule(
+                name=s.name,
+                clauses=clauses,
+                schedule_uses=schedule_uses,
+                schedules_inline=schedules_inline
+            ))
+
+    return IRProgram(
+        aliases=amap,
+        syncs=syncs,
+        rules=rules,
+        schedules=scheds
+    )

hassl/semantics/domains.py

@@ -0,0 +1,8 @@
+DOMAIN_PROPS = {
+    "light": {"onoff", "brightness", "color_temp", "hs_color"},
+    "switch": {"onoff"},
+    "fan": {"onoff", "percentage", "preset_mode"},
+    "media_player": {"onoff", "volume", "mute", "source", "play_state"},
+}
+def domain_of(entity_id: str) -> str:
+    return entity_id.split(".", 1)[0]

hassl-0.2.0.dist-info/METADATA

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: hassl
+Version: 0.2.0
+Summary: HASSL: Home Assistant Simple Scripting Language
+Home-page: https://github.com/adanowitz/hassl
+Author: adanowitz
+Author-email: adanowitz@gmail.com
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lark-parser
+Requires-Dist: jinja2
+Requires-Dist: pyyaml
+Dynamic: license-file
+
+# HASSL
+
+> **Home Assistant Simple Scripting Language**
+
+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.
+
+---
+
+## 🚀 Features
+
+- **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`)
+- **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`
+- **Auto-reload resilience** → schedules re-evaluate automatically on HA restart
+
+---
+
+## 🧰 Example
+
+```hassl
+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;
+
+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
+```
+
+Produces a complete Home Assistant package with:
+
+- Helpers (`input_boolean`, `input_text`, `input_number`)
+- Context-aware writer scripts
+- Sync automations for linked devices
+- Rule-based automations with schedules and `not_by` guards
+
+---
+
+## 🏗 Installation
+
+```bash
+git clone https://github.com/adanowitz/hassl.git
+cd hassl
+pip install -e .
+```
+
+Verify:
+
+```bash
+hasslc --help
+```
+
+---
+
+## ⚙️ Usage
+
+1. Create a `.hassl` script (e.g., `living_room.hassl`).
+2. Compile it into a Home Assistant package:
+   ```bash
+   hasslc living_room.hassl -o ./packages/living_room/
+   ```
+3. Copy the package into `/config/packages/` and reload automations.
+
+Each `.hassl` file compiles into an isolated package — no naming collisions, no shared helpers.
+
+---
+
+## 📦 Output Files
+
+| File                       | Description                                   |
+| -------------------------- | --------------------------------------------- |
+| `helpers_<pkg>.yaml`       | Defines all helpers (booleans, text, numbers) |
+| `scripts_<pkg>.yaml`       | Writer scripts with context stamping          |
+| `sync_<pkg>_*.yaml`        | Sync automations for each property            |
+| `rules_bundled_<pkg>.yaml` | Rule logic automations + schedules            |
+
+---
+
+## 🧠 Concepts
+
+| Concept      | Description                                                     |
+| ------------ | --------------------------------------------------------------- |
+| **Alias**    | Maps short names to HA entities (`alias light = light.kitchen`) |
+| **Sync**     | Keeps multiple devices aligned across on/off, brightness, etc.  |
+| **Rule**     | Defines reactive logic with guards, waits, and control flow.    |
+| **Schedule** | Defines active time windows, reusable across rules.             |
+| **Tag**      | Lightweight metadata stored in `input_text` helpers.            |
+
+---
+
+## 🔒 Loop Safety & Context Tracking
+
+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.
+
+---
+
+## 🕒 Schedules That Survive Restarts
+
+All schedules are restart-safe:
+
+- `input_boolean.hassl_schedule_<name>` automatically re-evaluates on startup.
+- Triggers are set for both start and end times.
+- Missed events (like mid-day restarts) are recovered automatically.
+
+---
+
+## 📚 Documentation
+
+For full grammar and detailed semantics, see the [HASSL Language Specification](./HASSL_Specification.md).
+
+For a hands-on guide, check out the [Quickstart](./quickstart.md).
+
+---
+
+## 🧩 Contributing
+
+Contributions, tests, and ideas welcome!\
+To run tests locally:
+
+```bash
+pytest tests/
+```
+
+Please open pull requests for grammar improvements, new device domains, or scheduling logic.
+
+---
+
+## 📄 License
+
+MIT License © 2025\
+Created and maintained by [@adanowitz](https://github.com/adanowitz)
+
+---
+
+**HASSL** — simple, reliable, human-readable automations for Home Assistant.
+

hassl-0.2.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+hassl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hassl/cli.py,sha256=rp9C-W-Jy_Lxb9sw2mXR-3_KRLTBil5Xy5q5EYdLZT8,1503
+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/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.0.dist-info/licenses/LICENSE,sha256=hPNSrn93Btl9sU4BkQlrIK1FpuFPvaemdW6-Scz-Xeo,1072
+hassl-0.2.0.dist-info/METADATA,sha256=OBOKVzmNcsFlcVZyEp0YF6Z912-FStNKntSUd-0F96A,4929
+hassl-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hassl-0.2.0.dist-info/entry_points.txt,sha256=qA8jYPZlESNL6V4fJCTPOBXFeEBtjLGGsftXsSo82so,42
+hassl-0.2.0.dist-info/top_level.txt,sha256=BPuiULeikxMI3jDVLmv3_n7yjSD9Qrq58bp9af_HixI,6
+hassl-0.2.0.dist-info/RECORD,,