python-library-automation 0.1.16__py3-none-any.whl

automation/renderer.py

@@ -0,0 +1,311 @@
+import ast
+import re
+import operator
+from typing import Any
+
+VARIABLE_RE = re.compile(r"\{([^{}]+)\}")
+_SINGLE_VAR_RE = re.compile(r"^\{([^{}]+)\}$")
+
+class Renderer:
+    """
+    渲染器 — 统一的变量解析、模板渲染、表达式求值引擎
+    
+    通过 derive() 创建子渲染器来注入局部作用域，
+    不可变设计，derive 不影响父渲染器。
+    """
+
+    def __init__(self, hub):
+        self._hub = hub
+        self._scopes: dict[tuple[str, str], dict[str, Any]] = {}
+
+    def derive(self, type_: str, scope: str, data: dict[str, Any]) -> "Renderer":
+        """创建带有新作用域的子渲染器"""
+        child = Renderer.__new__(Renderer)
+        child._hub = self._hub
+        child._scopes = {**self._scopes, (type_, scope): data}
+        return child
+
+    # ── 变量解析 ──
+
+    def resolve(self, token: str) -> Any:
+        """解析 type.scope.attr_path 变量"""
+        parts = token.split(".", 2)
+
+        if len(parts) == 2:
+            type_, scope = parts
+            if type_ == "entity":
+                if scope not in self._hub.entities:
+                    raise ValueError(f"Entity {scope!r} not found")
+                return self._hub.entities[scope]
+            key = (type_, scope)
+            if key in self._scopes:
+                return self._scopes[key]
+            raise ValueError(f"Cannot resolve variable: {{{token}}}")
+
+        if len(parts) < 2:
+            raise ValueError(
+                f"Invalid variable: {{{token}}}, "
+                f"expected {{type.scope.attribute}}"
+            )
+        type_, scope, attr_path = parts
+
+        # 局部作用域: event.local.xxx, action.local.xxx
+        key = (type_, scope)
+        if key in self._scopes:
+            return self._deep_get(self._scopes[key], attr_path)
+
+        # 全局: entity.instance_name.attr_path
+        if type_ == "entity":
+            return self._resolve_entity(scope, attr_path)
+
+        raise ValueError(f"Cannot resolve variable: {{{token}}}")
+
+    def render(self, template: str) -> str:
+        """将 {var} 占位符替换为实际值的字符串"""
+        def replace(match):
+            token = match.group(1).strip()
+            return str(self.resolve(token))
+        return VARIABLE_RE.sub(replace, template)
+
+    def render_value(self, value: Any) -> Any:
+        """递归解析值：纯变量引用返回原始对象，混合文本做字符串渲染"""
+        if isinstance(value, str):
+            m = _SINGLE_VAR_RE.match(value.strip())
+            if m:
+                return self.resolve(m.group(1).strip())
+            return self.render(value)
+        if isinstance(value, dict):
+            return {k: self.render_value(v) for k, v in value.items()}
+        if isinstance(value, list):
+            return [self.render_value(v) for v in value]
+        return value
+
+    def eval_bool(self, expr: str) -> bool:
+        """解析并求值布尔表达式，{var} 占位符会先解析为值"""
+        placeholders: dict[str, str] = {}
+        def replace(match):
+            token = match.group(1).strip()
+            name = f"_v{len(placeholders)}"
+            placeholders[name] = token
+            return name
+        parsed = VARIABLE_RE.sub(replace, expr)
+        tree = ast.parse(parsed, mode="eval")
+        _validate_ast(tree)
+        values = {
+            name: self.resolve(token)
+            for name, token in placeholders.items()
+        }
+        result = _safe_eval(tree.body, values)
+        if not isinstance(result, bool):
+            raise ValueError(
+                f"Expression must return bool, got {type(result).__name__}"
+            )
+        return result
+
+    def validate_token(self, token: str) -> None:
+        parts = token.split(".", 2)
+        if len(parts) < 2:
+            raise ValueError(f"Invalid variable format: {{{token}}}")
+
+        if len(parts) == 2:
+            type_, scope = parts
+            if type_ == "entity":
+                if scope not in self._hub.entities:
+                    raise ValueError(f"Entity {scope!r} not found")
+                return
+            if type_ in ("event", "action") and scope == "local":
+                return
+            raise ValueError(f"Unknown variable namespace: {type_}.{scope}")
+
+        type_, scope, attr_path = parts
+        if type_ == "entity":
+            if scope not in self._hub.entities:
+                raise ValueError(f"Entity {scope!r} not found")
+            entity = self._hub.entities[scope]
+            attr_root = attr_path.split(".")[0]
+            known = {a.name for a in entity.get_attributes()}
+            if attr_root not in known:
+                raise ValueError(
+                    f"Entity {scope!r} has no attribute {attr_root!r}, "
+                    f"available: {', '.join(sorted(known))}"
+                )
+            return
+        if type_ in ("event", "action") and scope == "local":
+            return
+        raise ValueError(f"Unknown variable namespace: {type_}.{scope}")
+
+    def validate_template(self, template: str) -> None:
+        for match in VARIABLE_RE.finditer(template):
+            self.validate_token(match.group(1).strip())
+
+    def validate_expr(self, expr: str) -> None:
+        self.validate_template(expr)
+        
+        cleaned = VARIABLE_RE.sub("True", expr)
+        try:
+            tree = ast.parse(cleaned, mode="eval")
+        except SyntaxError as e:
+            raise ValueError(f"Syntax error in expression: {expr!r}") from e
+        _validate_ast(tree)
+
+    def _resolve_entity(self, name: str, attr_path: str) -> Any:
+        if name not in self._hub.entities:
+            raise ValueError(f"Entity {name!r} not found")
+        entity = self._hub.entities[name]
+        parts = attr_path.split(".")
+
+        values = entity.get_attribute_values()
+        first = parts[0]
+        if first not in values:
+            raise ValueError(
+                f"{entity.__class__.__name__} {name!r} has no attribute path {attr_path!r}"
+            )
+        obj = values[first]
+
+        for part in parts[1:]:
+            if not hasattr(obj, part):
+                raise ValueError(
+                    f"{entity.__class__.__name__} {name!r} has no attribute path {attr_path!r}"
+                )
+            obj = getattr(obj, part)
+        return obj
+
+    @staticmethod
+    def _deep_get(data: dict, path: str) -> Any:
+        """从 dict 中按 . 分隔路径取值"""
+        current = data
+        for part in path.split("."):
+            if isinstance(current, dict):
+                if part not in current:
+                    raise ValueError(f"Key {part!r} not found in scope data")
+                current = current[part]
+            else:
+                if not hasattr(current, part):
+                    raise ValueError(f"Attribute {part!r} not found")
+                current = getattr(current, part)
+        return current
+
+_SAFE_NODES = (
+    ast.Expression, ast.BoolOp, ast.Compare, ast.UnaryOp,
+    ast.Constant, ast.Name, ast.Load, ast.Store, ast.And, ast.Or, ast.Not,
+    ast.Eq, ast.NotEq, ast.Lt, ast.LtE, ast.Gt, ast.GtE,
+    ast.Is, ast.IsNot, ast.In, ast.NotIn,
+    ast.List, ast.Tuple,
+    ast.Call,
+    ast.Attribute,
+    ast.ListComp, ast.GeneratorExp, ast.comprehension,
+)
+_SAFE_FUNCTIONS = frozenset({"any", "all"})
+
+_CMP_OPS = {
+    ast.Eq: operator.eq, ast.NotEq: operator.ne,
+    ast.Lt: operator.lt, ast.LtE: operator.le,
+    ast.Gt: operator.gt, ast.GtE: operator.ge,
+    ast.Is: operator.is_, ast.IsNot: operator.is_not,
+    ast.In: lambda a, b: a in b,
+    ast.NotIn: lambda a, b: a not in b,
+}
+
+def _validate_ast(tree: ast.AST) -> None:
+    for node in ast.walk(tree):
+        if not isinstance(node, _SAFE_NODES):
+            raise ValueError(f"Unsupported expression node: {type(node).__name__}")
+        if isinstance(node, ast.Call):
+            if (
+                not isinstance(node.func, ast.Name)
+                or node.func.id not in _SAFE_FUNCTIONS
+            ):
+                raise ValueError(
+                    f"Unsupported function: only {', '.join(_SAFE_FUNCTIONS)} allowed"
+                )
+            if node.keywords:
+                raise ValueError("Keyword arguments not supported in expressions")
+        if isinstance(node, ast.Attribute):
+            if node.attr.startswith("_"):
+                raise ValueError(
+                    f"Access to private attribute {node.attr!r} not allowed"
+                )
+        if isinstance(node, ast.comprehension):
+            if not isinstance(node.target, ast.Name):
+                raise ValueError(
+                    "Only simple variable names allowed in comprehension target"
+                )
+            if node.is_async:
+                raise ValueError("Async comprehensions not supported")
+
+def _safe_eval(node: ast.AST, values: dict[str, Any]) -> Any:
+    if isinstance(node, ast.BoolOp):
+        if isinstance(node.op, ast.And):
+            return all(_safe_eval(v, values) for v in node.values)
+        return any(_safe_eval(v, values) for v in node.values)
+
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
+        return not _safe_eval(node.operand, values)
+
+    if isinstance(node, ast.Compare):
+        left = _safe_eval(node.left, values)
+        for op, comparator in zip(node.ops, node.comparators):
+            right = _safe_eval(comparator, values)
+            op_func = _CMP_OPS.get(type(op))
+            if op_func is None:
+                raise ValueError(f"Unsupported compare op: {type(op).__name__}")
+            if not op_func(left, right):
+                return False
+            left = right
+        return True
+
+    if isinstance(node, ast.Constant):
+        return node.value
+
+    if isinstance(node, ast.Name):
+        if node.id not in values:
+            raise ValueError(f"Unknown variable: {node.id}")
+        return values[node.id]
+
+    if isinstance(node, (ast.List, ast.Tuple)):
+        return [_safe_eval(el, values) for el in node.elts]
+
+    if isinstance(node, ast.Attribute):
+        obj = _safe_eval(node.value, values)
+        if not hasattr(obj, node.attr):
+            raise ValueError(
+                f"{type(obj).__name__!r} has no attribute {node.attr!r}"
+            )
+        return getattr(obj, node.attr)
+
+    if isinstance(node, (ast.ListComp, ast.GeneratorExp)):
+        return _eval_comprehension(node.generators, 0, node.elt, values)
+
+    if isinstance(node, ast.Call):
+        func_name = node.func.id
+        args = [_safe_eval(a, values) for a in node.args]
+        fn = any if func_name == "any" else all
+        if len(args) == 1:
+            return fn(args[0])
+        if len(args) == 2:
+            items, attr = args
+            return fn(getattr(item, attr, False) for item in items)
+        raise ValueError(f"{func_name}() takes 1 or 2 arguments, got {len(args)}")
+        
+    raise ValueError(f"Cannot evaluate node: {type(node).__name__}")
+
+def _eval_comprehension(
+    generators: list[ast.comprehension],
+    gen_idx: int,
+    elt: ast.AST,
+    values: dict[str, Any],
+) -> list:
+    """递归求值推导式（支持多层 for 和 if 过滤）"""
+    if gen_idx >= len(generators):
+        return [_safe_eval(elt, values)]
+    gen = generators[gen_idx]
+    target_name = gen.target.id
+    iterable = _safe_eval(gen.iter, values)
+    results = []
+    for item in iterable:
+        inner = {**values, target_name: item}
+        if all(_safe_eval(cond, inner) for cond in gen.ifs):
+            results.extend(
+                _eval_comprehension(generators, gen_idx + 1, elt, inner)
+            )
+    return results

automation/schema.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
+
+from automation.core.entity import (
+    entity_registry, introspect_attributes, introspect_methods,
+)
+from automation.core.event import event_registry
+from automation.core.action import action_registry
+from automation.core.trigger import trigger_registry
+
+if TYPE_CHECKING:
+    from automation.hub import Hub
+
+SECTION_REGISTRIES = {
+    "entities": entity_registry,
+    "events": event_registry,
+    "actions": action_registry,
+    "triggers": trigger_registry,
+}
+
+
+def _field_schema(field_info) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    if field_info.annotation is not None:
+        result["type"] = getattr(field_info.annotation, "__name__", str(field_info.annotation))
+    if field_info.description:
+        result["description"] = field_info.description
+    if field_info.default is not None:
+        result["default"] = field_info.default
+    result["required"] = field_info.is_required()
+    return result
+
+
+def export_type_schema() -> dict[str, Any]:
+    result: dict[str, Any] = {}
+
+    for section, registry in SECTION_REGISTRIES.items():
+        section_types = {}
+        for reg_name in registry.get_registered_names():
+            short = reg_name.split(".")[-1]
+            cls = registry.get(short)
+
+            config_fields = {}
+            for name, field_info in cls.model_fields.items():
+                if name == "instance_name":
+                    continue
+                config_fields[name] = _field_schema(field_info)
+
+            type_info: dict[str, Any] = {"config_fields": config_fields}
+
+            if section == "entities":
+                type_info["attributes"] = [
+                    {
+                        "name": a.name, "type": a.type,
+                        "description": a.description,
+                        "readonly": a.readonly, "default": a.default,
+                    }
+                    for a in introspect_attributes(cls)
+                ]
+                type_info["methods"] = [
+                    {
+                        "name": m.name, "description": m.description,
+                        "params": m.params, "return_type": m.return_type,
+                    }
+                    for m in introspect_methods(cls)
+                ]
+
+            section_types[short] = type_info
+        result[section] = section_types
+
+    result["composite_actions"] = {
+        "description": "可复用的命名组合动作",
+        "fields": {
+            "params": {"type": "object", "description": "参数声明 {名称: 类型}"},
+            "conditions": {"type": "array", "description": "条件表达式列表"},
+            "actions": {"type": "array", "description": "子动作规格列表"},
+        },
+    }
+    return result
+
+
+def export_instance_schema(hub: Hub) -> dict[str, Any]:
+    from automation.core.entity import Entity
+
+    result: dict[str, Any] = {}
+
+    entities = {}
+    for name, entity in hub.entities.items():
+        info: dict[str, Any] = {"type": entity._type}
+        if isinstance(entity, Entity):
+            info["attributes"] = {
+                attr.name: {
+                    "type": attr.type,
+                    "value": getattr(entity, attr.name, None),
+                    "readonly": attr.readonly,
+                    "description": attr.description,
+                }
+                for attr in entity.get_attributes()
+            }
+            info["methods"] = [
+                {
+                    "name": m.name, "description": m.description,
+                    "params": m.params, "return_type": m.return_type,
+                }
+                for m in entity.get_methods()
+            ]
+        entities[name] = info
+    result["entities"] = entities
+
+    events = {}
+    for name, event in hub.events.items():
+        event_info: dict[str, Any] = {"type": event._type}
+        config = {}
+        for fname, finfo in event.model_fields.items():
+            if fname == "instance_name":
+                continue
+            config[fname] = getattr(event, fname)
+        event_info["config"] = config
+        events[name] = event_info
+    result["events"] = events
+
+    triggers = {}
+    for name, trigger in hub.triggers.items():
+        triggers[name] = {
+            "type": trigger._type,
+            "event": trigger.event,
+            "mode": trigger.mode,
+            "conditions": trigger.conditions,
+            "actions_count": len(trigger.actions),
+        }
+    result["triggers"] = triggers
+
+    actions = {}
+    for name, composite in hub.actions.items():
+        actions[name] = {
+            "params": composite.params,
+            "conditions": composite.conditions,
+            "actions_count": len(composite.action_specs),
+        }
+    result["actions"] = actions
+
+    return result

automation/updater.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+from automation.hub import Hub, State
+from automation.loader import build_section, build_actions
+
+logger = logging.getLogger(__name__)
+
+
+async def apply_diff(
+    hub: Hub, old: dict[str, Any], new: dict[str, Any]
+) -> None:
+    changed_refs: set[tuple[str, str]] = set()
+
+    all_sections = (*hub.AUTOMATION_SECTIONS, "actions")
+    for section_name in all_sections:
+        old_section = old.get(section_name, {})
+        new_section = new.get(section_name, {})
+        for name in set(old_section) | set(new_section):
+            if old_section.get(name) != new_section.get(name):
+                changed_refs.add((section_name, name))
+
+    # --- automation sections (entities, events, triggers) ---
+    for section_name in hub.AUTOMATION_SECTIONS:
+        old_section = old.get(section_name, {})
+        new_section = new.get(section_name, {})
+        current = hub.section(section_name)
+
+        for name in list(current):
+            if name not in new_section:
+                obj = current.pop(name)
+                await obj.on_stop()
+
+        for name, spec in new_section.items():
+            old_spec = old_section.get(name)
+            if name in current and old_spec == spec:
+                continue
+
+            if name in current:
+                obj = current[name]
+                if hub.state == State.RUNNING:
+                    await obj.on_stop()
+                raw_spec = dict(spec)
+                raw_spec.pop("type", None)
+                await obj.update(hub, raw_spec)
+                await obj.on_validate(hub)
+                await obj.on_update(hub)
+                await obj.on_activate(hub)
+                if hub.state == State.RUNNING:
+                    await obj.on_start()
+            else:
+                built = build_section(section_name, {name: spec})
+                obj = built[name]
+                obj._hub = hub
+                await obj.on_validate(hub)
+                await obj.on_activate(hub)
+                current[name] = obj
+                if hub.state == State.RUNNING:
+                    await obj.on_start()
+
+    # --- actions (CompositeAction) ---
+    old_actions_cfg = old.get("actions", {})
+    new_actions_cfg = new.get("actions", {})
+
+    for name in list(hub.actions):
+        if name not in new_actions_cfg:
+            del hub.actions[name]
+
+    if new_actions_cfg != old_actions_cfg:
+        new_composites = build_actions(new_actions_cfg)
+        hub.actions = new_composites
+        for composite in hub.actions.values():
+            composite.validate(hub)
+
+    # --- refresh affected triggers ---
+    for trigger in hub.triggers.values():
+        refs = {("events", trigger.event)}
+        for spec in trigger.actions:
+            type_name = spec.get("type", "")
+            refs.add(("actions", type_name))
+        if refs & changed_refs:
+            await trigger.on_validate(hub)
+            await trigger.on_activate(hub)

python_library_automation-0.1.16.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: python-library-automation
+Version: 0.1.16
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-library-registry
+Requires-Dist: python-library-scheduler
+Requires-Dist: python-library-watch-config

python_library_automation-0.1.16.dist-info/RECORD

@@ -0,0 +1,42 @@
+automation/__init__.py,sha256=gowCERBmUVqZ6aavHlXikw9emojRoa3XRf9SbkcyH2Q,551
+automation/assistant.py,sha256=7mlqPpckFlGm5CGWl_m9pydhK9CID-1Nt-gCuHo2RS0,4870
+automation/errors.py,sha256=ATAR5gMWFme3uqpN-ivMH6of1g7jTcfrdtGxCDxj7cs,1096
+automation/executor.py,sha256=ELThuvCRpN01dfM5xkxcgjfRDNuhlqF3tXMPp3pTqA8,1340
+automation/hub.py,sha256=L1IXxqO2TBmzMi8soSuLVKCoXCQrFgwnBRKOxWw35nI,1799
+automation/loader.py,sha256=RW76kVCfGiUYi8l-zwAVZbrLlGwtywNCSwvCpn8KUX4,4557
+automation/renderer.py,sha256=bM-9tNGzU5jGNZNzA_JxaoggSZBGEZ9cfTfYuLbeYcU,11892
+automation/schema.py,sha256=TJRm5Dij70dYLZ1hjuxt2Hn11pUVwBy97zz181XX03I,4944
+automation/updater.py,sha256=8KRkC4LCZ8SFVhB6HPPW9HxvLfQdk1ea1fmZV5fRhB4,3062
+automation/builtins/__init__.py,sha256=Azwf9VF0SI97Pt9wf-SD1zmedVyAEyQbo1WGliq5qW0,886
+automation/builtins/action/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+automation/builtins/action/call_entity_method.py,sha256=cjz_wal37AUapKPTmtMWVmP0EiF1cjaSSW1XtSXFBf8,1247
+automation/builtins/action/delay.py,sha256=x5EMoG1Hr0y2kuJLawYMHaoYZG5gvuwITUfM-C1zHDk,499
+automation/builtins/action/log.py,sha256=f9ZnLVZ8WcQI-Mj_qpZGY41Vcq7tRX9GUHR1pQxVejg,513
+automation/builtins/action/set_attribute.py,sha256=kpUmCvqDYIno73p3w1YzRMuOEGQ3sKfkO2QWq0bCODw,965
+automation/builtins/entity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+automation/builtins/entity/time.py,sha256=Dh1I8-twm7M5pZFgQXb3CcW6T1m6fCKHPYVW1xS0rnI,723
+automation/builtins/entity/variable.py,sha256=aGfN_AEPlFxcAjkzFFQUtwMreu0GTYmBC-hvKyDsSIQ,2928
+automation/builtins/event/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+automation/builtins/event/_scheduled.py,sha256=EnoIvra4PUx-9aqn0Q9gLoNE_SSMiJEX-_V2ztc3YkI,804
+automation/builtins/event/at.py,sha256=i0Lr0l89J1wvCHP9KG2yS37RSYvBkGC3_WCjSYhBn3A,726
+automation/builtins/event/callback.py,sha256=NsaEnlTTI1PdJ1Za-KXgTO5wqQi49x5e1HAiJ8tD1_Q,2208
+automation/builtins/event/every.py,sha256=Xqwu3Z_nM5EMYu1Vi29zCi2yB7sv1ul0v6oAIRsS0OA,1033
+automation/builtins/event/state_changed.py,sha256=nPVQTuxqtF3zxzY7zu3KO3ddov-QSR9Mp7pJCrTubOM,2000
+automation/core/__init__.py,sha256=YO2W5YwrRKmCG1ODsTX2G9_jLRZgxozIrP95XuUUy24,245
+automation/core/action.py,sha256=MGSnVoPxW2K5WKBaen_vUdHDjcaCLXMmmnJioOJSzJ0,532
+automation/core/base.py,sha256=uSSzsy63AHbZUUbc-2M_Y6jkpbCIVxUr9bJiUc7oeaQ,1872
+automation/core/composite_action.py,sha256=6uO9LKVllfP-FB7nKsZ_Rq3sWVt0MdZ1dk45gjSlCDw,1452
+automation/core/entity.py,sha256=NGXAWHDcJeKpiCOFvHmHm3a__Mi3LX1jgUTlPwAdj0c,5797
+automation/core/event.py,sha256=SRdS5KTNJctiJPNeVnJd6cPCDBjWizbxtrCp84dimQo,2995
+automation/core/event_context.py,sha256=YU1rTG83bJj78C9e-C-iWpnVpfB2n0B62L3we4bAa0s,345
+automation/core/trigger.py,sha256=1wP6cvWvgk05-OpkvirUbTktx4seDtFiHGOHklu4ycw,5416
+automation/listeners/__init__.py,sha256=qot61a5pfvfWpYwL-uKYrikfBPY9WP5MsUwIY4aLuzg,476
+automation/listeners/base.py,sha256=Iqh6kIbgagMWy4qPNx-fccriVl0FwA2NX2g3dqcHZe8,1327
+automation/listeners/console.py,sha256=NNyJWuBYQzHltcglZ1Q4BkY5RWM1dRLyfnGuhIejdoI,3172
+automation/listeners/instance_schema.py,sha256=3_ALaqLUjYv2ubYoLWT_KG4Ru04tfhAZRd7M9iKjyvU,808
+automation/listeners/record.py,sha256=zWgNBBdwg-JRiQjX7PfBczQ4-R4GpySBZUP0HdYAbLQ,887
+automation/listeners/trace.py,sha256=sKGFj1spItSvJdAiVk3mQ4XVRm-lME7X89FAbEivQyk,3199
+automation/listeners/type_schema.py,sha256=hEyGoVADpO8ePCG1LJiuB2yMj08xTa9pdUH0dI_Ilr8,793
+python_library_automation-0.1.16.dist-info/METADATA,sha256=98o5Fwx1sJRsuOt1EBcl8yyljVn_PyEVqcx2ZASQTCU,247
+python_library_automation-0.1.16.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_library_automation-0.1.16.dist-info/RECORD,,

python_library_automation-0.1.16.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any