satori-python-adapter-milky 0.2.0__tar.gz → 0.3.1__tar.gz

{satori_python_adapter_milky-0.2.0 → satori_python_adapter_milky-0.3.1}/.mina/adapter_milky.toml

@@ -1,9 +1,9 @@
 includes = ["src/satori/adapters/milky"]
-raw-dependencies = ["satori-python-server >= 0.18.0"]
+raw-dependencies = ["satori-python-server<1.4.0,>= 1.3.0"]
 
 [project]
 name = "satori-python-adapter-milky"
-version = "0.2.0"
+version = "0.3.1"
 authors = [
   {name = "RF-Tar-Railt", email = "rf_tar_railt@qq.com"}
 ]

{satori_python_adapter_milky-0.2.0 → satori_python_adapter_milky-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satori-python-adapter-milky
-Version: 0.2.0
+Version: 0.3.1
 Summary: Satori Protocol SDK for python, adapter for Milky
 Home-page: https://github.com/RF-Tar-Railt/satori-python
 Author-Email: RF-Tar-Railt <rf_tar_railt@qq.com>
@@ -17,7 +17,7 @@ Classifier: Operating System :: OS Independent
 Project-URL: Homepage, https://github.com/RF-Tar-Railt/satori-python
 Project-URL: Repository, https://github.com/RF-Tar-Railt/satori-python
 Requires-Python: <4.0,>=3.10
-Requires-Dist: satori-python-server>=0.18.0
+Requires-Dist: satori-python-server<1.4.0,>=1.3.0
 Description-Content-Type: text/markdown
 
 # satori-python
@@ -70,13 +70,13 @@ pip install satori-python-server
 
 ### 官方适配器
 
-| 适配器        | 安装                                           | 路径                                                                 |
-|------------|----------------------------------------------|--------------------------------------------------------------------|
-| Satori     | `pip install satori-python-adapter-satori`   | satori.adapters.satori                                             |
-| OneBot V11 | `pip install satori-python-adapter-onebot11` | satori.adapters.onebot11.forward, satori.adapters.onebot11.reverse |
-| Console    | `pip install satori-python-adapter-console`  | satori.adapters.console                                            |
-| Milky      | `pip install satori-python-adapter-milky`    | satori.adapters.milky.main, satori.adapters.milky.webhook          |
-| QQ         | `pip install satori-python-adapter-qq`       | satori.adapters.milky.main, satori.adapters.milky.websocket        |
+| 适配器        | 安装                                           | 路径                                                                                   |
+|------------|----------------------------------------------|--------------------------------------------------------------------------------------|
+| Satori     | `pip install satori-python-adapter-satori`   | satori.adapters.satori                                                               |
+| OneBot V11 | `pip install satori-python-adapter-onebot11` | satori.adapters.onebot11.forward, satori.adapters.onebot11.reverse                   |
+| Console    | `pip install satori-python-adapter-console`  | satori.adapters.console                                                              |
+| Milky      | `pip install satori-python-adapter-milky`    | satori.adapters.milky.main, satori.adapters.milky.webhook, satori.adapters.milky.sse |
+| QQ         | `pip install satori-python-adapter-qq`       | satori.adapters.qq.main, satori.adapters.qq.websocket                                |
 
 ### 社区适配器
 

{satori_python_adapter_milky-0.2.0 → satori_python_adapter_milky-0.3.1}/README.md

@@ -48,13 +48,13 @@ pip install satori-python-server
 
 ### 官方适配器
 
-| 适配器        | 安装                                           | 路径                                                                 |
-|------------|----------------------------------------------|--------------------------------------------------------------------|
-| Satori     | `pip install satori-python-adapter-satori`   | satori.adapters.satori                                             |
-| OneBot V11 | `pip install satori-python-adapter-onebot11` | satori.adapters.onebot11.forward, satori.adapters.onebot11.reverse |
-| Console    | `pip install satori-python-adapter-console`  | satori.adapters.console                                            |
-| Milky      | `pip install satori-python-adapter-milky`    | satori.adapters.milky.main, satori.adapters.milky.webhook          |
-| QQ         | `pip install satori-python-adapter-qq`       | satori.adapters.milky.main, satori.adapters.milky.websocket        |
+| 适配器        | 安装                                           | 路径                                                                                   |
+|------------|----------------------------------------------|--------------------------------------------------------------------------------------|
+| Satori     | `pip install satori-python-adapter-satori`   | satori.adapters.satori                                                               |
+| OneBot V11 | `pip install satori-python-adapter-onebot11` | satori.adapters.onebot11.forward, satori.adapters.onebot11.reverse                   |
+| Console    | `pip install satori-python-adapter-console`  | satori.adapters.console                                                              |
+| Milky      | `pip install satori-python-adapter-milky`    | satori.adapters.milky.main, satori.adapters.milky.webhook, satori.adapters.milky.sse |
+| QQ         | `pip install satori-python-adapter-qq`       | satori.adapters.qq.main, satori.adapters.qq.websocket                                |
 
 ### 社区适配器
 

{satori_python_adapter_milky-0.2.0 → satori_python_adapter_milky-0.3.1}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "satori-python-adapter-milky"
-version = "0.2.0"
+version = "0.3.1"
 authors = [
     { name = "RF-Tar-Railt", email = "rf_tar_railt@qq.com" },
 ]
 dependencies = [
-    "satori-python-server >= 0.18.0",
+    "satori-python-server<1.4.0,>= 1.3.0",
 ]
 description = "Satori Protocol SDK for python, adapter for Milky"
 readme = "README.md"

satori_python_adapter_milky-0.3.1/src/satori/adapters/milky/__init__.py

@@ -0,0 +1,5 @@
+from .main import MilkyWebsocketAdapter as MilkyWebsocketAdapter
+from .sse import MilkySSEAdapter as MilkySSEAdapter
+from .webhook import MilkyWebhookAdapter as MilkyWebhookAdapter
+
+__all__ = ["MilkyWebsocketAdapter", "MilkySSEAdapter", "MilkyWebhookAdapter"]

{satori_python_adapter_milky-0.2.0 → satori_python_adapter_milky-0.3.1}/src/satori/adapters/milky/api.py

@@ -17,6 +17,7 @@ from satori.server.route import (
     GuildMemberGetParam,
     GuildMemberKickParam,
     GuildMemberMuteParam,
+    GuildMemberRoleParam,
     GuildXXXListParam,
     MessageListParam,
     MessageOpParam,
@@ -24,11 +25,12 @@ from satori.server.route import (
     ReactionCreateParam,
     ReactionDeleteParam,
     UserChannelCreateParam,
-    UserGetParam,
+    UserOpParam,
 )
 
 from .message import MilkyMessageEncoder, decode_message
 from .utils import (
+    ROLE_MAPPING,
     MilkyNetwork,
     decode_friend,
     decode_group_channel,
@@ -219,12 +221,42 @@ def apply(
         )
         return
 
+    @adapter.route(Api.GUILD_MEMBER_ROLE_SET)
+    async def guild_member_role_set(request: Request[GuildMemberRoleParam]):
+        net = net_getter(request.self_id)
+        await net.call_api(
+            "set_group_member_admin ",
+            {
+                "group_id": int(request.params["guild_id"]),
+                "user_id": int(request.params["user_id"]),
+                "is_set": request.params["role_id"] == "admin",
+            },
+        )
+        return
+
+    @adapter.route(Api.GUILD_MEMBER_ROLE_UNSET)
+    async def guild_member_role_unset(request: Request[GuildMemberRoleParam]):
+        net = net_getter(request.self_id)
+        await net.call_api(
+            "set_group_member_admin ",
+            {
+                "group_id": int(request.params["guild_id"]),
+                "user_id": int(request.params["user_id"]),
+                "is_set": request.params["role_id"] != "admin",
+            },
+        )
+        return
+
+    @adapter.route(Api.GUILD_ROLE_LIST)
+    async def guild_role_list(request: Request[GuildXXXListParam]):
+        return PageResult(list(ROLE_MAPPING.values()))
+
     @adapter.route(Api.GUILD_MEMBER_APPROVE)
     async def guild_member_approve(request: Request[ApproveParam]):
         net = net_getter(request.self_id)
         message_id = request.params["message_id"]
         notification_seq, notification_type, group_id, is_filtered = message_id.split("|")
-        params = {
+        params: dict = {
             "notification_seq": int(notification_seq),
             "notification_type": notification_type,
             "group_id": int(group_id),
@@ -259,7 +291,7 @@ def apply(
             {
                 "group_id": peer_id,
                 "message_seq": int(request.params["message_id"]),
-                "reaction": request.params["emoji"],
+                "reaction": request.params["emoji_id"],
                 "is_add": True,
             },
         )
@@ -276,14 +308,14 @@ def apply(
             {
                 "group_id": peer_id,
                 "message_seq": int(request.params["message_id"]),
-                "reaction": request.params["emoji"],
+                "reaction": request.params["emoji_id"],
                 "is_add": False,
             },
         )
         return
 
     @adapter.route(Api.USER_GET)
-    async def user_get(request: Request[UserGetParam]):
+    async def user_get(request: Request[UserOpParam]):
         net = net_getter(request.self_id)
         user_id = request.params["user_id"]
         profile = await net.call_api("get_user_profile", {"user_id": int(user_id)})
@@ -291,6 +323,13 @@ def apply(
             raise RuntimeError("Failed to get user profile")
         return decode_user_profile(profile, user_id)
 
+    @adapter.route(Api.FRIEND_DELETE)
+    async def friend_delete(request: Request[UserOpParam]):
+        net = net_getter(request.self_id)
+        user_id = request.params["user_id"]
+        await net.call_api("delete_friend", {"user_id": int(user_id)})
+        return
+
     @adapter.route(Api.FRIEND_LIST)
     async def friend_list(request: Request[FriendListParam]):
         net = net_getter(request.self_id)
@@ -302,7 +341,7 @@ def apply(
     async def friend_approve(request: Request[ApproveParam]):
         net = net_getter(request.self_id)
         initiator_uid, is_filtered = request.params["message_id"].split("|")
-        payload = {"initiator_uid": initiator_uid, "is_filtered": bool(int(is_filtered))}
+        payload: dict = {"initiator_uid": initiator_uid, "is_filtered": bool(int(is_filtered))}
         if request.params["approve"]:
             await net.call_api("accept_friend_request", payload)
         else:

satori_python_adapter_milky-0.2.0/src/satori/adapters/milky/webhook.py → satori_python_adapter_milky-0.3.1/src/satori/adapters/milky/base.py

@@ -1,14 +1,12 @@
 from __future__ import annotations
 
+from abc import ABC
 from datetime import datetime
 
 import aiohttp
-from launart import Launart
 from launart.status import Phase
 from loguru import logger
-from starlette.requests import Request as StarletteRequest
 from starlette.responses import JSONResponse, Response
-from starlette.routing import Route
 from yarl import URL
 
 from satori import EventType
@@ -20,20 +18,13 @@ from satori.utils import decode, encode
 
 from .api import apply
 from .events import event_handlers
-from .utils import MilkyNetwork, decode_login_user
+from .utils import decode_login_user
 
 DEFAULT_FEATURES = ["guild.plain", "reaction"]
 
 
-class _MilkyNetwork:
-    def __init__(self, adapter: MilkyWebhookAdapter):  # type: ignore[name-defined]
-        self.adapter = adapter
-
-    async def call_api(self, action: str, params: dict | None = None):
-        return await self.adapter.call_api(action, params or {})
-
-
-class MilkyWebhookAdapter(BaseAdapter):
+class MilkyBaseAdapter(BaseAdapter, ABC):
+    """Base adapter for Milky protocol with common functionality."""
 
     session: aiohttp.ClientSession | None
 
@@ -43,8 +34,6 @@ class MilkyWebhookAdapter(BaseAdapter):
         *,
         token: str | None = None,
         headers: dict[str, str] | None = None,
-        path: str = "/milky",
-        self_token: str | None = None,
     ):
         super().__init__()
         self.base_url = URL(str(endpoint))
@@ -54,11 +43,8 @@ class MilkyWebhookAdapter(BaseAdapter):
         self.headers = headers.copy() if headers else {}
         self.session = None
         self.logins: dict[str, Login] = {}
-        self.networks: dict[str, MilkyNetwork] = {}
-        self.features = list(DEFAULT_FEATURES)
-        self.webhook_token = self_token if self_token is not None else token
-        self.webhook_paths = self._normalize_webhook_paths(path)
-        apply(self, self._get_network, self._get_login)
+        self.features: list[str] = list(DEFAULT_FEATURES)
+        apply(self, lambda _: self, self._get_login)
 
     def get_platform(self) -> str:
         return "milky"
@@ -80,19 +66,6 @@ class MilkyWebhookAdapter(BaseAdapter):
     def stages(self) -> set[Phase]:
         return {"preparing", "blocking", "cleanup"}
 
-    async def launch(self, manager: Launart):
-        async with self.stage("preparing"):
-            self.session = aiohttp.ClientSession()
-
-        async with self.stage("blocking"):
-            await manager.status.wait_for_sigexit()
-
-        async with self.stage("cleanup"):
-            if self.session:
-                await self.session.close()
-            self.session = None
-            await self._handle_disconnect()
-
     def proxy_urls(self) -> list[str]:
         return []
 
@@ -125,9 +98,6 @@ class MilkyWebhookAdapter(BaseAdapter):
             raise ActionFailed(f"{data.get('retcode')}: {data.get('message')}", data)
         return data.get("data")
 
-    def get_routes(self) -> list[Route]:
-        return [Route(path, self.webhook_endpoint, methods=["POST"]) for path in self.webhook_paths]
-
     async def handle_event(self, payload: dict):
         event_type = payload.get("event_type")
         self_id = str(payload.get("self_id"))
@@ -140,12 +110,8 @@ class MilkyWebhookAdapter(BaseAdapter):
             return
         login = self.logins[self_id]
         handler = event_handlers.get(event_type)
-        network = self.networks.get(self_id)
-        if not network:
-            network = _MilkyNetwork(self)
-            self.networks[self_id] = network
         if handler:
-            event = await handler(login, network, payload)
+            event = await handler(login, self, payload)
         else:
             event = Event(
                 EventType.INTERNAL,
@@ -170,7 +136,6 @@ class MilkyWebhookAdapter(BaseAdapter):
         self_id = login.id
         previous = self.logins.get(self_id)
         self.logins[self_id] = login
-        self.networks[self_id] = _MilkyNetwork(self)
         event_type = EventType.LOGIN_ADDED if previous is None else EventType.LOGIN_UPDATED
         await self.server.post(Event(event_type, datetime.now(), login))
 
@@ -179,53 +144,9 @@ class MilkyWebhookAdapter(BaseAdapter):
             login.status = LoginStatus.OFFLINE
             await self.server.post(Event(EventType.LOGIN_REMOVED, datetime.now(), login))
             self.logins.pop(self_id, None)
-            self.networks.pop(self_id, None)
-
-    def _normalize_webhook_paths(self, webhook_path: str) -> tuple[str, ...]:
-        path = webhook_path or "/"
-        normalized = path if path.startswith("/") else f"/{path}"
-        paths: set[str] = {normalized}
-        stripped = normalized.rstrip("/")
-        if stripped and stripped != normalized:
-            paths.add(stripped)
-        return tuple(sorted(paths))
-
-    def _get_network(self, self_id: str) -> MilkyNetwork:
-        network = self.networks.get(self_id)
-        if not network:
-            network = _MilkyNetwork(self)
-            self.networks[self_id] = network
-        return network
 
     def _get_login(self, self_id: str) -> Login:
         return self.logins[self_id]
 
-    async def webhook_endpoint(self, request: StarletteRequest) -> Response:
-        if self.webhook_token:
-            auth_header = request.headers.get("Authorization")
-            provided = None
-            if auth_header:
-                if auth_header.lower().startswith("bearer "):
-                    provided = auth_header[7:]
-                else:
-                    provided = auth_header
-            if provided is None:
-                provided = request.query_params.get("access_token")
-            if provided != self.webhook_token:
-                return JSONResponse({"error": "unauthorized"}, status_code=401)
-        try:
-            payload = await request.json()
-        except Exception as e:  # pragma: no cover - defensive
-            logger.error(f"Failed to parse milky webhook payload: {e}")
-            return JSONResponse({"error": "invalid json"}, status_code=400)
-        if not isinstance(payload, dict):
-            return JSONResponse({"error": "invalid payload"}, status_code=400)
-        try:
-            await self.handle_event(payload)
-        except Exception as e:  # pragma: no cover - defensive
-            logger.exception("Error while processing milky webhook event", exc_info=e)
-            return JSONResponse({"error": "internal error"}, status_code=500)
-        return Response(status_code=204)
-
 
-__all__ = ["MilkyWebhookAdapter"]
+__all__ = ["MilkyBaseAdapter", "DEFAULT_FEATURES"]

{satori_python_adapter_milky-0.2.0 → satori_python_adapter_milky-0.3.1}/src/satori/adapters/milky/events/message.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from datetime import datetime
 
 from satori import EventType
-from satori.model import Channel, ChannelType, Event, Guild, MessageObject, User
+from satori.model import Channel, ChannelType, EmojiObject, Event, Guild, MessageObject, User
 
 from ..message import decode_message
 from ..utils import group_avatar, user_avatar
@@ -61,9 +61,9 @@ async def group_message_reaction(login, net, raw):
     guild = Guild(guild_id, avatar=group_avatar(guild_id))
     channel = Channel(guild_id, ChannelType.TEXT)
     user = User(str(data["user_id"]), avatar=user_avatar(data["user_id"]))
-    face_id = data["face_id"]
+    emoji_id = data["face_id"]
     message = MessageObject(
-        str(data["message_seq"]), f"<milky:face id='{face_id}'>", channel=channel, guild=guild, user=user
+        str(data["message_seq"]), f"<emoji id='{emoji_id}'>", channel=channel, guild=guild, user=user
     )
     if data["is_add"]:
         event_type = EventType.REACTION_ADDED
@@ -77,4 +77,5 @@ async def group_message_reaction(login, net, raw):
         guild=guild,
         user=user,
         message=message,
+        emoji=EmojiObject(emoji_id),
     )

satori_python_adapter_milky-0.3.1/src/satori/adapters/milky/main.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import asyncio
+
+import aiohttp
+from launart import Launart, any_completed
+from loguru import logger
+from yarl import URL
+
+from satori.utils import decode
+
+from .base import MilkyBaseAdapter
+
+
+class MilkyWebsocketAdapter(MilkyBaseAdapter):
+
+    connection: aiohttp.ClientWebSocketResponse | None
+
+    def __init__(
+        self,
+        endpoint: str | URL,
+        *,
+        token: str | None = None,
+        token_in_query: bool = False,
+        headers: dict[str, str] | None = None,
+    ):
+        super().__init__(endpoint, token=token, headers=headers)
+        base_path = self.base_url.path.rstrip("/")
+        ws_scheme = "wss" if self.base_url.scheme == "https" else "ws"
+        self.event_url = self.base_url.with_scheme(ws_scheme).with_path(f"{base_path}/event")
+        if token_in_query and token:
+            self.event_url = self.event_url.update_query(access_token=token)
+        self.connection = None
+        self.close_signal = asyncio.Event()
+
+    async def launch(self, manager: Launart):
+        async with self.stage("preparing"):
+            self.session = aiohttp.ClientSession()
+
+        async with self.stage("blocking"):
+            await self.connection_daemon(manager, self.session)
+
+        async with self.stage("cleanup"):
+            if self.connection and not self.connection.closed:
+                await self.connection.close()
+            if self.session:
+                await self.session.close()
+            self.connection = None
+            self.session = None
+            await self._handle_disconnect()
+
+    async def connection_daemon(self, manager: Launart, session: aiohttp.ClientSession):
+        while not manager.status.exiting:
+            headers = self.headers.copy()
+            if self.token:
+                headers.setdefault("Authorization", f"Bearer {self.token}")
+            try:
+                self.connection = await session.ws_connect(self.event_url, headers=headers)
+            except Exception as e:
+                logger.error(f"Milky adapter websocket connect failed: {e}")
+                await asyncio.sleep(5)
+                continue
+            logger.info("Milky adapter websocket connected")
+            self.close_signal.clear()
+            await self.refresh_login()
+            receiver_task = asyncio.create_task(self.message_handle())
+            close_task = asyncio.create_task(self.close_signal.wait())
+            sigexit_task = asyncio.create_task(manager.status.wait_for_sigexit())
+
+            done, pending = await any_completed(receiver_task, close_task, sigexit_task)
+            for task in pending:
+                task.cancel()
+            await asyncio.gather(*pending, return_exceptions=True)
+            if sigexit_task in done:
+                break
+            logger.warning("Milky adapter websocket closed, retrying in 5 seconds")
+            await self._handle_disconnect()
+            await asyncio.sleep(5)
+        await self._handle_disconnect()
+
+    async def message_handle(self):
+        assert self.connection is not None
+        async for msg in self.connection:
+            if msg.type in (aiohttp.WSMsgType.CLOSE, aiohttp.WSMsgType.ERROR, aiohttp.WSMsgType.CLOSED):
+                self.close_signal.set()
+                break
+            if msg.type != aiohttp.WSMsgType.TEXT:
+                continue
+            try:
+                data = decode(msg.data)
+            except Exception as e:  # pragma: no cover - defensive
+                logger.error(f"Failed to decode milky event: {e}")
+                continue
+            if not isinstance(data, dict):
+                continue
+            await self.handle_event(data)
+
+    async def _handle_disconnect(self):
+        await super()._handle_disconnect()
+        if self.connection and not self.connection.closed:
+            await self.connection.close()
+        self.close_signal.set()
+
+
+__all__ = ["MilkyWebsocketAdapter"]

{satori_python_adapter_milky-0.2.0 → satori_python_adapter_milky-0.3.1}/src/satori/adapters/milky/message.py

@@ -157,8 +157,13 @@ class MilkyMessageEncoder:
                 if poster := attrs.get("poster"):
                     payload["thumb_uri"] = poster
                 self.segments.append({"type": "video", "data": payload})
-            case "milky:face":
-                self.segments.append({"type": "face", "data": {"face_id": attrs["id"]}})
+            case "milky:face" | "emoji":
+                if ":" in attrs["id"]:
+                    _, emj_id_str = attrs["id"].split(":", 1)
+                    emj_id = emj_id_str
+                else:
+                    emj_id = attrs["id"]
+                self.segments.append({"type": "face", "data": {"face_id": emj_id}})
             case "file":
                 await self.flush()
                 await self._send_file(attrs)
@@ -362,6 +367,8 @@ async def _decode_segments(net: MilkyNetwork, payload: dict, segments: Sequence[
                 result.append(E.at(str(data.get("user_id"))))
             case "mention_all":
                 result.append(E.at_all())
+            case "face":
+                result.append(E.emoji(str(data.get("face_id"))))
             case "image":
                 result.append(E.image(_resource_url(data)))
             case "record":

satori_python_adapter_milky-0.3.1/src/satori/adapters/milky/sse.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import asyncio
+
+import aiohttp
+from launart import Launart, any_completed
+from loguru import logger
+from yarl import URL
+
+from satori.utils import decode
+
+from .base import MilkyBaseAdapter
+
+
+class MilkySSEAdapter(MilkyBaseAdapter):
+
+    def __init__(
+        self,
+        endpoint: str | URL,
+        *,
+        token: str | None = None,
+        token_in_query: bool = False,
+        headers: dict[str, str] | None = None,
+    ):
+        super().__init__(endpoint, token=token, headers=headers)
+        base_path = self.base_url.path.rstrip("/")
+        self.event_url = self.base_url.with_path(f"{base_path}/event")
+        if token_in_query and token:
+            self.event_url = self.event_url.update_query(access_token=token)
+        self.close_signal = asyncio.Event()
+
+    async def launch(self, manager: Launart):
+        async with self.stage("preparing"):
+            self.session = aiohttp.ClientSession()
+
+        async with self.stage("blocking"):
+            await self.connection_daemon(manager, self.session)
+
+        async with self.stage("cleanup"):
+            if self.session:
+                await self.session.close()
+            self.session = None
+            await self._handle_disconnect()
+
+    async def connection_daemon(self, manager: Launart, session: aiohttp.ClientSession):
+        while not manager.status.exiting:
+            headers = self.headers.copy()
+            headers["Accept"] = "text/event-stream"
+            headers["Cache-Control"] = "no-cache"
+            headers["Upgrade"] = "none"
+            if self.token:
+                headers.setdefault("Authorization", f"Bearer {self.token}")
+            try:
+                async with session.get(self.event_url, headers=headers) as response:
+                    if response.status != 200:
+                        logger.error(f"Milky SSE adapter connect failed with status {response.status}")
+                        await asyncio.sleep(5)
+                        continue
+                    logger.info("Milky SSE adapter connected")
+                    self.close_signal.clear()
+                    await self.refresh_login()
+
+                    receiver_task = asyncio.create_task(self._read_sse_stream(response))
+                    close_task = asyncio.create_task(self.close_signal.wait())
+                    sigexit_task = asyncio.create_task(manager.status.wait_for_sigexit())
+
+                    done, pending = await any_completed(receiver_task, close_task, sigexit_task)
+                    for task in pending:
+                        task.cancel()
+                    await asyncio.gather(*pending, return_exceptions=True)
+                    if sigexit_task in done:
+                        break
+            except aiohttp.ClientError as e:
+                logger.error(f"Milky SSE adapter connection error: {e}")
+            except Exception as e:
+                logger.error(f"Milky SSE adapter unexpected error: {e}")
+
+            logger.warning("Milky SSE adapter connection closed, retrying in 5 seconds")
+            await self._handle_disconnect()
+            await asyncio.sleep(5)
+        await self._handle_disconnect()
+
+    async def _read_sse_stream(self, response: aiohttp.ClientResponse):
+        """Read and parse SSE stream without external dependencies."""
+        event_type: str | None = None
+        data_buffer: list[str] = []
+
+        async for line_bytes in response.content:
+            line = line_bytes.decode("utf-8").rstrip("\r\n")
+
+            if not line:
+                # Empty line indicates end of event
+                if data_buffer:
+                    data_str = "\n".join(data_buffer)
+                    await self._dispatch_sse_event(event_type, data_str)
+                event_type = None
+                data_buffer = []
+                continue
+
+            if line.startswith(":"):
+                # Comment line, ignore
+                continue
+
+            if ":" in line:
+                field, _, value = line.partition(":")
+                # Remove leading space from value if present
+                if value.startswith(" "):
+                    value = value[1:]
+            else:
+                field = line
+                value = ""
+
+            if field == "event":
+                event_type = value
+            elif field == "data":
+                data_buffer.append(value)
+            elif field == "id":
+                # Event ID, could be used for reconnection
+                pass
+            elif field == "retry":
+                # Retry interval, could be implemented if needed
+                pass
+
+    async def _dispatch_sse_event(self, event_type: str | None, data: str):
+        """Dispatch a parsed SSE event."""
+        if not data or event_type != "milky_event":
+            return
+        try:
+            payload = decode(data)
+        except Exception as e:
+            logger.error(f"Failed to decode SSE event data: {e}")
+            return
+        if not isinstance(payload, dict):
+            return
+        await self.handle_event(payload)
+
+    async def _handle_disconnect(self):
+        await super()._handle_disconnect()
+        self.close_signal.set()
+
+
+__all__ = ["MilkySSEAdapter"]

{satori_python_adapter_milky-0.2.0 → satori_python_adapter_milky-0.3.1}/src/satori/adapters/milky/utils.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Literal, Protocol
 
-from satori.model import Channel, ChannelType, Guild, Member, User
+from satori.model import Channel, ChannelType, Friend, Guild, Member, Role, User
 
 AVATAR_URL = "https://q.qlogo.cn/headimg_dl?dst_uin={uin}&spec=640"
 GROUP_AVATAR_URL = "https://p.qlogo.cn/gh/{group}/{group}/640"
@@ -33,6 +33,13 @@ def decode_guild(group: dict) -> Guild:
     return Guild(str(group["group_id"]), group.get("group_name"), group_avatar(group["group_id"]))
 
 
+ROLE_MAPPING = {
+    "member": Role("member", "群成员"),
+    "admin": Role("admin", "管理员"),
+    "owner": Role("owner", "群主"),
+}
+
+
 def decode_member(member: dict) -> Member:
     user_id = str(member["user_id"])
     user = User(user_id, member.get("nickname"), avatar=user_avatar(user_id))
@@ -42,12 +49,13 @@ def decode_member(member: dict) -> Member:
         nick=member.get("card") or member.get("nickname"),
         avatar=user_avatar(user_id),
         joined_at=datetime.fromtimestamp(joined_at) if joined_at else None,
+        roles=[ROLE_MAPPING[member.get("role", "member")]],
     )
 
 
-def decode_friend(friend: dict) -> User:
+def decode_friend(friend: dict) -> Friend:
     user_id = str(friend["user_id"])
-    return User(user_id, friend.get("nickname"), avatar=user_avatar(user_id))
+    return Friend(User(user_id, friend.get("nickname"), avatar=user_avatar(user_id)), friend.get("remark"))
 
 
 def decode_login_user(login: dict) -> User:

satori_python_adapter_milky-0.3.1/src/satori/adapters/milky/webhook.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import aiohttp
+from launart import Launart
+from loguru import logger
+from starlette.requests import Request as StarletteRequest
+from starlette.responses import JSONResponse, Response
+from starlette.routing import Route
+from yarl import URL
+
+from .base import MilkyBaseAdapter
+
+
+class MilkyWebhookAdapter(MilkyBaseAdapter):
+
+    def __init__(
+        self,
+        endpoint: str | URL,
+        *,
+        token: str | None = None,
+        headers: dict[str, str] | None = None,
+        path: str = "/milky",
+        self_token: str | None = None,
+    ):
+        super().__init__(endpoint, token=token, headers=headers)
+        self.webhook_token = self_token if self_token is not None else token
+        self.webhook_paths = self._normalize_webhook_paths(path)
+
+    async def launch(self, manager: Launart):
+        async with self.stage("preparing"):
+            self.session = aiohttp.ClientSession()
+
+        async with self.stage("blocking"):
+            await manager.status.wait_for_sigexit()
+
+        async with self.stage("cleanup"):
+            if self.session:
+                await self.session.close()
+            self.session = None
+            await self._handle_disconnect()
+
+    def get_routes(self) -> list[Route]:
+        return [Route(path, self.webhook_endpoint, methods=["POST"]) for path in self.webhook_paths]
+
+    def _normalize_webhook_paths(self, webhook_path: str) -> tuple[str, ...]:
+        path = webhook_path or "/"
+        normalized = path if path.startswith("/") else f"/{path}"
+        paths: set[str] = {normalized}
+        stripped = normalized.rstrip("/")
+        if stripped and stripped != normalized:
+            paths.add(stripped)
+        return tuple(sorted(paths))
+
+    async def webhook_endpoint(self, request: StarletteRequest) -> Response:
+        if self.webhook_token:
+            auth_header = request.headers.get("Authorization")
+            provided = None
+            if auth_header:
+                if auth_header.lower().startswith("bearer "):
+                    provided = auth_header[7:]
+                else:
+                    provided = auth_header
+            if provided is None:
+                provided = request.query_params.get("access_token")
+            if provided != self.webhook_token:
+                return JSONResponse({"error": "unauthorized"}, status_code=401)
+        try:
+            payload = await request.json()
+        except Exception as e:  # pragma: no cover - defensive
+            logger.error(f"Failed to parse milky webhook payload: {e}")
+            return JSONResponse({"error": "invalid json"}, status_code=400)
+        if not isinstance(payload, dict):
+            return JSONResponse({"error": "invalid payload"}, status_code=400)
+        try:
+            await self.handle_event(payload)
+        except Exception as e:  # pragma: no cover - defensive
+            logger.exception("Error while processing milky webhook event", exc_info=e)
+            return JSONResponse({"error": "internal error"}, status_code=500)
+        return Response(status_code=204)
+
+
+__all__ = ["MilkyWebhookAdapter"]

satori_python_adapter_milky-0.2.0/src/satori/adapters/milky/__init__.py

@@ -1,4 +0,0 @@
-from .main import MilkyAdapter as MilkyAdapter
-from .webhook import MilkyWebhookAdapter as MilkyWebhookAdapter
-
-__all__ = ["MilkyAdapter", "MilkyWebhookAdapter"]

satori_python_adapter_milky-0.2.0/src/satori/adapters/milky/main.py

@@ -1,247 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from datetime import datetime
-
-import aiohttp
-from launart import Launart, any_completed
-from launart.status import Phase
-from loguru import logger
-from starlette.responses import JSONResponse, Response
-from yarl import URL
-
-from satori import EventType
-from satori.exception import ActionFailed
-from satori.model import Event, Login, LoginStatus
-from satori.server.adapter import Adapter as BaseAdapter
-from satori.server.model import Request
-from satori.utils import decode, encode
-
-from .api import apply
-from .events import event_handlers
-from .utils import MilkyNetwork, decode_login_user
-
-DEFAULT_FEATURES = ["guild.plain", "reaction"]
-
-
-class _MilkyNetwork:
-    def __init__(self, adapter: MilkyAdapter):  # type: ignore[name-defined]
-        self.adapter = adapter
-
-    async def call_api(self, action: str, params: dict | None = None):
-        return await self.adapter.call_api(action, params or {})
-
-
-class MilkyAdapter(BaseAdapter):
-
-    session: aiohttp.ClientSession | None
-    connection: aiohttp.ClientWebSocketResponse | None
-
-    def __init__(
-        self,
-        endpoint: str | URL,
-        *,
-        token: str | None = None,
-        token_in_query: bool = False,
-        headers: dict[str, str] | None = None,
-    ):
-        super().__init__()
-        self.base_url = URL(str(endpoint))
-        base_path = self.base_url.path.rstrip("/")
-        self.api_base = self.base_url.with_path(f"{base_path}/api")
-        ws_scheme = "wss" if self.base_url.scheme == "https" else "ws"
-        self.event_url = self.base_url.with_scheme(ws_scheme).with_path(f"{base_path}/event")
-        if token_in_query and token:
-            self.event_url = self.event_url.update_query(access_token=token)
-        self.token = token
-        self.headers = headers.copy() if headers else {}
-        self.session = None
-        self.connection = None
-        self.close_signal = asyncio.Event()
-        self.logins: dict[str, Login] = {}
-        self.networks: dict[str, MilkyNetwork] = {}
-        self.features = list(DEFAULT_FEATURES)
-        apply(self, self._get_network, self._get_login)
-
-    def get_platform(self) -> str:
-        return "milky"
-
-    def ensure(self, platform: str, self_id: str) -> bool:
-        return platform == "milky" and self_id in self.logins
-
-    async def get_logins(self) -> list[Login]:
-        logins = list(self.logins.values())
-        for index, login in enumerate(logins):
-            login.sn = index
-        return logins
-
-    @property
-    def required(self) -> set[str]:
-        return {"satori-python.server"}
-
-    @property
-    def stages(self) -> set[Phase]:
-        return {"preparing", "blocking", "cleanup"}
-
-    async def launch(self, manager: Launart):
-        async with self.stage("preparing"):
-            self.session = aiohttp.ClientSession()
-
-        async with self.stage("blocking"):
-            await self.connection_daemon(manager, self.session)
-
-        async with self.stage("cleanup"):
-            if self.connection and not self.connection.closed:
-                await self.connection.close()
-            if self.session:
-                await self.session.close()
-            self.connection = None
-            self.session = None
-            await self._handle_disconnect()
-
-    def proxy_urls(self) -> list[str]:
-        return []
-
-    async def handle_internal(self, request: Request, path: str) -> Response:
-        if path.startswith("_api"):
-            data = await request.origin.json()
-            return JSONResponse(await self.call_api(path[5:], data))
-        if not self.session:
-            raise RuntimeError("HTTP session not initialized")
-        url = self.base_url.with_path(path)
-        headers = self.headers.copy()
-        if self.token:
-            headers.setdefault("Authorization", f"Bearer {self.token}")
-        async with self.session.get(url, headers=headers) as resp:
-            content = await resp.read()
-            return Response(content=content, media_type=resp.headers.get("Content-Type"))
-
-    async def call_api(self, action: str, params: dict | None = None) -> dict:
-        if not self.session:
-            raise RuntimeError("HTTP session not initialized")
-        url = self.api_base.with_path(f"{self.api_base.path.rstrip('/')}/{action}")
-        headers = self.headers.copy()
-        headers["Content-Type"] = "application/json"
-        if self.token:
-            headers.setdefault("Authorization", f"Bearer {self.token}")
-        async with self.session.post(url, data=encode(params or {}), headers=headers) as resp:
-            resp.raise_for_status()
-            data = decode(await resp.text())
-        if data.get("status") == "failed" or data.get("retcode", 0) != 0:
-            raise ActionFailed(f"{data.get('retcode')}: {data.get('message')}", data)
-        return data.get("data")
-
-    async def connection_daemon(self, manager: Launart, session: aiohttp.ClientSession):
-        while not manager.status.exiting:
-            headers = self.headers.copy()
-            if self.token:
-                headers.setdefault("Authorization", f"Bearer {self.token}")
-            try:
-                self.connection = await session.ws_connect(self.event_url, headers=headers)
-            except Exception as e:
-                logger.error(f"Milky adapter websocket connect failed: {e}")
-                await asyncio.sleep(5)
-                continue
-            logger.info("Milky adapter websocket connected")
-            self.close_signal.clear()
-            await self.refresh_login()
-            receiver_task = asyncio.create_task(self.message_handle())
-            close_task = asyncio.create_task(self.close_signal.wait())
-            sigexit_task = asyncio.create_task(manager.status.wait_for_sigexit())
-
-            done, pending = await any_completed(receiver_task, close_task, sigexit_task)
-            for task in pending:
-                task.cancel()
-            await asyncio.gather(*pending, return_exceptions=True)
-            if sigexit_task in done:
-                break
-            logger.warning("Milky adapter websocket closed, retrying in 5 seconds")
-            await self._handle_disconnect()
-            await asyncio.sleep(5)
-        await self._handle_disconnect()
-
-    async def message_handle(self):
-        assert self.connection is not None
-        async for msg in self.connection:
-            if msg.type in (aiohttp.WSMsgType.CLOSE, aiohttp.WSMsgType.ERROR, aiohttp.WSMsgType.CLOSED):
-                self.close_signal.set()
-                break
-            if msg.type != aiohttp.WSMsgType.TEXT:
-                continue
-            try:
-                data = decode(msg.data)
-            except Exception as e:  # pragma: no cover - defensive
-                logger.error(f"Failed to decode milky event: {e}")
-                continue
-            if not isinstance(data, dict):
-                continue
-            await self.handle_event(data)
-
-    async def handle_event(self, payload: dict):
-        event_type = payload.get("event_type")
-        self_id = str(payload.get("self_id"))
-        if not event_type or not self_id:
-            return
-        if self_id not in self.logins:
-            await self.refresh_login()
-        if self_id not in self.logins:
-            logger.warning(f"Ignoring event for unknown self_id {self_id}")
-            return
-        login = self.logins[self_id]
-        handler = event_handlers.get(event_type)
-        network = self.networks.get(self_id)
-        if not network:
-            network = _MilkyNetwork(self)
-            self.networks[self_id] = network
-        if handler:
-            event = await handler(login, network, payload)
-        else:
-            event = Event(
-                EventType.INTERNAL,
-                datetime.fromtimestamp(payload.get("time", datetime.now().timestamp())),
-                login,
-            )
-        if event:
-            event._type = event_type
-            event._data = payload.get("data", {})
-            await self.server.post(event)
-
-    async def refresh_login(self):
-        try:
-            data = await self.call_api("get_login_info", {})
-        except Exception as e:
-            logger.error(f"Failed to fetch milky login info: {e}")
-            return
-        if not data:
-            return
-        user = decode_login_user(data)
-        login = Login(0, LoginStatus.ONLINE, "milky", platform="milky", user=user, features=self.features.copy())
-        self_id = login.id
-        previous = self.logins.get(self_id)
-        self.logins[self_id] = login
-        self.networks[self_id] = _MilkyNetwork(self)
-        event_type = EventType.LOGIN_ADDED if previous is None else EventType.LOGIN_UPDATED
-        await self.server.post(Event(event_type, datetime.now(), login))
-
-    async def _handle_disconnect(self):
-        for self_id, login in list(self.logins.items()):
-            login.status = LoginStatus.OFFLINE
-            await self.server.post(Event(EventType.LOGIN_REMOVED, datetime.now(), login))
-            self.logins.pop(self_id, None)
-            self.networks.pop(self_id, None)
-        if self.connection and not self.connection.closed:
-            await self.connection.close()
-        self.close_signal.set()
-
-    def _get_network(self, self_id: str) -> MilkyNetwork:
-        network = self.networks.get(self_id)
-        if not network:
-            network = _MilkyNetwork(self)
-            self.networks[self_id] = network
-        return network
-
-    def _get_login(self, self_id: str) -> Login:
-        return self.logins[self_id]
-
-
-__all__ = ["MilkyAdapter"]