hyperot-adapter-onebot 2.0.0__py3-none-any.whl

hyperot_adapter_onebot/adapter.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import asyncio
+from collections import OrderedDict
+from contextlib import suppress
+from typing import TypeVar
+
+from pydantic import JsonValue
+
+from hyperot.v2.actions import Action
+from hyperot.v2.adapter import (
+    ActionRegistry,
+    AdapterManifest,
+    ExtensionRegistry,
+    load_manifest,
+)
+from hyperot.v2.common import FileId, GroupId, MessageId, SceneType
+from hyperot.v2.events import Event, GroupInvitationReceivedEvent, GroupJoinRequestedEvent
+
+from .actions import OneBotActions
+from .api import OneBotAPI
+from .config import OneBotConfig
+from .events import (
+    OneBotFileUploadedEvent,
+    OneBotMessageReceivedEvent,
+    translate_event,
+)
+from .segments import OneBotFile, OneBotSegmentCodec
+from .transport import ActionTransport, HTTPPostTransport, build_transport
+
+ResultT = TypeVar("ResultT")
+
+
+class _ExtensionContext:
+    def __init__(self, adapter: OneBotAdapter) -> None:
+        self.adapter = adapter
+
+    async def execute(self, action: Action[ResultT]) -> ResultT:
+        return await self.adapter.execute(action)
+
+
+class OneBotAdapter:
+    def __init__(self) -> None:
+        self.manifest: AdapterManifest = load_manifest("hyperot_adapter_onebot")
+        self.config_type = OneBotConfig
+        self.segment_codec = OneBotSegmentCodec()
+        self.actions = ActionRegistry()
+        self.extensions = ExtensionRegistry(_ExtensionContext(self))
+        self.api_type = OneBotAPI
+        self._config: OneBotConfig | None = None
+        self._transports: list[ActionTransport] = []
+        self._action_transport: ActionTransport | None = None
+        self._running = False
+        self._message_groups: OrderedDict[str, GroupId] = OrderedDict()
+        self._request_subtypes: OrderedDict[str, str] = OrderedDict()
+        self._file_context: OrderedDict[str, dict[str, JsonValue]] = OrderedDict()
+
+    async def start(self, config: OneBotConfig) -> None:
+        if self._running:
+            return
+        self._config = config
+        self._transports = [build_transport(connection) for connection in config.connections]
+        if not self._transports:
+            raise ValueError("OneBot adapter requires at least one connection")
+        started: list[ActionTransport] = []
+        try:
+            for transport in self._transports:
+                await transport.start()
+                started.append(transport)
+        except Exception:
+            for transport in reversed(started):
+                with suppress(Exception):
+                    await transport.stop()
+            raise
+        self._action_transport = next(
+            (transport for transport in self._transports if not isinstance(transport, HTTPPostTransport)),
+            None,
+        )
+        self.actions = ActionRegistry()
+        if self._action_transport is not None:
+            builder = OneBotActions(
+                self._action_transport,
+                self.segment_codec,
+                config.action_timeout,
+                message_group_lookup=self._message_group_lookup,
+                message_group_remember=self._remember_message_group,
+                request_subtype_lookup=self._request_subtype_lookup,
+                file_context_lookup=self._file_context_lookup,
+            )
+            builder.register_all(self.actions)
+        self._running = True
+
+    async def stop(self) -> None:
+        if not self._running:
+            return
+        self._running = False
+        for transport in reversed(self._transports):
+            await transport.stop()
+        self._transports.clear()
+        self._action_transport = None
+        self.extensions.clear()
+
+    async def receive(self) -> Event:
+        if not self._transports:
+            from hyperot.v2.common import AdapterDisconnectedError
+
+            raise AdapterDisconnectedError("OneBot adapter is not started")
+        while True:
+            if len(self._transports) == 1:
+                payload = await self._transports[0].receive()
+            else:
+                tasks = [asyncio.create_task(transport.receive()) for transport in self._transports]
+                done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+                for task in pending:
+                    task.cancel()
+                if pending:
+                    await asyncio.gather(*pending, return_exceptions=True)
+                payload = done.pop().result()
+            event = translate_event(payload, self.segment_codec, self._message_group_lookup)
+            if event is not None:
+                self._remember_event_context(event)
+                return event
+
+    async def execute(self, action: Action[ResultT]) -> ResultT:
+        handler = self.actions.get(type(action))
+        return await handler(action)
+
+    def _require_action_transport(self) -> ActionTransport:
+        if self._action_transport is None:
+            raise RuntimeError("OneBot adapter has no action transport")
+        return self._action_transport
+
+    def _remember_message_group(self, message_id: MessageId, group_id: GroupId) -> None:
+        self._message_groups[str(message_id)] = group_id
+        self._message_groups.move_to_end(str(message_id))
+        while len(self._message_groups) > 8192:
+            self._message_groups.popitem(last=False)
+
+    def _message_group_lookup(self, message_id: MessageId) -> GroupId | None:
+        group_id = self._message_groups.get(str(message_id))
+        if group_id is not None:
+            self._message_groups.move_to_end(str(message_id))
+        return group_id
+
+    def _remember_request_subtype(self, request_id: str, sub_type: str) -> None:
+        self._request_subtypes[request_id] = sub_type
+        self._request_subtypes.move_to_end(request_id)
+        while len(self._request_subtypes) > 1024:
+            self._request_subtypes.popitem(last=False)
+
+    def _request_subtype_lookup(self, request_id: str) -> str | None:
+        sub_type = self._request_subtypes.get(request_id)
+        if sub_type is not None:
+            self._request_subtypes.move_to_end(request_id)
+        return sub_type
+
+    def _remember_file_context(self, file_id: FileId, **values: JsonValue) -> None:
+        key = str(file_id)
+        context = self._file_context.setdefault(key, {})
+        context.update({name: value for name, value in values.items() if value is not None})
+        self._file_context.move_to_end(key)
+        while len(self._file_context) > 4096:
+            self._file_context.popitem(last=False)
+
+    def _file_context_lookup(self, file_id: FileId) -> dict[str, JsonValue] | None:
+        context = self._file_context.get(str(file_id))
+        if context is not None:
+            self._file_context.move_to_end(str(file_id))
+            return dict(context)
+        return None
+
+    def _remember_event_context(self, event: Event) -> None:
+        if isinstance(event, OneBotMessageReceivedEvent):
+            if event.scene_type == SceneType.GROUP:
+                self._remember_message_group(event.message_id, GroupId(str(event.scene_id)))
+            for segment in event.message:
+                if isinstance(segment, OneBotFile) and segment.file_id is not None:
+                    self._remember_file_context(segment.file_id, file_hash=segment.file_hash)
+        elif isinstance(event, OneBotFileUploadedEvent):
+            if str(event.file.file_id):
+                self._remember_file_context(
+                    event.file.file_id,
+                    busid=event.busid,
+                    file_hash=event.file_hash,
+                )
+        elif isinstance(event, GroupJoinRequestedEvent):
+            self._remember_request_subtype(str(event.request_id), "add")
+        elif isinstance(event, GroupInvitationReceivedEvent):
+            self._remember_request_subtype(str(event.request_id), "invite")
+
+
+def create_adapter() -> OneBotAdapter:
+    return OneBotAdapter()

hyperot_adapter_onebot/api.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
+from hyperot.v2.actions import (
+    CookieInfo,
+    CsrfTokenInfo,
+    FileReference,
+    FileUrl,
+    MuteMemberAction,
+    ReactMessageAction,
+)
+from hyperot.v2.api import BotAPI, ClientAPI, FileAPI, GroupAPI, GroupMemberAPI, MessageAPI, UserAPI
+from hyperot.v2.common import CapabilityNotSupportedError, FileId, GroupId, MessageId, SceneId, SceneType, UserId
+
+from .actions import (
+    GetGroupFileUrlAction,
+    GetPrivateFileUrlAction,
+    GroupReactionAction,
+    OneBotKickMemberAction,
+    OneBotLeaveGroupAction,
+    OneBotSetMemberTitleAction,
+)
+
+
+class OneBotUserAPI(UserAPI):
+    async def send_like(self, times: int = 1) -> None:
+        from hyperot.v2.actions import SendLikeAction
+
+        await self._context.execute(SendLikeAction(user_id=self.user_id, times=times))
+
+
+class OneBotGroupMemberAPI(GroupMemberAPI):
+    @override
+    async def kick(self, reject_add_request: bool = False) -> None:
+        await self._context.execute(
+            OneBotKickMemberAction(
+                group_id=self.group_id,
+                user_id=self.user_id,
+                reject_add_request=reject_add_request,
+            )
+        )
+
+    @override
+    async def mute(self, duration: int = 1800) -> None:
+        await self._context.execute(
+            MuteMemberAction(
+                group_id=self.group_id,
+                user_id=self.user_id,
+                duration=duration,
+            )
+        )
+
+    @override
+    async def set_card(self, card: str) -> None:
+        from hyperot.v2.actions import SetMemberCardAction
+
+        await self._context.execute(
+            SetMemberCardAction(
+                group_id=self.group_id,
+                user_id=self.user_id,
+                card=card,
+            )
+        )
+
+    @override
+    async def set_title(self, title: str, duration: int = -1) -> None:
+        await self._context.execute(
+            OneBotSetMemberTitleAction(
+                group_id=self.group_id,
+                user_id=self.user_id,
+                title=title,
+                duration=duration,
+            )
+        )
+
+
+class OneBotGroupAPI(GroupAPI):
+    @override
+    def member(self, user_id: str | int) -> OneBotGroupMemberAPI:
+        return OneBotGroupMemberAPI(self._context, self.group_id, UserId(str(user_id)))
+
+    async def reaction(self, message_id: str | int, reaction: str) -> None:
+        await self._context.execute(
+            GroupReactionAction(
+                group_id=self.group_id,
+                message_id=MessageId(str(message_id)),
+                reaction=reaction,
+                enabled=True,
+            )
+        )
+
+    @override
+    async def leave(self, is_dismiss: bool = False) -> None:
+        await self._context.execute(
+            OneBotLeaveGroupAction(
+                group_id=self.group_id,
+                is_dismiss=is_dismiss,
+            )
+        )
+
+
+class OneBotMessageAPI(MessageAPI):
+    async def group_reaction(self, reaction: str) -> None:
+        await self._context.execute(
+            ReactMessageAction(
+                message_id=self.message_id,
+                reaction=reaction,
+                enabled=True,
+            )
+        )
+
+
+class OneBotFileAPI(FileAPI):
+    @override
+    async def info(self) -> FileReference:
+        raise CapabilityNotSupportedError("OneBot has no generic file info endpoint")
+
+    @override
+    async def download(self) -> FileUrl:
+        raise CapabilityNotSupportedError("OneBot has no generic file download endpoint")
+
+    async def group_url(self, group_id: str | int) -> FileUrl:
+        return await self._context.execute(
+            GetGroupFileUrlAction(
+                group_id=GroupId(str(group_id)),
+                file_id=self.file_id,
+            )
+        )
+
+    async def private_url(self, user_id: str | int, file_hash: str | None = None) -> FileUrl:
+        return await self._context.execute(
+            GetPrivateFileUrlAction(
+                user_id=UserId(str(user_id)),
+                file_id=self.file_id,
+                file_hash=file_hash,
+            )
+        )
+
+
+class OneBotBotAPI(BotAPI):
+    async def cookies(self, domain: str) -> CookieInfo:
+        from hyperot.v2.actions import GetCookieAction
+
+        return await self._context.execute(GetCookieAction(domain=domain))
+
+    async def csrf_token(self) -> CsrfTokenInfo:
+        from hyperot.v2.actions import GetCsrfTokenAction
+
+        return await self._context.execute(GetCsrfTokenAction())
+
+
+class OneBotAPI(ClientAPI):
+    @override
+    def scene(self, scene_type: SceneType, scene_id: str | int):
+        return super().scene(scene_type, scene_id)
+
+    @override
+    def user(self, user_id: str | int) -> OneBotUserAPI:
+        return OneBotUserAPI(self._context, SceneType.USER, SceneId(str(user_id)), UserId(str(user_id)))
+
+    @override
+    def group(self, group_id: str | int) -> OneBotGroupAPI:
+        return OneBotGroupAPI(self._context, SceneType.GROUP, SceneId(str(group_id)), GroupId(str(group_id)))
+
+    @override
+    def message(self, message_id: str | int) -> OneBotMessageAPI:
+        return OneBotMessageAPI(self._context, MessageId(str(message_id)))
+
+    @override
+    def file(self, file_id: str | int) -> OneBotFileAPI:
+        return OneBotFileAPI(self._context, FileId(str(file_id)))
+
+    @override
+    @property
+    def bot(self) -> OneBotBotAPI:
+        return OneBotBotAPI(self._context)

hyperot_adapter_onebot/config.py

@@ -0,0 +1,51 @@
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ConnectionConfig(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    access_token: str = ""
+
+
+class ForwardWebSocketConfig(ConnectionConfig):
+    type: Literal["ForwardWebSocket"] = "ForwardWebSocket"
+    url: str
+    ping_interval: float | None = 20.0
+    ping_timeout: float | None = 20.0
+
+
+class ReverseWebSocketConfig(ConnectionConfig):
+    type: Literal["ReverseWebSocket"] = "ReverseWebSocket"
+    host: str = "127.0.0.1"
+    port: int = 6700
+    api_path: str = "/api"
+    event_path: str = "/event"
+
+
+class HTTPConfig(ConnectionConfig):
+    type: Literal["HTTP"] = "HTTP"
+    url: str
+    timeout: float = 30.0
+
+
+class HTTPPostConfig(ConnectionConfig):
+    type: Literal["HTTPPost"] = "HTTPPost"
+    host: str = "127.0.0.1"
+    port: int = 6701
+    endpoint: str = "/"
+    secret: str = ""
+
+
+OneBotConnectionConfig = Annotated[
+    ForwardWebSocketConfig | ReverseWebSocketConfig | HTTPConfig | HTTPPostConfig,
+    Field(discriminator="type"),
+]
+
+
+class OneBotConfig(BaseModel):
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    connections: tuple[OneBotConnectionConfig, ...] = (ForwardWebSocketConfig(url="ws://127.0.0.1:5004"),)
+    action_timeout: float = 30.0