neobot-adapter 1.0.0__tar.gz

neobot_adapter-1.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.3
+Name: neobot-adapter
+Version: 1.0.0
+Summary: Add your description here
+Author: wsrsq, tangtian
+Author-email: wsrsq <wsrsq001@163.com>, tangtian <a14b@126.com>
+Requires-Dist: websockets
+Requires-Dist: aiohttp
+Requires-Dist: pydantic>=2.7.4
+Requires-Dist: loguru>=0.7.2
+Requires-Dist: neobot-contracts
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+

neobot_adapter-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "neobot-adapter"
+version = "1.0.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "websockets",
+    "aiohttp",
+    "pydantic>=2.7.4",
+    "loguru>=0.7.2",
+    "neobot-contracts",
+]
+
+[[project.authors]]
+name = "wsrsq"
+email = "wsrsq001@163.com"
+
+[[project.authors]]
+name = "tangtian"
+email = "a14b@126.com"
+
+[tool.uv.sources.neobot-contracts]
+workspace = true
+
+[build-system]
+requires = ["uv_build>=0.9.27,<0.10.0"]
+build-backend = "uv_build"

neobot_adapter-1.0.0/pyproject.toml.orig

@@ -0,0 +1,24 @@
+[project]
+name = "neobot-adapter"
+version = "1.0.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "wsrsq", email = "wsrsq001@163.com" },
+    { name = "tangtian", email = "a14b@126.com" },
+]
+requires-python = ">=3.13"
+dependencies = [
+    "websockets",
+    "aiohttp",
+    "pydantic>=2.7.4",
+    "loguru>=0.7.2",
+    "neobot-contracts",
+]
+
+[tool.uv.sources]
+neobot-contracts = { workspace = true }
+
+[build-system]
+requires = ["uv_build>=0.9.27,<0.10.0"]
+build-backend = "uv_build"

neobot_adapter-1.0.0/src/neobot_adapter/__init__.py

@@ -0,0 +1,21 @@
+"""NeoBot 适配器公开入口"""
+
+from .factory import AdapterSettings, create_adapter
+from .interfaces import CoreLike, RuntimeAdapter
+from .local import LocalAdapter
+from .mapping import map_to_incoming_message
+from .onebot import AdapterCore, OneBotAdapter, Subscription
+from .request.websocket import WebSocketAPI
+
+__all__ = [
+    "OneBotAdapter",
+    "LocalAdapter",
+    "Subscription",
+    "AdapterSettings",
+    "create_adapter",
+    "CoreLike",
+    "RuntimeAdapter",
+    "map_to_incoming_message",
+    "AdapterCore",
+    "WebSocketAPI",
+]

neobot_adapter-1.0.0/src/neobot_adapter/eventing.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import threading
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Dict, Optional, get_type_hints
+
+from pydantic import BaseModel
+
+from neobot_contracts.ports.logging import Logger, NullLogger
+
+Rule = Callable[[Dict[str, Any]], bool | Awaitable[bool]]
+EventHandlerFunc = Callable[..., Any]
+
+
+@dataclass
+class Subscription:
+    _unsubscribe: Callable[[], None]
+    _active: bool = True
+
+    def unsubscribe(self) -> None:
+        if not self._active:
+            return
+        self._unsubscribe()
+        self._active = False
+
+
+@dataclass
+class _HandlerRegistration:
+    handler: EventHandlerFunc
+    is_async: bool
+    post_type: Optional[str]
+    message_type: Optional[str]
+    notice_type: Optional[str]
+    request_type: Optional[str]
+    meta_event_type: Optional[str]
+    sub_type: Optional[str]
+    rule: Optional[Rule]
+    priority: int
+    event_model: Optional[type[BaseModel]] = field(default=None)
+
+    def matches(self, event: Dict[str, Any]) -> bool:
+        if self.post_type and event.get("post_type") != self.post_type:
+            return False
+        if self.message_type and event.get("message_type") != self.message_type:
+            return False
+        if self.notice_type and event.get("notice_type") != self.notice_type:
+            return False
+        if self.request_type and event.get("request_type") != self.request_type:
+            return False
+        if self.meta_event_type and event.get("meta_event_type") != self.meta_event_type:
+            return False
+        if self.sub_type and event.get("sub_type") != self.sub_type:
+            return False
+        return True
+
+    def coerce(self, event: Dict[str, Any]) -> Any:
+        if self.event_model is not None:
+            return self.event_model.model_validate(event)
+        return event
+
+
+class EventDispatcher:
+    def __init__(self, logger: Optional[Logger] = None) -> None:
+        self._handlers: list[_HandlerRegistration] = []
+        self._lock = threading.RLock()
+        self._logger: Logger = logger if logger is not None else NullLogger()
+
+    def subscribe(self, registration: _HandlerRegistration) -> Subscription:
+        with self._lock:
+            self._handlers.append(registration)
+            self._handlers.sort(key=lambda item: item.priority, reverse=True)
+
+        def _unsubscribe() -> None:
+            with self._lock:
+                self._handlers = [
+                    item for item in self._handlers if item is not registration
+                ]
+
+        return Subscription(_unsubscribe)
+
+    async def publish(self, event: Dict[str, Any]) -> None:
+        with self._lock:
+            handlers: list[_HandlerRegistration] = []
+            for handler in self._handlers:
+                try:
+                    if handler.matches(event):
+                        handlers.append(handler)
+                except Exception as exc:
+                    # 单个处理器的匹配逻辑（或形状异常的事件）不得让整条事件
+                    # 分发失败：跳过该处理器并告警，其余处理器继续。
+                    self._logger.error(
+                        "事件匹配失败，已跳过该处理器 "
+                        f"({handler.handler.__qualname__}): {exc}"
+                    )
+
+        for handler in handlers:
+            if handler.rule is not None:
+                try:
+                    rule_result = handler.rule(event)
+                    if inspect.isawaitable(rule_result):
+                        rule_result = await rule_result
+                    if not rule_result:
+                        continue
+                except Exception as exc:
+                    self._logger.error(f"事件规则执行失败: {exc}")
+                    continue
+
+            try:
+                coerced = handler.coerce(event)
+            except Exception as exc:
+                self._logger.error(f"事件模型转换失败 ({handler.handler.__qualname__}): {exc}")
+                coerced = event
+
+            try:
+                if handler.is_async:
+                    await handler.handler(coerced)
+                else:
+                    await asyncio.to_thread(handler.handler, coerced)
+            except Exception as exc:
+                self._logger.error(f"事件处理失败: {exc}")
+
+
+def extract_event_model(handler: EventHandlerFunc) -> Optional[type[BaseModel]]:
+    try:
+        hints = get_type_hints(handler)
+    except Exception:
+        return None
+    params = list(inspect.signature(handler).parameters.values())
+    if not params:
+        return None
+    first_param = params[0]
+    annotation = hints.get(first_param.name)
+    if annotation is None:
+        return None
+    if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+        return annotation
+    return None
+
+
+class EventNamespace:
+    def __init__(self, adapter: Any, path: tuple[str, ...] = ()) -> None:
+        self._adapter = adapter
+        self._path = path
+
+    def __getattr__(self, name: str) -> "EventNamespace":
+        return EventNamespace(self._adapter, self._path + (name,))
+
+    def __call__(
+        self,
+        func: Optional[EventHandlerFunc] = None,
+        *,
+        group: bool = False,
+        private: bool = False,
+        rule: Optional[Rule] = None,
+        priority: int = 0,
+        sub_type: Optional[str] = None,
+    ) -> Any:
+        filters = self._adapter._filters_from_path(
+            self._path,
+            group=group,
+            private=private,
+            sub_type=sub_type,
+        )
+
+        def decorator(handler: EventHandlerFunc) -> EventHandlerFunc:
+            self._adapter._register_handler(
+                handler,
+                rule=rule,
+                priority=priority,
+                **filters,
+            )
+            return handler
+
+        if func is not None:
+            return decorator(func)
+        return decorator

neobot_adapter-1.0.0/src/neobot_adapter/factory.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from neobot_contracts.ports.logging import Logger, NullLogger
+from neobot_contracts.ports.sandbox import SandboxDataPort
+
+from neobot_adapter.interfaces import RuntimeAdapter
+from neobot_adapter.local import LocalAdapter
+from neobot_adapter.onebot import OneBotAdapter
+
+
+@dataclass(frozen=True)
+class AdapterSettings:
+    mode: str = "onebot"
+    local_host: str = "127.0.0.1"
+    local_port: int = 8090
+    local_auth_token: str = ""
+    bot_user_id: int = 0
+    bot_name: str = "Neo Bot"
+    # onebot 反向 WebSocket 服务端监听(空/0 表示未配置,回退环境变量与默认值)
+    reverse_ws_host: str = ""
+    reverse_ws_port: int = 0
+    # 反向 WebSocket 握手鉴权的 access token(OneBot 11 规范;留空表示不校验)
+    reverse_ws_access_token: str = ""
+
+
+def create_adapter(
+    settings: AdapterSettings | Any | None = None,
+    *,
+    logger: Logger | None = None,
+    packet_callback: Callable[[dict[str, Any]], None] | None = None,
+    sandbox_data: SandboxDataPort | None = None,
+) -> RuntimeAdapter:
+    cfg = _coerce_settings(settings)
+    adapter_logger = logger or NullLogger()
+    mode = cfg.mode.strip().casefold()
+    if mode == "onebot":
+        return OneBotAdapter(
+            logger=adapter_logger,
+            packet_callback=packet_callback,
+            host=cfg.reverse_ws_host or None,
+            port=cfg.reverse_ws_port if cfg.reverse_ws_port else None,
+            access_token=cfg.reverse_ws_access_token,
+        )
+    if mode == "local":
+        return LocalAdapter(
+            host=cfg.local_host,
+            port=cfg.local_port,
+            auth_token=cfg.local_auth_token,
+            bot_user_id=cfg.bot_user_id,
+            bot_name=cfg.bot_name,
+            logger=adapter_logger,
+            packet_callback=packet_callback,
+            sandbox_data=sandbox_data,
+        )
+    raise ValueError(f"未知适配器模式: {cfg.mode}。可选值: onebot, local")
+
+
+def _coerce_settings(settings: AdapterSettings | Any | None) -> AdapterSettings:
+    if settings is None:
+        return AdapterSettings()
+    if isinstance(settings, AdapterSettings):
+        return settings
+    return AdapterSettings(
+        mode=str(getattr(settings, "mode", "onebot") or "onebot"),
+        local_host=str(getattr(settings, "local_host", "127.0.0.1") or "127.0.0.1"),
+        local_port=int(getattr(settings, "local_port", 8090) or 8090),
+        local_auth_token=str(getattr(settings, "local_auth_token", "") or ""),
+        bot_user_id=int(getattr(settings, "bot_user_id", 0) or 0),
+        bot_name=str(getattr(settings, "bot_name", "Neo Bot") or "Neo Bot"),
+        reverse_ws_host=str(getattr(settings, "reverse_ws_host", "") or ""),
+        reverse_ws_port=int(getattr(settings, "reverse_ws_port", 0) or 0),
+        reverse_ws_access_token=str(
+            getattr(settings, "reverse_ws_access_token", "") or ""
+        ),
+    )

neobot_adapter-1.0.0/src/neobot_adapter/interfaces.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+from neobot_contracts.models import ConversationRef
+
+from neobot_adapter.eventing import EventHandlerFunc, Subscription
+from neobot_adapter.model.response import SendMsgResponse
+
+
+@runtime_checkable
+class CoreLike(Protocol):
+    async def call_api(
+        self,
+        action: str,
+        params: dict[str, Any],
+        timeout: float = 5.0,
+        websocket: Any = None,
+    ) -> dict[str, Any] | None: ...
+
+    def call_api_sync(
+        self,
+        action: str,
+        params: dict[str, Any],
+        timeout: float = 5.0,
+        websocket: Any = None,
+    ) -> dict[str, Any] | None: ...
+
+
+@runtime_checkable
+class RuntimeAdapter(Protocol):
+    @property
+    def requires_connection_wait(self) -> bool: ...
+
+    @property
+    def connected(self) -> bool: ...
+
+    @property
+    def http_url(self) -> str:
+        """本地适配器（local 模式）的 HTTP 地址；不适用时为空串。"""
+        ...
+
+    @property
+    def ws_url(self) -> str:
+        """本地适配器（local 模式）的 WebSocket 地址；不适用时为空串。"""
+        ...
+
+    async def start(self) -> None: ...
+
+    async def stop(self) -> None: ...
+
+    def wait_for_connection(self, timeout: float | None = None) -> bool: ...
+
+    def subscribe(
+        self,
+        event_type: Any,
+        handler: EventHandlerFunc,
+        **filters: Any,
+    ) -> Subscription: ...
+
+    async def call_api(
+        self,
+        action: str,
+        params: dict[str, Any],
+        timeout: float = 5.0,
+        wait_response: bool = True,
+    ) -> dict[str, Any] | None: ...
+
+    async def send(
+        self,
+        conversation: ConversationRef,
+        message: str | list[dict[str, Any]],
+        timeout: float = 5.0,
+        wait_response: bool = True,
+    ) -> SendMsgResponse: ...
+
+
+@runtime_checkable
+class AdapterReconfigurable(Protocol):
+    """可在运行期改监听设置（host / port / access token）的适配器能力。
+
+    只有「监听设置不固化在构造期」的适配器实现它（如 OneBotAdapter）；
+    控制面用 ``isinstance(adapter, AdapterReconfigurable)`` 做能力查询，
+    而不是 ``hasattr`` 猜测 —— 能力应当是接口的一部分，不是隐藏的可选成员。
+    """
+
+    @property
+    def settings(self) -> Any:
+        """当前解析后的监听设置（值对象，用于比较与展示）。"""
+        ...
+
+    def reconfigure(self, settings: Any) -> None:
+        """写入新的监听设置；不触碰运行中的接收线程。"""
+        ...

neobot_adapter-1.0.0/src/neobot_adapter/listener/__init__.py

@@ -0,0 +1,5 @@
+"""事件监听器模块"""
+
+from .manager import ListenerManager
+
+__all__ = ["ListenerManager"]