python-library-automation 0.1.16__tar.gz

python_library_automation-0.1.16/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.venv/
+.env
+.pytest_cache/
+config.yaml
+logs/

python_library_automation-0.1.16/PKG-INFO

@@ -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/automation/__init__.py

@@ -0,0 +1,25 @@
+from .core import (
+    Action,
+    Entity,
+    Trigger,
+    Event,
+)
+from .assistant import Assistant
+from .listeners import BaseListener, ConsoleListener, TraceListener, TypeSchemaListener, InstanceSchemaListener
+from .renderer import Renderer
+
+from . import builtins  # noqa: F401  触发自动注册
+
+__all__ = [
+    "Action",
+    "Entity",
+    "Trigger",
+    "Event",
+    "Assistant",
+    "BaseListener",
+    "ConsoleListener",
+    "TraceListener",
+    "TypeSchemaListener",
+    "InstanceSchemaListener",
+    "Renderer",
+]

python_library_automation-0.1.16/automation/assistant.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any
+
+from configlib import load_config
+from watch_config import WatchConfig
+
+from automation.hub import Hub, State
+from automation.core import Entity, Event, Trigger, BaseAutomation
+from automation.core.composite_action import CompositeAction
+from automation import loader, updater, schema
+from automation.listeners import BaseListener
+
+logger = logging.getLogger(__name__)
+
+
+class Assistant:
+    def __init__(self, listeners: list[BaseListener] | BaseListener | None = None) -> None:
+        self._hub = Hub()
+        if listeners is not None:
+            if isinstance(listeners, BaseListener):
+                listeners = [listeners]
+            self._hub.listeners = listeners
+        self._watcher: WatchConfig[dict] | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._reload_lock = asyncio.Lock()
+
+    @property
+    def entities(self) -> dict[str, Entity]:
+        return self._hub.entities
+
+    @property
+    def events(self) -> dict[str, Event]:
+        return self._hub.events
+
+    @property
+    def actions(self) -> dict[str, CompositeAction]:
+        return self._hub.actions
+
+    @property
+    def triggers(self) -> dict[str, Trigger]:
+        return self._hub.triggers
+
+    def section(self, name: str) -> dict[str, BaseAutomation]:
+        return self._hub.section(name)
+
+    async def load(
+        self, source: str | Path | dict, watch: bool = False
+    ) -> Assistant:
+        if watch and isinstance(source, dict):
+            raise TypeError(
+                "watch=True requires a file path, dict is not supported"
+            )
+        config = _read_source(source)
+        await loader.load(self._hub, config)
+        self._hub.notify("on_loaded", self._hub)
+        if watch:
+            self._watcher = WatchConfig(Path(source), dict)
+            self._watcher(self._on_config_change)
+        return self
+
+    async def start(self) -> Assistant:
+        if self._hub.state == State.RUNNING:
+            return self
+        self._hub.state = State.RUNNING
+        self._hub.stop_event.clear()
+        self._loop = asyncio.get_running_loop()
+        for section_name in self._hub.AUTOMATION_SECTIONS:
+            for obj in self._hub.section(section_name).values():
+                await obj.on_start()
+        if self._watcher is not None:
+            self._watcher.start()
+        self._hub.notify("on_start")
+        return self
+
+    async def run(self) -> Assistant:
+        await self.start()
+        await self._hub.stop_event.wait()
+        return self
+
+    async def stop(self) -> None:
+        if self._hub.state != State.RUNNING:
+            return
+        self._hub.state = State.STOPPED
+        if self._watcher:
+            self._watcher.stop()
+        for section_name in reversed(self._hub.AUTOMATION_SECTIONS):
+            for obj in self._hub.section(section_name).values():
+                await obj.on_stop()
+        self._hub.stop_event.set()
+        self._hub.notify("on_stop")
+
+    async def update(self, source: str | Path | dict) -> None:
+        """手动热更新"""
+        new_config = _read_source(source)
+        await self._apply_reload(new_config)
+
+    def watch(self, path: str | Path, interval: float = 2.0) -> Assistant:
+        """设置文件监控"""
+        if self._watcher:
+            self._watcher.stop()
+        self._watcher = WatchConfig(Path(path), dict, interval=interval)
+        self._watcher(self._on_config_change)
+        if self._hub.state == State.RUNNING:
+            self._watcher.start()
+        return self
+
+    def _on_config_change(self, cfg: dict, changelog) -> None:
+        if self._loop is None or self._loop.is_closed():
+            return
+        asyncio.run_coroutine_threadsafe(
+            self._apply_reload(cfg), self._loop
+        )
+
+    async def _apply_reload(self, new_config: dict) -> None:
+        async with self._reload_lock:
+            old_config = self._hub.config
+            if old_config == new_config:
+                return
+            await updater.apply_diff(self._hub, old_config, new_config)
+            self._hub.config = new_config
+            self._hub.notify("on_loaded", self._hub)
+
+    @staticmethod
+    def export_schema() -> dict:
+        from automation.schema import export_type_schema
+        return export_type_schema()
+
+
+def _read_source(source: str | Path | dict) -> dict[str, Any]:
+    if isinstance(source, (str, Path)):
+        data = load_config(str(source))
+        if not isinstance(data, dict):
+            raise TypeError(
+                f"Config root must be a dict, got {type(data).__name__}"
+            )
+        return data
+    return source

python_library_automation-0.1.16/automation/builtins/__init__.py

@@ -0,0 +1,27 @@
+import importlib
+import pkgutil
+from pathlib import Path
+
+def _auto_import():
+    """自动导入 builtins 下所有子模块，触发类的注册"""
+    package_dir = Path(__file__).resolve().parent
+    for sub_pkg in package_dir.iterdir():
+        if not sub_pkg.is_dir() or sub_pkg.name.startswith("_"):
+            continue
+        sub_package = f"{__name__}.{sub_pkg.name}"
+        try:
+            pkg = importlib.import_module(sub_package)
+        except ImportError:
+            continue
+        pkg_path = getattr(pkg, "__path__", None)
+        if pkg_path is None:
+            continue
+        for _finder, module_name, _is_pkg in pkgutil.walk_packages(
+            pkg_path, prefix=f"{sub_package}."
+        ):
+            try:
+                importlib.import_module(module_name)
+            except ImportError:
+                pass
+
+_auto_import()

python_library_automation-0.1.16/automation/builtins/action/call_entity_method.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+import inspect
+from typing import ClassVar, TYPE_CHECKING
+from pydantic import Field
+from automation.core import Action
+
+if TYPE_CHECKING:
+    from automation.renderer import Renderer
+
+
+class CallEntityMethod(Action):
+    _abstract: ClassVar[bool] = False
+    _type: ClassVar[str] = "call_entity_method"
+
+    entity: str = Field(description="实体名称")
+    method: str = Field(description="方法名称")
+    args: dict = Field(default_factory=dict, description="方法参数")
+
+    async def execute(self, renderer: Renderer) -> None:
+        hub = renderer._hub
+        if self.entity not in hub.entities:
+            raise ValueError(f"Entity {self.entity!r} not found")
+        entity = hub.entities[self.entity]
+        if not hasattr(entity, self.method):
+            raise ValueError(
+                f"Entity {self.entity!r} has no method {self.method!r}"
+            )
+        method = getattr(entity, self.method)
+        if not callable(method):
+            raise ValueError(
+                f"Entity {self.entity!r}.{self.method} is not callable"
+            )
+        result = method(**self.args)
+        if inspect.isawaitable(result):
+            await result

python_library_automation-0.1.16/automation/builtins/action/delay.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from typing import ClassVar, TYPE_CHECKING
+import asyncio
+from pydantic import Field
+from automation.core import Action
+
+if TYPE_CHECKING:
+    from automation.renderer import Renderer
+
+
+class DelayAction(Action):
+    _type: ClassVar[str] = "delay"
+    _abstract: ClassVar[bool] = False
+
+    seconds: float = Field(ge=0, description="等待秒数")
+
+    async def execute(self, renderer: Renderer) -> None:
+        await asyncio.sleep(self.seconds)

python_library_automation-0.1.16/automation/builtins/action/log.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+from typing import ClassVar, TYPE_CHECKING
+import logging
+from pydantic import Field
+from automation.core import Action
+
+if TYPE_CHECKING:
+    from automation.renderer import Renderer
+
+logger = logging.getLogger(__name__)
+
+
+class LogAction(Action):
+    _type: ClassVar[str] = "log"
+    _abstract: ClassVar[bool] = False
+
+    info: str = Field(description="日志内容")
+
+    async def execute(self, renderer: Renderer) -> None:
+        logger.info(self.info)

python_library_automation-0.1.16/automation/builtins/action/set_attribute.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+from typing import Any, ClassVar, TYPE_CHECKING
+from pydantic import Field
+from automation.core import Action
+
+if TYPE_CHECKING:
+    from automation.renderer import Renderer
+
+
+class SetAttributeAction(Action):
+    _abstract: ClassVar[bool] = False
+    _type: ClassVar[str] = "set_attribute"
+
+    entity: str = Field(description="实体名称")
+    attribute: str = Field(description="属性名称")
+    value: Any = Field(description="新值")
+
+    async def execute(self, renderer: Renderer) -> None:
+        hub = renderer._hub
+        if self.entity not in hub.entities:
+            raise ValueError(f"Entity {self.entity!r} not found")
+        entity = hub.entities[self.entity]
+        if not hasattr(entity, self.attribute):
+            raise ValueError(
+                f"Entity {self.entity!r} has no attribute {self.attribute!r}"
+            )
+        setattr(entity, self.attribute, self.value)

python_library_automation-0.1.16/automation/builtins/entity/time.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+from datetime import datetime
+from typing import ClassVar
+from automation.core import Entity
+
+
+class TimeEntity(Entity):
+    _abstract: ClassVar[bool] = False
+    _type: ClassVar[str] = "time"
+
+    @property
+    def hour(self) -> int:
+        """当前小时 (0-23)"""
+        return datetime.now().hour
+
+    @property
+    def minute(self) -> int:
+        """当前分钟 (0-59)"""
+        return datetime.now().minute
+
+    @property
+    def second(self) -> int:
+        """当前秒 (0-59)"""
+        return datetime.now().second
+
+    @property
+    def weekday(self) -> int:
+        """星期几 (0=周一, 6=周日)"""
+        return datetime.now().weekday()

python_library_automation-0.1.16/automation/builtins/entity/variable.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+from typing import Any, ClassVar, TYPE_CHECKING
+from pydantic import Field, PrivateAttr
+from automation.core import Entity
+from automation.core.entity import AttributeInfo
+
+if TYPE_CHECKING:
+    from automation.hub import Hub
+
+TYPE_MAP = {"int": int, "float": float, "str": str, "bool": bool}
+
+
+class VariableEntity(Entity):
+    _abstract: ClassVar[bool] = False
+    _type: ClassVar[str] = "variable"
+
+    properties: dict[str, dict[str, Any]] = Field(
+        default_factory=dict,
+        description="变量定义：{name: {type: str, default: value}}",
+    )
+
+    _values: dict[str, Any] = PrivateAttr(default_factory=dict)
+
+    async def on_validate(self, hub: Hub) -> None:
+        for name, spec in self.properties.items():
+            type_name = spec.get("type", "str")
+            value = spec.get("value")
+            if type_name == "list":
+                self._values[name] = hub.renderer.render_value(value or [])
+            else:
+                self._values[name] = self._cast(type_name, value)
+
+    def get_attributes(self) -> tuple[AttributeInfo, ...]:
+        return tuple(
+            AttributeInfo(
+                name=name,
+                type=spec.get("type", "str"),
+                description=spec.get("description", ""),
+                readonly=False,
+                default=spec.get("default"),
+            )
+            for name, spec in self.properties.items()
+        )
+
+    def get_attribute_values(self) -> dict[str, Any]:
+        return dict(self._values)
+
+    def __getattr__(self, name: str) -> Any:
+        if not name.startswith("_"):
+            priv = self.__dict__.get("__pydantic_private__")
+            if priv and "_values" in priv and name in priv["_values"]:
+                return priv["_values"][name]
+        return super().__getattr__(name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        priv = self.__dict__.get("__pydantic_private__")
+        if priv is not None and "_values" in priv and name in priv["_values"]:
+            old = priv["_values"][name]
+            type_name = self.properties[name].get("type", "str")
+            if type_name == "list":
+                new = list(value) if not isinstance(value, list) else value
+            else:
+                new = self._cast(type_name, value)
+            priv["_values"][name] = new
+            try:
+                changed = old != new
+            except Exception:
+                changed = True
+            if changed:
+                self._notify_change(name, old, new)
+            return
+        super().__setattr__(name, value)
+
+    @staticmethod
+    def _cast(type_name: str, value: Any) -> Any:
+        if value is None:
+            return None
+        caster = TYPE_MAP.get(type_name)
+        if caster is not None:
+            return caster(value)
+        return value

python_library_automation-0.1.16/automation/builtins/event/_scheduled.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import ClassVar, TYPE_CHECKING, Any
+
+from pydantic import PrivateAttr
+
+from automation.core import Event
+
+if TYPE_CHECKING:
+    from automation.hub import Hub
+
+
+class ScheduledEvent(Event):
+    _abstract: ClassVar[bool] = True
+
+    _job: Any = PrivateAttr(default=None)
+
+    def _create_job(self) -> Any:
+        raise NotImplementedError
+
+    async def on_activate(self, hub: Hub) -> None:
+        if self._job:
+            await self._job.stop()
+        job = self._create_job()
+        job.add(self.fire)
+        self._job = job
+
+    async def on_start(self) -> None:
+        if self._job:
+            await self._job.start()
+
+    async def on_stop(self) -> None:
+        if self._job:
+            await self._job.stop()

python_library_automation-0.1.16/automation/builtins/event/at.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+from pydantic import Field
+
+from ._scheduled import ScheduledEvent
+from scheduler import At
+
+
+class AtEvent(ScheduledEvent):
+    _type: ClassVar[str] = "at"
+
+    weekday: int | None = Field(default=None, ge=0, le=6)
+    hour: int = Field(default=0, ge=0, le=23)
+    minute: int = Field(default=0, ge=0, le=59)
+    second: int = Field(default=0, ge=0, le=59)
+    max_runs: int | None = Field(default=None, ge=1)
+
+    def _create_job(self) -> At:
+        return At(
+            weekday=self.weekday,
+            hour=self.hour,
+            minute=self.minute,
+            second=self.second,
+            max_runs=self.max_runs,
+        )

python_library_automation-0.1.16/automation/builtins/event/callback.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+from typing import Any, ClassVar, TYPE_CHECKING
+
+from pydantic import Field, PrivateAttr
+
+from automation.core.event import Event
+from automation.core.event_context import EventContext
+
+if TYPE_CHECKING:
+    from automation.hub import Hub
+
+
+class CallbackEvent(Event):
+    _abstract: ClassVar[bool] = False
+    _type: ClassVar[str] = "callback"
+
+    entity_type: str = Field(description="实体类型名")
+    callback: str = Field(description="实体上的回调属性名")
+
+    _entity_ref: Any = PrivateAttr(default=None)
+    _original_callbacks: dict[str, Any] = PrivateAttr(default_factory=dict)
+
+    @property
+    def entity(self) -> Any:
+        """触发后可引用的实际 entity 实例"""
+        return self._entity_ref
+
+    def _find_entities(self, hub: Hub) -> list:
+        return [
+            e for e in hub.entities.values()
+            if e._type == self.entity_type
+        ]
+
+    async def on_validate(self, hub: Hub) -> None:
+        if not self._find_entities(hub):
+            raise ValueError(
+                f"No entity of type {self.entity_type!r} found"
+            )
+
+    async def on_activate(self, hub: Hub) -> None:
+        event_ref = self
+        self._original_callbacks.clear()
+
+        for entity in self._find_entities(hub):
+            self._original_callbacks[entity.instance_name] = getattr(
+                entity, self.callback, None
+            )
+
+            async def wrapper(_entity=entity, **kwargs):
+                event_ref._entity_ref = _entity
+                context = EventContext(
+                    event_name=event_ref.instance_name,
+                    data={"entity": _entity, **kwargs},
+                )
+                await event_ref.fire(context)
+
+            setattr(entity, self.callback, wrapper)
+
+    async def on_stop(self) -> None:
+        for name, original in self._original_callbacks.items():
+            entity = self._hub.entities.get(name)
+            if entity is not None and original is not None:
+                setattr(entity, self.callback, original)
+        self._original_callbacks.clear()
+        self._entity_ref = None

python_library_automation-0.1.16/automation/builtins/event/every.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+from typing import ClassVar
+
+from pydantic import Field
+
+from ._scheduled import ScheduledEvent
+from scheduler import Every
+
+class EveryEvent(ScheduledEvent):
+    _type: ClassVar[str] = "every"
+
+    seconds: float = Field(default=0, ge=0)
+    minutes: float = Field(default=0, ge=0)
+    hours: float = Field(default=0, ge=0)
+    days: float = Field(default=0, ge=0)
+    immediate: bool = Field(default=False)
+    max_runs: int | None = Field(default=None, ge=1)
+
+    async def on_validate(self, hub) -> None:
+        total = self.seconds + self.minutes * 60 + self.hours * 3600 + self.days * 86400
+        if total <= 0:
+            raise ValueError("EveryEvent requires at least one interval > 0")
+
+    def _create_job(self) -> Every:
+        return Every(
+            seconds=self.seconds,
+            minutes=self.minutes,
+            hours=self.hours,
+            days=self.days,
+            immediate=self.immediate,
+            max_runs=self.max_runs,
+        )

python_library_automation-0.1.16/automation/builtins/event/state_changed.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from typing import Any, ClassVar, TYPE_CHECKING
+
+from pydantic import Field, PrivateAttr
+
+from automation.core.event import Event
+from automation.core.event_context import EventContext
+
+if TYPE_CHECKING:
+    from automation.hub import Hub
+
+
+class StateChangedEvent(Event):
+    _abstract: ClassVar[bool] = False
+    _type: ClassVar[str] = "state_changed"
+
+    entity_type: str | None = Field(default=None, description="过滤实体类型（可选）")
+    entity_name: str | None = Field(default=None, description="过滤实体实例名（可选）")
+    attribute: str | None = Field(default=None, description="过滤属性名（可选）")
+
+    _entity_ref: Any = PrivateAttr(default=None)
+    _handler: Any = PrivateAttr(default=None)
+
+    @property
+    def entity(self) -> Any:
+        return self._entity_ref
+
+    async def on_activate(self, hub: Hub) -> None:
+        event_ref = self
+
+        async def handler(entity, attr, old, new):
+            if event_ref.entity_type and entity._type != event_ref.entity_type:
+                return
+            if event_ref.entity_name and entity.instance_name != event_ref.entity_name:
+                return
+            if event_ref.attribute and attr != event_ref.attribute:
+                return
+            event_ref._entity_ref = entity
+            context = EventContext(
+                event_name=event_ref.instance_name,
+                data={
+                    "entity": entity,
+                    "attribute": attr,
+                    "old": old,
+                    "new": new,
+                },
+            )
+            await event_ref.fire(context)
+
+        self._handler = handler
+        hub._on_state_changed.append(handler)
+
+    async def on_stop(self) -> None:
+        if self._handler and self._hub:
+            try:
+                self._hub._on_state_changed.remove(self._handler)
+            except ValueError:
+                pass

python_library_automation-0.1.16/automation/core/__init__.py

@@ -0,0 +1,13 @@
+from .base import BaseAutomation
+from .action import Action
+from .entity import Entity
+from .trigger import Trigger
+from .event import Event
+
+__all__ = [
+    "BaseAutomation",
+    "Action",
+    "Entity",
+    "Trigger",
+    "Event",
+]