satori-python 0.10.0__tar.gz → 0.11.0__tar.gz

{satori_python-0.10.0 → satori_python-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satori-python
-Version: 0.10.0
+Version: 0.11.0
 Summary: Satori Protocol SDK for python
 Home-page: https://github.com/RF-Tar-Railt/satori-python
 Author-Email: RF-Tar-Railt <rf_tar_railt@qq.com>

{satori_python-0.10.0 → satori_python-0.11.0}/pyproject.toml

@@ -28,7 +28,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Operating System :: OS Independent",
 ]
-version = "0.10.0"
+version = "0.11.0"
 
 [project.license]
 text = "MIT"
@@ -63,7 +63,7 @@ includes = [
 composite = [
     "isort ./src/ ./example/",
     "black ./src/ ./example/",
-    "ruff ./src/ ./example/",
+    "ruff check ./src/ ./example/",
 ]
 
 [tool.pdm.version]
@@ -84,6 +84,13 @@ extra_standard_library = [
 ]
 
 [tool.ruff]
+line-length = 110
+target-version = "py38"
+exclude = [
+    "exam.py",
+]
+
+[tool.ruff.lint]
 select = [
     "E",
     "W",
@@ -100,8 +107,6 @@ ignore = [
     "C901",
     "UP037",
 ]
-line-length = 110
-target-version = "py38"
 
 [tool.pyright]
 pythonPlatform = "All"

{satori_python-0.10.0 → satori_python-0.11.0}/src/satori/__init__.py

@@ -39,4 +39,4 @@ from .model import MessageObject as MessageObject
 from .model import Role as Role
 from .model import User as User
 
-__version__ = "0.10.0"
+__version__ = "0.11.0"

satori_python-0.11.0/src/satori/client/__init__.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import asyncio
+import signal
+from functools import wraps
+from typing import Any, Awaitable, Callable, Iterable, Literal, TypeVar, overload
+
+from creart import it
+from launart import Launart, Service, any_completed
+from loguru import logger
+
+from satori import event
+from satori.config import Config, WebhookInfo, WebsocketsInfo
+from satori.const import EventType
+from satori.model import Event, LoginStatus
+
+from .account import Account as Account
+from .account import ApiInfo as ApiInfo
+from .network.base import BaseNetwork as BaseNetwork
+from .network.webhook import WebhookNetwork
+from .network.websocket import WsNetwork
+
+TConfig = TypeVar("TConfig", bound=Config)
+TE = TypeVar("TE", bound=Event, contravariant=True)
+
+MAPPING: dict[type[Config], type[BaseNetwork]] = {
+    WebhookInfo: WebhookNetwork,
+    WebsocketsInfo: WsNetwork,
+}
+
+
+class App(Service):
+    id = "satori-python.client"
+    required: set[str] = set()
+    stages: set[str] = {"preparing", "blocking", "cleanup"}
+
+    accounts: dict[str, Account]
+    connections: list[BaseNetwork]
+    event_callbacks: list[Callable[[Account, Event], Awaitable[Any]]]
+    lifecycle_callbacks: list[Callable[[Account, LoginStatus], Awaitable[Any]]]
+
+    @classmethod
+    def register_config(cls, tc: type[TConfig], tn: type[BaseNetwork[TConfig]]):
+        MAPPING[tc] = tn
+
+    def __init__(self, *configs: Config):
+        self.accounts = {}
+        self.connections = []
+        self.event_callbacks = []
+        self.lifecycle_callbacks = []
+        super().__init__()
+        for config in configs:
+            self.apply(config)
+
+    def apply(self, config: Config):
+        try:
+            connection = MAPPING[config.__class__](self, config)
+        except KeyError:
+            raise TypeError(f"Unknown config type: {config}")
+        self.connections.append(connection)
+
+    def get_account(self, self_id: str) -> Account:
+        return self.accounts[self_id]
+
+    def register(self, callback: Callable[[Account, Event], Awaitable[Any]]):
+        self.event_callbacks.append(callback)
+
+    @overload
+    def register_on(self, event_type: Literal[EventType.FRIEND_REQUEST]) -> Callable[
+        [Callable[[Account, event.UserEvent], Awaitable[Any]]],
+        Callable[[Account, event.UserEvent], Awaitable[Any]],
+    ]: ...
+
+    @overload
+    def register_on(
+        self,
+        event_type: Literal[
+            EventType.GUILD_ADDED, EventType.GUILD_REMOVED, EventType.GUILD_REQUEST, EventType.GUILD_UPDATED
+        ],
+    ) -> Callable[
+        [Callable[[Account, event.GuildEvent], Awaitable[Any]]],
+        Callable[[Account, event.GuildEvent], Awaitable[Any]],
+    ]: ...
+
+    @overload
+    def register_on(
+        self,
+        event_type: Literal[
+            EventType.GUILD_MEMBER_ADDED,
+            EventType.GUILD_MEMBER_REMOVED,
+            EventType.GUILD_MEMBER_UPDATED,
+            EventType.GUILD_MEMBER_REQUEST,
+        ],
+    ) -> Callable[
+        [Callable[[Account, event.GuildMemberEvent], Awaitable[Any]]],
+        Callable[[Account, event.GuildMemberEvent], Awaitable[Any]],
+    ]: ...
+
+    @overload
+    def register_on(
+        self,
+        event_type: Literal[
+            EventType.GUILD_ROLE_CREATED, EventType.GUILD_ROLE_DELETED, EventType.GUILD_ROLE_UPDATED
+        ],
+    ) -> Callable[
+        [Callable[[Account, event.GuildRoleEvent], Awaitable[Any]]],
+        Callable[[Account, event.GuildRoleEvent], Awaitable[Any]],
+    ]: ...
+
+    @overload
+    def register_on(
+        self, event_type: Literal[EventType.LOGIN_ADDED, EventType.LOGIN_REMOVED, EventType.LOGIN_UPDATED]
+    ) -> Callable[
+        [Callable[[Account, event.LoginEvent], Awaitable[Any]]],
+        Callable[[Account, event.LoginEvent], Awaitable[Any]],
+    ]: ...
+
+    @overload
+    def register_on(
+        self,
+        event_type: Literal[EventType.MESSAGE_CREATED, EventType.MESSAGE_DELETED, EventType.MESSAGE_UPDATED],
+    ) -> Callable[
+        [Callable[[Account, event.MessageEvent], Awaitable[Any]]],
+        Callable[[Account, event.MessageEvent], Awaitable[Any]],
+    ]: ...
+
+    @overload
+    def register_on(
+        self, event_type: Literal[EventType.REACTION_ADDED, EventType.REACTION_REMOVED]
+    ) -> Callable[
+        [Callable[[Account, event.ReactionEvent], Awaitable[Any]]],
+        Callable[[Account, event.ReactionEvent], Awaitable[Any]],
+    ]: ...
+
+    @overload
+    def register_on(self, event_type: Literal[EventType.INTERACTION_BUTTON]) -> Callable[
+        [Callable[[Account, event.ButtonInteractionEvent], Awaitable[Any]]],
+        Callable[[Account, event.ButtonInteractionEvent], Awaitable[Any]],
+    ]: ...
+
+    @overload
+    def register_on(self, event_type: Literal[EventType.INTERACTION_COMMAND]) -> Callable[
+        [Callable[[Account, event.ArgvInteractionEvent | event.MessageEvent], Awaitable[Any]]],
+        Callable[[Account, event.ArgvInteractionEvent | event.MessageEvent], Awaitable[Any]],
+    ]: ...
+
+    @overload
+    def register_on(self, event_type: Literal[EventType.INTERNAL]) -> Callable[
+        [Callable[[Account, event.InternalEvent], Awaitable[Any]]],
+        Callable[[Account, event.InternalEvent], Awaitable[Any]],
+    ]: ...
+
+    def register_on(self, event_type: EventType):
+        def decorator(
+            func: Callable[[Account, Any], Awaitable[Any]], /
+        ) -> Callable[[Account, Any], Awaitable[Any]]:
+            @wraps(func)
+            async def wrapper(account: Account, event: Event) -> Any:
+                if event.type == event_type.value:
+                    return await func(account, event)
+
+            self.register(wrapper)
+            return wrapper
+
+        return decorator
+
+    def lifecycle(self, callback: Callable[[Account, LoginStatus], Awaitable[Any]]):
+        self.lifecycle_callbacks.append(callback)
+
+    async def account_update(self, account: Account, state: LoginStatus):
+        if self.lifecycle_callbacks:
+            await asyncio.gather(*(callback(account, state) for callback in self.lifecycle_callbacks))
+
+    async def post(self, event: Event):
+        if not self.event_callbacks:
+            return
+        identity = f"{event.platform}/{event.self_id}"
+        if identity not in self.accounts:
+            logger.warning(f"Received event for unknown account: {event}")
+            return
+        account = self.accounts[identity]
+        await asyncio.gather(*(callback(account, event) for callback in self.event_callbacks))
+
+    async def launch(self, manager: Launart):
+        for conn in self.connections:
+            manager.add_component(conn)
+
+        async with self.stage("preparing"):
+            ...
+
+        async with self.stage("blocking"):
+            await any_completed(
+                manager.status.wait_for_sigexit(),
+                *(conn.status.wait_for("blocking-completed") for conn in self.connections),
+            )
+
+        async with self.stage("cleanup"):
+            for account in self.accounts.values():
+                await self.account_update(account, LoginStatus.OFFLINE)
+            self.accounts.clear()
+
+    def run(
+        self,
+        manager: Launart | None = None,
+        *,
+        loop: asyncio.AbstractEventLoop | None = None,
+        stop_signal: Iterable[signal.Signals] = (signal.SIGINT,),
+    ):
+        if manager is None:
+            manager = it(Launart)
+        manager.add_component(self)
+        manager.launch_blocking(loop=loop, stop_signal=stop_signal)
+
+    async def run_async(self, manager: Launart | None = None):
+        if manager is None:
+            manager = it(Launart)
+        manager.add_component(self)
+        await manager.launch()

{satori_python-0.10.0 → satori_python-0.11.0}/src/satori/client/account.pyi

@@ -55,6 +55,7 @@ class Account:
             message: 要发送的消息
         """
         ...
+
     async def send_private_message(
         self,
         user_id: str,
@@ -67,6 +68,7 @@ class Account:
             message: 要发送的消息
         """
         ...
+
     async def update_message(
         self,
         channel_id: str,
@@ -81,6 +83,7 @@ class Account:
             message: 要更新的消息
         """
         ...
+
     async def message_create(
         self,
         *,

{satori_python-0.10.0 → satori_python-0.11.0}/src/satori/client/network/base.py

@@ -27,12 +27,10 @@ class BaseNetwork(Generic[TConfig], Service):
         self.close_signal = asyncio.Event()
         self.sequence = -1
 
-    async def wait_for_available(self):
-        ...
+    async def wait_for_available(self): ...
 
     @property
-    def alive(self) -> bool:
-        ...
+    def alive(self) -> bool: ...
 
     async def connection_closed(self):
         self.close_signal.set()

{satori_python-0.10.0 → satori_python-0.11.0}/src/satori/client/network/websocket.py

@@ -101,9 +101,11 @@ class WsNetwork(BaseNetwork[WebsocketsInfo]):
             else:
                 account = Account(platform, self_id, self.config)
                 logger.info(f"account registered: {account}")
-                account.connected.set() if login[
-                    "status"
-                ] == LoginStatus.ONLINE else account.connected.clear()
+                (
+                    account.connected.set()
+                    if login["status"] == LoginStatus.ONLINE
+                    else account.connected.clear()
+                )
                 self.app.accounts[identity] = account
                 self.accounts[identity] = account
                 await self.app.account_update(account, LoginStatus.ONLINE)

{satori_python-0.10.0 → satori_python-0.11.0}/src/satori/const.py

@@ -13,6 +13,7 @@ class Api(str, Enum):
     CHANNEL_CREATE = "channel.create"
     CHANNEL_UPDATE = "channel.update"
     CHANNEL_DELETE = "channel.delete"
+    CHANNEL_MUTE = "channel.mute"
     USER_CHANNEL_CREATE = "user.channel.create"
 
     GUILD_GET = "guild.get"
@@ -22,6 +23,7 @@ class Api(str, Enum):
     GUILD_MEMBER_LIST = "guild.member.list"
     GUILD_MEMBER_GET = "guild.member.get"
     GUILD_MEMBER_KICK = "guild.member.kick"
+    GUILD_MEMBER_MUTE = "guild.member.mute"
     GUILD_MEMBER_APPROVE = "guild.member.approve"
     GUILD_MEMBER_ROLE_SET = "guild.member.role.set"
     GUILD_MEMBER_ROLE_UNSET = "guild.member.role.unset"

{satori_python-0.10.0 → satori_python-0.11.0}/src/satori/element.py

@@ -24,6 +24,13 @@ class Element:
         for f in fields(self):
             if f.name in ("_attrs", "_children"):
                 continue
+            if f.type is not str and isinstance(attr := getattr(self, f.name), str):
+                if f.type is bool:
+                    if attr.lower() not in ("true", "false"):
+                        raise TypeError(f.name, attr)
+                    setattr(self, f.name, attr.lower() == "true")
+                else:
+                    setattr(self, f.name, f.type(attr))
             self._attrs[f.name] = getattr(self, f.name)
         self._attrs = {k: v for k, v in self._attrs.items() if v is not None}
 
@@ -59,8 +66,7 @@ class Element:
         self.__post_call__()
         return self
 
-    def __post_call__(self):
-        ...
+    def __post_call__(self): ...
 
 
 @dataclass

satori_python-0.11.0/src/satori/event.py

@@ -0,0 +1,63 @@
+from satori.model import (
+    ArgvInteraction,
+    ButtonInteraction,
+    Channel,
+    Event,
+    Guild,
+    Login,
+    Member,
+    MessageObject,
+    Role,
+    User,
+)
+
+
+class MessageEvent(Event):
+    channel: Channel
+    member: Member
+    message: MessageObject
+    user: User
+
+
+class UserEvent(Event):
+    user: User
+
+
+class GuildEvent(Event):
+    guild: Guild
+
+
+class GuildMemberEvent(GuildEvent):
+    user: User
+    member: Member
+
+
+class GuildRoleEvent(GuildEvent):
+    role: Role
+
+
+class LoginEvent(Event):
+    login: Login
+
+
+class ReactionEvent(Event):
+    channel: Channel
+    user: User
+    message: MessageObject
+
+
+class ButtonInteractionEvent(Event):
+    button: ButtonInteraction
+    user: User
+    channel: Channel
+
+
+class ArgvInteractionEvent(Event):
+    argv: ArgvInteraction
+    user: User
+    channel: Channel
+
+
+class InternalEvent(Event):
+    _type: str
+    _data: dict

{satori_python-0.10.0 → satori_python-0.11.0}/src/satori/model.py

@@ -7,6 +7,15 @@ from .element import Element, transform
 from .parser import parse
 
 
+class ModelBase:
+    @classmethod
+    def parse(cls, raw: dict):
+        raise NotImplementedError
+
+    def dump(self) -> dict:
+        raise NotImplementedError
+
+
 class ChannelType(IntEnum):
     TEXT = 0
     DIRECT = 1
@@ -15,7 +24,7 @@ class ChannelType(IntEnum):
 
 
 @dataclass
-class Channel:
+class Channel(ModelBase):
     id: str
     type: ChannelType
     name: Optional[str] = None
@@ -37,7 +46,7 @@ class Channel:
 
 
 @dataclass
-class Guild:
+class Guild(ModelBase):
     id: str
     name: Optional[str] = None
     avatar: Optional[str] = None
@@ -56,7 +65,7 @@ class Guild:
 
 
 @dataclass
-class User:
+class User(ModelBase):
     id: str
     name: Optional[str] = None
     nick: Optional[str] = None
@@ -81,7 +90,7 @@ class User:
 
 
 @dataclass
-class Member:
+class Member(ModelBase):
     user: Optional[User] = None
     nick: Optional[str] = None
     name: Optional[str] = None
@@ -111,7 +120,7 @@ class Member:
 
 
 @dataclass
-class Role:
+class Role(ModelBase):
     id: str
     name: Optional[str] = None
 
@@ -135,7 +144,7 @@ class LoginStatus(IntEnum):
 
 
 @dataclass
-class Login:
+class Login(ModelBase):
     status: LoginStatus
     user: Optional[User] = None
     self_id: Optional[str] = None
@@ -161,19 +170,27 @@ class Login:
 
 
 @dataclass
-class ArgvInteraction:
+class ArgvInteraction(ModelBase):
     name: str
     arguments: list
     options: Any
 
+    @classmethod
+    def parse(cls, raw: dict):
+        return cls(**raw)
+
     def dump(self):
         return asdict(self)
 
 
 @dataclass
-class ButtonInteraction:
+class ButtonInteraction(ModelBase):
     id: str
 
+    @classmethod
+    def parse(cls, raw: dict):
+        return cls(**raw)
+
     def dump(self):
         return asdict(self)
 
@@ -187,18 +204,18 @@ class Opcode(IntEnum):
 
 
 @dataclass
-class Identify:
+class Identify(ModelBase):
     token: Optional[str] = None
     sequence: Optional[int] = None
 
 
 @dataclass
-class Ready:
+class Ready(ModelBase):
     logins: List[Login]
 
 
 @dataclass
-class MessageObject:
+class MessageObject(ModelBase):
     id: str
     content: str
     channel: Optional[Channel] = None
@@ -208,6 +225,20 @@ class MessageObject:
     created_at: Optional[datetime] = None
     updated_at: Optional[datetime] = None
 
+    @classmethod
+    def from_elements(
+        cls,
+        id: str,
+        content: List[Element],
+        channel: Optional[Channel] = None,
+        guild: Optional[Guild] = None,
+        member: Optional[Member] = None,
+        user: Optional[User] = None,
+        created_at: Optional[datetime] = None,
+        updated_at: Optional[datetime] = None,
+    ):
+        return cls(id, "".join(str(i) for i in content), channel, guild, member, user, created_at, updated_at)
+
     @property
     def message(self) -> List[Element]:
         return transform(parse(self.content))
@@ -267,6 +298,9 @@ class Event:
     role: Optional[Role] = None
     user: Optional[User] = None
 
+    _type: Optional[str] = None
+    _data: Optional[dict] = None
+
     @classmethod
     def parse(cls, raw: dict):
         data = {
@@ -277,9 +311,9 @@ class Event:
             "timestamp": datetime.fromtimestamp(int(raw["timestamp"]) / 1000),
         }
         if "argv" in raw:
-            data["argv"] = ArgvInteraction(**raw["argv"])
+            data["argv"] = ArgvInteraction.parse(raw["argv"])
         if "button" in raw:
-            data["button"] = ButtonInteraction(**raw["button"])
+            data["button"] = ButtonInteraction.parse(raw["button"])
         if "channel" in raw:
             data["channel"] = Channel.parse(raw["channel"])
         if "guild" in raw:
@@ -296,6 +330,10 @@ class Event:
             data["role"] = Role.parse(raw["role"])
         if "user" in raw:
             data["user"] = User.parse(raw["user"])
+        if "_type" in raw:
+            data["_type"] = raw["_type"]
+        if "_data" in raw:
+            data["_data"] = raw["_data"]
         return cls(**data)
 
     def dump(self):
@@ -326,14 +364,18 @@ class Event:
             res["role"] = self.role.dump()
         if self.user:
             res["user"] = self.user.dump()
+        if self._type:
+            res["_type"] = self._type
+        if self._data:
+            res["_data"] = self._data
         return res
 
 
-T = TypeVar("T")
+T = TypeVar("T", bound=ModelBase)
 
 
 @dataclass
-class PageResult(Generic[T]):
+class PageResult(ModelBase, Generic[T]):
     data: List[T]
     next: Optional[str] = None
 
@@ -341,3 +383,9 @@ class PageResult(Generic[T]):
     def parse(cls, raw: dict, parser: Callable[[dict], T]) -> "PageResult[T]":
         data = [parser(item) for item in raw["data"]]
         return cls(data, raw.get("next"))
+
+    def dump(self):
+        res: dict = {"data": [item.dump() for item in self.data]}
+        if self.next:
+            res["next"] = self.next
+        return res