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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satori-python
-Version: 0.9.2
+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>
@@ -17,14 +17,14 @@ 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: >=3.9
-Requires-Dist: aiohttp>=3.8.6
+Requires-Dist: aiohttp>=3.9.3
 Requires-Dist: loguru>=0.7.2
 Requires-Dist: launart>=0.8.2
-Requires-Dist: typing-extensions>=4.8.0
-Requires-Dist: graia-amnesia>=0.8.2
-Requires-Dist: starlette>=0.32.0.post1
-Requires-Dist: uvicorn[standard]>=0.24.0.post1
-Requires-Dist: yarl>=1.9.3
+Requires-Dist: typing-extensions>=4.10.0
+Requires-Dist: graia-amnesia>=0.9.0
+Requires-Dist: starlette>=0.37.2
+Requires-Dist: uvicorn[standard]>=0.28.0
+Requires-Dist: yarl>=1.9.4
 Description-Content-Type: text/markdown
 
 # satori-python

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

@@ -6,14 +6,14 @@ authors = [
 ]
 dynamic = []
 dependencies = [
-    "aiohttp>=3.8.6",
+    "aiohttp>=3.9.3",
     "loguru>=0.7.2",
     "launart>=0.8.2",
-    "typing-extensions>=4.8.0",
-    "graia-amnesia>=0.8.2",
-    "starlette>=0.32.0.post1",
-    "uvicorn[standard]>=0.24.0.post1",
-    "yarl>=1.9.3",
+    "typing-extensions>=4.10.0",
+    "graia-amnesia>=0.9.0",
+    "starlette>=0.37.2",
+    "uvicorn[standard]>=0.28.0",
+    "yarl>=1.9.4",
 ]
 requires-python = ">=3.9"
 readme = "README.md"
@@ -28,7 +28,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Operating System :: OS Independent",
 ]
-version = "0.9.2"
+version = "0.11.0"
 
 [project.license]
 text = "MIT"
@@ -39,19 +39,19 @@ repository = "https://github.com/RF-Tar-Railt/satori-python"
 
 [build-system]
 requires = [
-    "mina-build>=0.5.1",
+    "mina-build<0.6,>=0.5.1",
 ]
 build-backend = "mina.backend"
 
 [tool.pdm.dev-dependencies]
 dev = [
-    "isort>=5.12.0",
-    "black>=23.11.0",
-    "ruff>=0.1.5",
-    "pre-commit>=3.5.0",
+    "isort>=5.13.2",
+    "black>=24.2.0",
+    "ruff>=0.3.2",
+    "pre-commit>=3.6.2",
     "fix-future-annotations>=0.5.0",
-    "mina-build>=0.5.2",
-    "pdm-mina>=0.3.1",
+    "mina-build<0.6,>=0.5.1",
+    "pdm-mina>=0.3.2",
 ]
 
 [tool.pdm.build]
@@ -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,9 +107,10 @@ ignore = [
     "C901",
     "UP037",
 ]
-line-length = 110
-target-version = "py38"
 
 [tool.pyright]
 pythonPlatform = "All"
 pythonVersion = "3.8"
+typeCheckingMode = "basic"
+reportShadowedImports = false
+disableBytesTypePromotions = true

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

@@ -15,6 +15,7 @@ from .element import Image as Image
 from .element import Italic as Italic
 from .element import Link as Link
 from .element import Message as Message
+from .element import Paragraph as Paragraph
 from .element import Quote as Quote
 from .element import Sharp as Sharp
 from .element import Spoiler as Spoiler
@@ -38,4 +39,4 @@ from .model import MessageObject as MessageObject
 from .model import Role as Role
 from .model import User as User
 
-__version__ = "0.9.2"
+__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.9.2 → satori_python-0.11.0}/src/satori/client/account.py

@@ -2,11 +2,14 @@ from __future__ import annotations
 
 import asyncio
 from dataclasses import dataclass
+from typing import TypeVar
 
 from yarl import URL
 
 from .session import Session
 
+TS = TypeVar("TS", bound="Session")
+
 
 @dataclass
 class ApiInfo:
@@ -25,15 +28,15 @@ class ApiInfo:
 
 
 class Account:
-    def __init__(self, platform: str, self_id: str, config: ApiInfo):
+    def __init__(self, platform: str, self_id: str, config: ApiInfo, session_cls: type[Session] = Session):
         self.platform = platform
         self.self_id = self_id
         self.config = config
-        self.session = Session(self)  # type: ignore
+        self.session = session_cls(self)  # type: ignore
         self.connected = asyncio.Event()
 
-    def custom(self, config: ApiInfo | None = None, **kwargs):
-        return Account(self.platform, self.self_id, config or ApiInfo(**kwargs)).session
+    def custom(self, config: ApiInfo | None = None, session_cls: type[TS] = Session, **kwargs) -> TS:
+        return Account(self.platform, self.self_id, config or ApiInfo(**kwargs), session_cls).session  # type: ignore
 
     @property
     def identity(self):

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

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, Iterable, Protocol, overload
+from typing import Any, Iterable, Protocol, TypeVar, overload
 
 from yarl import URL
 
@@ -8,6 +8,8 @@ from satori.model import Channel, Event, Guild, Login, Member, MessageObject, Pa
 
 from .session import Session
 
+TS = TypeVar("TS", bound="Session")
+
 class Api(Protocol):
     token: str | None = None
 
@@ -26,13 +28,15 @@ class Account:
     session: Session
     connected: asyncio.Event
 
-    def __init__(self, platform: str, self_id: str, config: Api): ...
+    def __init__(self, platform: str, self_id: str, config: Api, session_cls: type[Session] = Session): ...
     @property
     def identity(self) -> str: ...
     @overload
-    def custom(self, config: Api) -> Session: ...
+    def custom(self, config: Api, session_cls: type[TS] = Session) -> TS: ...
     @overload
-    def custom(self, *, host: str, port: int, token: str | None = None) -> Session: ...
+    def custom(
+        self, *, session_cls: type[TS] = Session, host: str, port: int, token: str | None = None
+    ) -> TS: ...
     async def send(
         self,
         event: Event,
@@ -51,6 +55,7 @@ class Account:
             message: 要发送的消息
         """
         ...
+
     async def send_private_message(
         self,
         user_id: str,
@@ -63,6 +68,7 @@ class Account:
             message: 要发送的消息
         """
         ...
+
     async def update_message(
         self,
         channel_id: str,
@@ -77,6 +83,7 @@ class Account:
             message: 要更新的消息
         """
         ...
+
     async def message_create(
         self,
         *,

{satori_python-0.9.2 → 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.9.2 → 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.9.2 → 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"