satori-python-adapter-qq 0.1.0__py3-none-any.whl

.mina/adapter_qq.toml

@@ -0,0 +1,32 @@
+includes = ["src/satori/adapters/qq"]
+raw-dependencies = [
+    "satori-python >= 0.18.0",
+    "crypography>=46.0.4",
+]
+
+[project]
+name = "satori-python-adapter-qq"
+version = "0.1.0"
+authors = [
+  {name = "RF-Tar-Railt", email = "rf_tar_railt@qq.com"}
+]
+dependencies = []
+description = "Satori Protocol SDK for python, adapter for QQ"
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.10,<4.0"
+classifiers = [
+    "Typing :: Typed",
+    "Development Status :: 4 - Beta",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+homepage = "https://github.com/RF-Tar-Railt/satori-python"
+repository = "https://github.com/RF-Tar-Railt/satori-python"

satori/adapters/qq/api.py

@@ -0,0 +1,433 @@
+from collections.abc import Callable
+from datetime import datetime
+
+from satori import Api, At, Channel, ChannelType, Guild, Login, Member, MessageObject, PageResult, Role, Text
+from satori.exception import BadRequestException, NotFoundException
+from satori.server import Adapter, Request
+from satori.server.route import (
+    ChannelCreateParam,
+    ChannelListParam,
+    ChannelParam,
+    ChannelUpdateParam,
+    GuildGetParam,
+    GuildListParam,
+    GuildMemberGetParam,
+    GuildMemberKickParam,
+    GuildMemberMuteParam,
+    GuildMemberRoleParam,
+    GuildRoleCreateParam,
+    GuildRoleDeleteParam,
+    GuildRoleUpdateParam,
+    GuildXXXListParam,
+    MessageOpParam,
+    MessageParam,
+    ReactionCreateParam,
+    ReactionDeleteParam,
+    ReactionListParam,
+    UserChannelCreateParam,
+    UserGetParam,
+)
+
+from .message import QQGroupMessageEncoder, QQGuildMessageEncoder, decode_segments
+from .utils import QQBotNetwork, decode_channel, decode_guild, decode_member, decode_user
+
+
+def apply(
+    adapter: Adapter, net_getter: Callable[[str, bool], QQBotNetwork], login_getter: Callable[[str, bool], Login]
+):
+    @adapter.route(Api.LOGIN_GET)
+    async def login_get(request: Request):
+        return login_getter(request.self_id, request.platform == "qqguild")
+
+    @adapter.route(Api.MESSAGE_CREATE)
+    async def message_create(request: Request[MessageParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        login = login_getter(request.self_id, request.platform == "qqguild")
+        # encoder = OneBot11MessageEncoder(login, net, request.params["channel_id"])
+        if login.platform == "qqguild":
+            encoder = QQGuildMessageEncoder(login, net, request.params["channel_id"], request.params.get("referrer"))
+        else:
+            encoder = QQGroupMessageEncoder(login, net, request.params["channel_id"], request.params.get("referrer"))
+        await encoder.send(request.params["content"])
+        return encoder.results
+
+    @adapter.route(Api.USER_CHANNEL_CREATE)
+    async def user_channel_create(request: Request[UserChannelCreateParam]):
+        if request.platform == "qqguild":
+            net = net_getter(request.self_id, request.platform == "qqguild")
+            if "guild_id" not in request.params:
+                raise BadRequestException("guild_id is required for qqguild's user.channel.create")
+            guild_id = request.params["guild_id"]
+            if "_" in guild_id:
+                guild_id = guild_id.split("_")[0]
+            res = await net.call_api(
+                "post",
+                "users/@me/dms",
+                {"recipient_id": request.params["user_id"], "source_guild_id": request.params["guild_id"]},
+            )
+            return Channel(f"{res['guild_id']}_{guild_id}", ChannelType.TEXT)
+        else:
+            return Channel(f"private:{request.params['user_id']}", ChannelType.DIRECT)
+
+    @adapter.route(Api.MESSAGE_DELETE)
+    async def delete_message(request: Request[MessageOpParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            if "_" in request.params["channel_id"]:
+                guild_id = request.params["channel_id"].split("_")[0]
+                endpoint = f"dms/{guild_id}/messages/{request.params['message_id']}"
+            else:
+                endpoint = f"channels/{request.params['channel_id']}/messages/{request.params['message_id']}"
+            await net.call_api("delete", endpoint, {"hidetip": "false"})
+        else:
+            if request.params["channel_id"].startswith("private:"):
+                user_id = request.params["channel_id"][8:]
+                endpoint = f"v2/users/{user_id}/messages/{request.params['message_id']}"
+            else:
+                endpoint = f"v2/groups/{request.params['channel_id']}/messages/{request.params['message_id']}"
+            await net.call_api("delete", endpoint)
+
+    @adapter.route(Api.MESSAGE_GET)
+    async def get_message(request: Request[MessageOpParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            if "_" in request.params["channel_id"]:
+                raise NotFoundException("user-channel is not supported for message.get")
+            endpoint = f"channels/{request.params['channel_id']}/messages/{request.params['message_id']}"
+            raw = await net.call_api("get", endpoint)
+            guild = Guild(raw["guild_id"])
+            channel = Channel(raw["channel_id"], ChannelType.TEXT, parent_id=guild.id)
+            user = decode_user(raw["author"])
+            member = Member(
+                user,
+                avatar=user.avatar,
+                joined_at=datetime.fromisoformat(raw["member"]["joined_at"]),
+            )
+            msg = decode_segments(raw)
+            if len(msg) >= 2 and isinstance(msg[0], At) and isinstance(msg[1], Text):
+                text = msg[1].text.lstrip()
+                if not text:
+                    msg.pop(1)
+                else:
+                    msg[1] = Text(text)
+            return MessageObject.from_elements(
+                raw["id"],
+                msg,
+                channel=channel,
+                guild=guild,
+                member=member,
+                user=user,
+                created_at=(
+                    datetime.fromtimestamp(int(raw["timestamp"]))
+                    if isinstance(raw["timestamp"], (int, float)) or raw["timestamp"].isdigit()
+                    else datetime.fromisoformat(str(raw["timestamp"]))
+                ),
+                referrer={
+                    "msg_id": raw["id"],
+                    "msg_seq": -1,
+                },
+            )
+        raise NotFoundException("qq platform does not support message.get")
+
+    @adapter.route(Api.USER_GET)
+    async def guild_get_user(request: Request[UserGetParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            if "_" in request.params["user_id"]:
+                guild_id, user_id = request.params["user_id"].split("_", maxsplit=1)
+                res = await net.call_api(
+                    "get",
+                    f"guilds/{guild_id}/members/{user_id}",
+                )
+                return decode_user(res)
+            raise NotFoundException("qqguild platform does not support user.get without guild_id")
+        raise NotFoundException("qq platform does not support user.get")
+
+    @adapter.route(Api.GUILD_GET)
+    async def guild_get(request: Request[GuildGetParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            res = await net.call_api(
+                "get",
+                f"guilds/{request.params['guild_id']}",
+            )
+            return decode_guild(res)
+        raise NotFoundException("qq platform does not support guild.get")
+
+    @adapter.route(Api.GUILD_LIST)
+    async def guild_list(request: Request[GuildListParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            res = await net.call_api(
+                "get",
+                "users/@me/guilds",
+                {"after": request.params["next"]} if "next" in request.params else None,
+            )
+            guilds = [decode_guild(guild) for guild in res]
+            return PageResult(guilds, next=guilds[-1].id if guilds else None)
+        raise NotFoundException("qq platform does not support guild.list")
+
+    @adapter.route(Api.CHANNEL_GET)
+    async def channel_get(request: Request[ChannelParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            channel_id = request.params["channel_id"].split("_")[-1]
+            res = await net.call_api(
+                "get",
+                f"channels/{channel_id}",
+            )
+            return decode_channel(res)
+        raise NotFoundException("qq platform does not support channel.get")
+
+    @adapter.route(Api.CHANNEL_LIST)
+    async def channel_list(request: Request[ChannelListParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            res = await net.call_api(
+                "get",
+                f"guilds/{guild_id}/channels",
+            )
+            channels = [decode_channel(channel) for channel in res]
+            return PageResult(channels, next=None)
+        raise NotFoundException("qq platform does not support channel.list")
+
+    @adapter.route(Api.CHANNEL_CREATE)
+    async def channel_create(request: Request[ChannelCreateParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            data = request.params["data"]
+            res = await net.call_api(
+                "post",
+                f"guilds/{guild_id}/channels",
+                {
+                    "name": data["name"],
+                    "type": {ChannelType.TEXT.value: 0, ChannelType.VOICE.value: 2, ChannelType.CATEGORY.value: 4}.get(
+                        data.get("type", ChannelType.TEXT.value), 0
+                    ),
+                    "parent_id": data.get("parent_id"),
+                    "sub_type": 0,
+                    "speak_permission": 1,
+                },
+            )
+            return decode_channel(res)
+        raise NotFoundException("qq platform does not support channel.create")
+
+    @adapter.route(Api.CHANNEL_UPDATE)
+    async def channel_update(request: Request[ChannelUpdateParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            channel_id = request.params["channel_id"].split("_")[-1]
+            data = request.params["data"]
+            await net.call_api(
+                "patch",
+                f"channels/{channel_id}",
+                {
+                    "name": data.get("name"),
+                    "parent_id": data.get("parent_id"),
+                },
+            )
+        else:
+            raise NotFoundException("qq platform does not support channel.update")
+
+    @adapter.route(Api.CHANNEL_DELETE)
+    async def channel_delete(request: Request[ChannelParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            channel_id = request.params["channel_id"].split("_")[-1]
+            await net.call_api(
+                "delete",
+                f"channels/{channel_id}",
+            )
+        else:
+            raise NotFoundException("qq platform does not support channel.delete")
+
+    @adapter.route(Api.GUILD_MEMBER_GET)
+    async def guild_get_member(request: Request[GuildMemberGetParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            res = await net.call_api(
+                "get",
+                f"guilds/{guild_id}/members/{request.params['user_id']}",
+            )
+            return decode_member(res)
+        raise NotFoundException("qq platform does not support guild.member.get")
+
+    @adapter.route(Api.GUILD_MEMBER_LIST)
+    async def guild_list_member(request: Request[GuildXXXListParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            res = await net.call_api(
+                "get",
+                f"guilds/{guild_id}/members",
+                {"limit": 400, "after": request.params["next"] if "next" in request.params else "0"},
+            )
+            members = [decode_member(member) for member in res]
+            return PageResult(members, next=members[-1].user.id if members else None)  # type: ignore
+        raise NotFoundException("qq platform does not support guild.member.list")
+
+    @adapter.route(Api.GUILD_MEMBER_KICK)
+    async def guild_kick_member(request: Request[GuildMemberKickParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            await net.call_api(
+                "delete",
+                f"guilds/{guild_id}/members/{request.params['user_id']}",
+            )
+        else:
+            raise NotFoundException("qq platform does not support guild.member.kick")
+
+    @adapter.route(Api.GUILD_MEMBER_MUTE)
+    async def guild_mute_member(request: Request[GuildMemberMuteParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            await net.call_api(
+                "patch",
+                f"guilds/{guild_id}/members/{request.params['user_id']}/mute",
+                {"mute_seconds": request.params.get("duration", 0) // 1000},
+            )
+        else:
+            raise NotFoundException("qq platform does not support guild.member.mute")
+
+    @adapter.route(Api.REACTION_LIST)
+    async def reaction_list(request: Request[ReactionListParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            channel_id = request.params["channel_id"].split("_")[-1]
+            if ":" in request.params["emoji"]:
+                type_, emoji_id = request.params["emoji"].split(":", maxsplit=1)
+            else:
+                type_, emoji_id = "1", request.params["emoji"]
+            res = await net.call_api(
+                "get",
+                f"channels/{channel_id}/messages/{request.params['message_id']}/reactions/{type_}/{emoji_id}",
+                {
+                    "limit": 50,
+                    "cookie": request.params.get("next"),
+                },
+            )
+            users = [decode_user(user) for user in res["users"]]
+            return PageResult(users, next=None if res["is_end"] else res["cookie"])
+        raise NotFoundException("qq platform does not support reaction.list")
+
+    @adapter.route(Api.REACTION_CREATE)
+    async def reaction_create(request: Request[ReactionCreateParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            channel_id = request.params["channel_id"].split("_")[-1]
+            if ":" in request.params["emoji"]:
+                type_, emoji_id = request.params["emoji"].split(":", maxsplit=1)
+            else:
+                type_, emoji_id = "1", request.params["emoji"]
+            await net.call_api(
+                "put",
+                f"channels/{channel_id}/messages/{request.params['message_id']}/reactions/{type_}/{emoji_id}/",
+            )
+        else:
+            raise NotFoundException("qq platform does not support reaction.create")
+
+    @adapter.route(Api.REACTION_DELETE)
+    async def reaction_delete(request: Request[ReactionDeleteParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            channel_id = request.params["channel_id"].split("_")[-1]
+            if ":" in request.params["emoji"]:
+                type_, emoji_id = request.params["emoji"].split(":", maxsplit=1)
+            else:
+                type_, emoji_id = "1", request.params["emoji"]
+            await net.call_api(
+                "delete",
+                f"channels/{channel_id}/messages/{request.params['message_id']}/reactions/{type_}/{emoji_id}/",
+            )
+        else:
+            raise NotFoundException("qq platform does not support reaction.delete")
+
+    @adapter.route(Api.GUILD_ROLE_LIST)
+    async def guild_list_role(request: Request[GuildXXXListParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            res = await net.call_api(
+                "get",
+                f"guilds/{guild_id}/roles",
+            )
+            roles = [Role(role["id"], role.get("name", "")) for role in res]
+            return PageResult(roles, next=None)
+        raise NotFoundException("qq platform does not support guild.role.list")
+
+    @adapter.route(Api.GUILD_ROLE_CREATE)
+    async def guild_create_role(request: Request[GuildRoleCreateParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            data = request.params["role"]
+            res = await net.call_api(
+                "post",
+                f"guilds/{guild_id}/roles",
+                {
+                    "name": data.get("name"),
+                    "color": data.get("color"),
+                    "hoist": data.get("hoist"),
+                },
+            )
+            return Role(res["role"]["id"], res["role"]["name"])
+        raise NotFoundException("qq platform does not support guild.role.create")
+
+    @adapter.route(Api.GUILD_ROLE_DELETE)
+    async def guild_delete_role(request: Request[GuildRoleDeleteParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            await net.call_api(
+                "delete",
+                f"guilds/{guild_id}/roles/{request.params['role_id']}",
+            )
+        else:
+            raise NotFoundException("qq platform does not support guild.role.delete")
+
+    @adapter.route(Api.GUILD_ROLE_UPDATE)
+    async def guild_update_role(request: Request[GuildRoleUpdateParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            data = request.params["role"]
+            await net.call_api(
+                "patch",
+                f"guilds/{guild_id}/roles/{request.params['role_id']}",
+                {
+                    "name": data.get("name"),
+                    "color": data.get("color"),
+                    "hoist": data.get("hoist"),
+                },
+            )
+        else:
+            raise NotFoundException("qq platform does not support guild.role.update")
+
+    @adapter.route(Api.GUILD_MEMBER_ROLE_SET)
+    async def guild_add_member_role(request: Request[GuildMemberRoleParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            await net.call_api(
+                "put",
+                f"guilds/{guild_id}/members/{request.params['user_id']}/roles/{request.params['role_id']}",
+            )
+        else:
+            raise NotFoundException("qq platform does not support guild.member.role.add")
+
+    @adapter.route(Api.GUILD_MEMBER_ROLE_UNSET)
+    async def guild_remove_member_role(request: Request[GuildMemberRoleParam]):
+        net = net_getter(request.self_id, request.platform == "qqguild")
+        if request.platform == "qqguild":
+            guild_id = request.params["guild_id"].split("_")[0]
+            await net.call_api(
+                "delete",
+                f"guilds/{guild_id}/members/{request.params['user_id']}/roles/{request.params['role_id']}",
+            )
+        else:
+            raise NotFoundException("qq platform does not support guild.member.role.remove")

satori/adapters/qq/audit_store.py

@@ -0,0 +1,47 @@
+import asyncio
+from dataclasses import dataclass
+from datetime import datetime
+from weakref import finalize
+
+
+@dataclass
+class Audit:
+    id: str
+    guild_id: str
+    channel_id: str
+    seq: str
+    create_time: datetime
+    audit_time: datetime
+    message_id: str | None = None
+
+
+class AuditResultStore:
+    def __init__(self) -> None:
+        self._futures: dict[str, asyncio.Future] = {}
+        finalize(self, self._futures.clear)
+
+    def add_result(self, result: dict):
+        audit = Audit(
+            result["audit_id"],
+            result["guild_id"],
+            result["channel_id"],
+            result["seq_in_channel"],
+            datetime.fromisoformat(result["create_time"]),
+            datetime.fromisoformat(result["audit_time"]),
+            result.get("message_id"),
+        )
+        if future := self._futures.get(audit.id):
+            future.set_result(audit)
+
+    async def fetch(self, audit: str, timeout: float = 30) -> Audit | None:
+        future = asyncio.get_event_loop().create_future()
+        self._futures[audit] = future
+        try:
+            return await asyncio.wait_for(future, timeout)
+        except asyncio.TimeoutError:
+            return None
+        finally:
+            del self._futures[audit]
+
+
+audit_result = AuditResultStore()

satori/adapters/qq/events/__init__.py

@@ -0,0 +1,5 @@
+from . import group as group  # noqa: F401
+from . import guild as guild  # noqa: F401
+from . import interaction as interaction  # noqa: F401
+from . import message as message  # noqa: F401
+from .base import event_handlers  # noqa: F401

satori/adapters/qq/events/base.py

@@ -0,0 +1,17 @@
+from collections.abc import Awaitable, Callable
+
+from satori.model import Event, Login
+
+from ..utils import Payload, QQBotNetwork
+
+EventHandler = Callable[[Login, Login, QQBotNetwork, Payload], Awaitable[Event | None]]
+
+event_handlers: dict[str, EventHandler] = {}
+
+
+def register_event(event_type: str):
+    def wrapper(func: EventHandler):
+        event_handlers[event_type] = func
+        return func
+
+    return wrapper

satori/adapters/qq/events/group.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from satori import EventType
+from satori.model import Event, Guild, User
+
+from ..utils import Payload
+from .base import register_event
+
+
+@register_event("FRIEND_ADD")
+@register_event("FRIEND_DEL")
+async def friend_event(login, guild_login, net, payload: Payload):
+    raw = payload.data
+    t = {
+        "FRIEND_ADD": EventType.FRIEND_ADDED,
+        "FRIEND_DEL": EventType.FRIEND_REMOVED,
+    }[payload.type or ""]
+    user = User(raw["openid"])
+    return Event(
+        t,
+        (
+            datetime.fromtimestamp(int(raw["timestamp"]))
+            if isinstance(raw["timestamp"], (int, float)) or raw["timestamp"].isdigit()
+            else datetime.fromisoformat(str(raw["timestamp"]))
+        ),
+        login,
+        user=user,
+    )
+
+
+@register_event("GROUP_ADD_ROBOT")
+@register_event("GROUP_DEL_ROBOT")
+async def group_event(login, guild_login, net, payload: Payload):
+    raw = payload.data
+    if "group_openid" in raw:
+        guild = Guild(raw["group_openid"])
+    else:
+        guild = Guild(raw["guild_id"])
+    operator = User(raw["op_member_openid"])
+    t = {
+        "GROUP_ADD_ROBOT": EventType.GUILD_ADDED,
+        "GROUP_DEL_ROBOT": EventType.GUILD_REMOVED,
+    }[payload.type or ""]
+    return Event(
+        t,
+        (
+            datetime.fromtimestamp(int(raw["timestamp"]))
+            if isinstance(raw["timestamp"], (int, float)) or raw["timestamp"].isdigit()
+            else datetime.fromisoformat(str(raw["timestamp"]))
+        ),
+        login,
+        guild=guild,
+        operator=operator,
+    )

satori/adapters/qq/events/guild.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from satori import EventType
+from satori.model import Event, Guild, Member, Role, User
+
+from ..utils import Payload, decode_channel, decode_guild, decode_user
+from .base import register_event
+
+
+@register_event("CHANNEL_CREATE")
+@register_event("CHANNEL_UPDATE")
+@register_event("CHANNEL_DELETE")
+async def channel_event(login, guild_login, net, payload: Payload):
+    raw = payload.data
+    guild = Guild(raw["guild_id"])
+    channel = decode_channel(raw)
+    t = {
+        "CHANNEL_CREATE": EventType.CHANNEL_ADDED,
+        "CHANNEL_UPDATE": EventType.CHANNEL_UPDATED,
+        "CHANNEL_DELETE": EventType.CHANNEL_REMOVED,
+    }[payload.type or ""]
+    operator = User(raw["op_user_id"])
+    return Event(t, datetime.now(), guild_login, channel=channel, guild=guild, operator=operator)
+
+
+@register_event("GUILD_CREATE")
+@register_event("GUILD_UPDATE")
+@register_event("GUILD_DELETE")
+async def guild_event(login, guild_login, net, payload: Payload):
+    raw = payload.data
+    guild = decode_guild(raw)
+    t = {
+        "GUILD_CREATE": EventType.GUILD_ADDED,
+        "GUILD_UPDATE": EventType.GUILD_UPDATED,
+        "GUILD_DELETE": EventType.GUILD_REMOVED,
+    }[payload.type or ""]
+    operator = User(raw["op_user_id"])
+    return Event(t, datetime.now(), guild_login, guild=guild, operator=operator)
+
+
+@register_event("GUILD_MEMBER_ADD")
+@register_event("GUILD_MEMBER_UPDATE")
+@register_event("GUILD_MEMBER_DELETE")
+async def guild_member_event(login, guild_login, net, payload: Payload):
+    raw = payload.data
+    guild = Guild(raw["guild_id"])
+    t = {
+        "GUILD_MEMBER_ADD": EventType.GUILD_MEMBER_ADDED,
+        "GUILD_MEMBER_UPDATE": EventType.GUILD_MEMBER_UPDATED,
+        "GUILD_MEMBER_DELETE": EventType.GUILD_MEMBER_REMOVED,
+    }[payload.type or ""]
+    user = decode_user(raw["user"])
+    member = Member(
+        user,
+        nick=raw["nick"],
+        avatar=user.avatar,
+        joined_at=datetime.fromisoformat(raw["joined_at"]),
+    )
+    role = Role(raw["roles"][0])
+    operator = User(raw["op_user_id"])
+    return Event(t, datetime.now(), guild_login, guild=guild, user=user, member=member, operator=operator, role=role)