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

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]
@@ -239,6 +397,33 @@ def analyze(prog: Program) -> IRProgram:
 
     # NEW: collect structured windows (serialize to plain dicts)
     sched_windows: Dict[str, List[dict]] = {}
+
+ # --- helpers: normalization for day selector & holiday mode ---
+    def _norm_day_selector(ds: Optional[str]) -> str:
+        s = (ds or "").strip().lower()
+        if s in ("weekdays", "weekday", "wd", "mon-fri", "monfri"):
+            return "weekdays"
+        if s in ("weekends", "weekend", "we", "sat-sun", "satsun"):
+            return "weekends"
+        return "daily"
+
+    def _norm_holiday_mode(mode: Optional[str]) -> Optional[str]:
+        """
+        Normalize holiday text to {'only','except',None}.
+        Accepts variants like:
+        'holiday', 'only holiday', 'holiday only' -> 'only'
+        'except holiday', 'exclude holiday', 'unless holiday', 'not holiday' -> 'except'
+        """
+        if mode is None:
+            return None
+        m = str(mode).strip().lower().replace("_", " ").replace("-", " ")
+        # look for negation/exclusion first
+        if any(tok in m for tok in ("except", "exclude", "unless", "not")):
+            return "except"
+        if "holiday" in m or "only" in m:
+            return "only"
+        return None
+
     for nm, wins in local_schedule_windows.items():
         out: List[dict] = []
         for w in wins:
@@ -249,14 +434,23 @@ def analyze(prog: Program) -> IRProgram:
             if getattr(w, "period", None):
                 p = w.period  # PeriodSelector
                 period = {"kind": p.kind, "data": dict(p.data)}
+
+            # --- normalize selectors & holiday mode ---
+            day_sel = _norm_day_selector(getattr(w, "day_selector", None))
+            href    = getattr(w, "holiday_ref", None)
+            hmode   = _norm_holiday_mode(getattr(w, "holiday_mode", None))
+            # Heuristic default: if a weekdays/weekends selector references a holiday
+            # set and no mode provided, treat as "except" (workday semantics).
+            if href and hmode is None and day_sel in ("weekdays", "weekends"):
+                hmode = "except"
             out.append({
                 "start": w.start,
                 "end": w.end,
-                "day_selector": w.day_selector,
+                "day_selector": day_sel,
                 "period": period,
-                "holiday_ref": w.holiday_ref,
-                "holiday_mode": w.holiday_mode,
-           })
+                "holiday_ref": href,
+                "holiday_mode": hmode,
+            })
         if out:
             sched_windows[nm] = out
 
@@ -338,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] = []
@@ -351,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":[...]}
@@ -371,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
@@ -386,6 +599,16 @@ def analyze(prog: Program) -> IRProgram:
     # -------- NEW: validate schedule windows --------
     allowed_days = {"weekdays", "weekends", "daily"}
     for sched_name, wins in sched_windows.items():
+        # Normalize holiday modes defensively:
+        # If a window references a holiday set and also specifies a day bucket,
+        # it should be "except" (non-holiday behavior). We keep pure holiday-only
+        # windows (`day_selector == "daily"`) as "only".
+        for w in wins:
+            ds = (w.get("day_selector") or "daily").lower()
+            href = w.get("holiday_ref")
+            hmode = w.get("holiday_mode")
+            if href and ds in ("weekdays", "weekends") and (hmode is None or hmode == "only"):
+                w["holiday_mode"] = "except"
         for w in wins:
             ds = w.get("day_selector")
             if ds not in allowed_days:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hassl
-Version: 0.3.1
+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.1.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.1.dist-info/RECORD

@@ -1,23 +0,0 @@
-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,,