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

{satori_python_server-0.9.2 → satori_python_server-0.11.0}/.mina/server.toml

@@ -1,5 +1,5 @@
 includes = ["src/satori/server"]
-raw-dependencies = ["satori-python-core >= 0.9.2"]
+raw-dependencies = ["satori-python-core >= 0.11.0"]
 
 [project]
 name = "satori-python-server"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satori-python-server
-Version: 0.9.2
+Version: 0.11.0
 Summary: Satori Protocol SDK for python, specify server part
 Home-page: https://github.com/RF-Tar-Railt/satori-python
 Author-Email: RF-Tar-Railt <rf_tar_railt@qq.com>
@@ -18,10 +18,10 @@ 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.8
 Requires-Dist: launart>=0.8.2
-Requires-Dist: graia-amnesia>=0.8.2
-Requires-Dist: starlette>=0.32.0.post1
-Requires-Dist: uvicorn[standard]>=0.24.0.post1
-Requires-Dist: satori-python-core>=0.9.2
+Requires-Dist: graia-amnesia>=0.9.0
+Requires-Dist: starlette>=0.37.2
+Requires-Dist: uvicorn[standard]>=0.28.0
+Requires-Dist: satori-python-core>=0.11.0
 Description-Content-Type: text/markdown
 
 # satori-python

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

@@ -6,10 +6,10 @@ authors = [
 ]
 dependencies = [
     "launart>=0.8.2",
-    "graia-amnesia>=0.8.2",
-    "starlette>=0.32.0.post1",
-    "uvicorn[standard]>=0.24.0.post1",
-    "satori-python-core >= 0.9.2",
+    "graia-amnesia>=0.9.0",
+    "starlette>=0.37.2",
+    "uvicorn[standard]>=0.28.0",
+    "satori-python-core >= 0.11.0",
 ]
 description = "Satori Protocol SDK for python, specify server part"
 readme = "README.md"
@@ -25,7 +25,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Operating System :: OS Independent",
 ]
-version = "0.9.2"
+version = "0.11.0"
 
 [project.license]
 text = "MIT"
@@ -36,19 +36,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]
@@ -61,7 +61,7 @@ includes = [
 composite = [
     "isort ./src/ ./example/",
     "black ./src/ ./example/",
-    "ruff ./src/ ./example/",
+    "ruff check ./src/ ./example/",
 ]
 
 [tool.pdm.version]
@@ -82,6 +82,13 @@ extra_standard_library = [
 ]
 
 [tool.ruff]
+line-length = 110
+target-version = "py38"
+exclude = [
+    "exam.py",
+]
+
+[tool.ruff.lint]
 select = [
     "E",
     "W",
@@ -98,9 +105,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_server-0.9.2 → satori_python_server-0.11.0}/src/satori/server/__init__.py

@@ -4,7 +4,7 @@ import asyncio
 import signal
 from contextlib import suppress
 from traceback import print_exc
-from typing import Any, Awaitable, Callable, Iterable, cast
+from typing import Callable, Iterable, Literal, cast, overload
 
 import aiohttp
 from creart import it
@@ -20,8 +20,9 @@ from yarl import URL
 
 from satori.config import WebhookInfo
 from satori.const import Api
-from satori.model import Event, Opcode
+from satori.model import Event, ModelBase, Opcode
 
+from . import route
 from .adapter import Adapter as Adapter
 from .conection import WebsocketConnection
 from .model import Provider
@@ -75,14 +76,167 @@ class Server(Service):
         else:
             raise TypeError(f"Unknown config type: {item}")
 
-    def route(self, path: str | Api):
+    @overload
+    def route(
+        self, path: Literal[Api.MESSAGE_CREATE]
+    ) -> Callable[[route.MESSAGE_CREATE], route.MESSAGE_CREATE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.MESSAGE_UPDATE]
+    ) -> Callable[[route.MESSAGE_UPDATE], route.MESSAGE_UPDATE]: ...
+
+    @overload
+    def route(self, path: Literal[Api.MESSAGE_GET]) -> Callable[[route.MESSAGE_GET], route.MESSAGE_GET]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.MESSAGE_DELETE]
+    ) -> Callable[[route.MESSAGE_DELETE], route.MESSAGE_DELETE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.MESSAGE_LIST]
+    ) -> Callable[[route.MESSAGE_LIST], route.MESSAGE_LIST]: ...
+
+    @overload
+    def route(self, path: Literal[Api.CHANNEL_GET]) -> Callable[[route.CHANNEL_GET], route.CHANNEL_GET]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.CHANNEL_LIST]
+    ) -> Callable[[route.CHANNEL_LIST], route.CHANNEL_LIST]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.CHANNEL_CREATE]
+    ) -> Callable[[route.CHANNEL_CREATE], route.CHANNEL_CREATE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.CHANNEL_UPDATE]
+    ) -> Callable[[route.CHANNEL_UPDATE], route.CHANNEL_UPDATE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.CHANNEL_DELETE]
+    ) -> Callable[[route.CHANNEL_DELETE], route.CHANNEL_DELETE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.CHANNEL_MUTE]
+    ) -> Callable[[route.CHANNEL_MUTE], route.CHANNEL_MUTE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.USER_CHANNEL_CREATE]
+    ) -> Callable[[route.ROUTE_USER_CHANNEL_CREATE], route.ROUTE_USER_CHANNEL_CREATE]: ...
+
+    @overload
+    def route(self, path: Literal[Api.GUILD_GET]) -> Callable[[route.GUILD_GET], route.GUILD_GET]: ...
+
+    @overload
+    def route(self, path: Literal[Api.GUILD_LIST]) -> Callable[[route.GUILD_LIST], route.GUILD_LIST]: ...
+
+    @overload
+    def route(self, path: Literal[Api.GUILD_APPROVE]) -> Callable[[route.APPROVE], route.APPROVE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.GUILD_MEMBER_LIST]
+    ) -> Callable[[route.GUILD_MEMBER_LIST], route.GUILD_MEMBER_LIST]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.GUILD_MEMBER_GET]
+    ) -> Callable[[route.GUILD_MEMBER_GET], route.GUILD_MEMBER_GET]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.GUILD_MEMBER_KICK]
+    ) -> Callable[[route.GUILD_MEMBER_KICK], route.GUILD_MEMBER_KICK]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.GUILD_MEMBER_MUTE]
+    ) -> Callable[[route.GUILD_MEMBER_MUTE], route.GUILD_MEMBER_MUTE]: ...
+
+    @overload
+    def route(self, path: Literal[Api.GUILD_MEMBER_APPROVE]) -> Callable[[route.APPROVE], route.APPROVE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.GUILD_MEMBER_ROLE_SET]
+    ) -> Callable[[route.GUILD_MEMBER_ROLE_SET], route.GUILD_MEMBER_ROLE_SET]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.GUILD_MEMBER_ROLE_UNSET]
+    ) -> Callable[[route.GUILD_MEMBER_ROLE_UNSET], route.GUILD_MEMBER_ROLE_UNSET]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.GUILD_ROLE_LIST]
+    ) -> Callable[[route.GUILD_ROLE_LIST], route.GUILD_ROLE_LIST]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.GUILD_ROLE_CREATE]
+    ) -> Callable[[route.GUILD_ROLE_CREATE], route.GUILD_ROLE_CREATE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.GUILD_ROLE_UPDATE]
+    ) -> Callable[[route.GUILD_ROLE_UPDATE], route.GUILD_ROLE_UPDATE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.GUILD_ROLE_DELETE]
+    ) -> Callable[[route.GUILD_ROLE_DELETE], route.GUILD_ROLE_DELETE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.REACTION_CREATE]
+    ) -> Callable[[route.REACTION_CREATE], route.REACTION_CREATE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.REACTION_DELETE]
+    ) -> Callable[[route.REACTION_DELETE], route.REACTION_DELETE]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.REACTION_CLEAR]
+    ) -> Callable[[route.REACTION_CLEAR], route.REACTION_CLEAR]: ...
+
+    @overload
+    def route(
+        self, path: Literal[Api.REACTION_LIST]
+    ) -> Callable[[route.REACTION_LIST], route.REACTION_LIST]: ...
+
+    @overload
+    def route(self, path: Literal[Api.LOGIN_GET]) -> Callable[[route.LOGIN_GET], route.LOGIN_GET]: ...
+
+    @overload
+    def route(self, path: Literal[Api.USER_GET]) -> Callable[[route.USER_GET], route.USER_GET]: ...
+
+    @overload
+    def route(self, path: Literal[Api.FRIEND_LIST]) -> Callable[[route.FRIEND_LIST], route.FRIEND_LIST]: ...
+
+    @overload
+    def route(self, path: Literal[Api.FRIEND_APPROVE]) -> Callable[[route.APPROVE], route.APPROVE]: ...
+
+    @overload
+    def route(self, path: str) -> Callable[[route.INTERAL], route.INTERAL]: ...
+
+    def route(self, path: str | Api) -> Callable[[route.Router], route.Router]:
         """注册一个路由
 
         Args:
             path (str | Api): 路由路径；若 path 不属于 Api，则会被认为是内部接口
         """
 
-        def wrapper(func: Callable[[Request], Awaitable[Any]]):
+        def wrapper(func: route.INTERAL):
             async def handler(request: StarletteRequest):
                 res = await func(
                     Request(
@@ -91,6 +245,10 @@ class Server(Service):
                         await request.json(),
                     )
                 )
+                if isinstance(res, ModelBase):
+                    return JSONResponse(content=res.dump())
+                if res and isinstance(res, list) and isinstance(res[0], ModelBase):
+                    return JSONResponse(content=[_.dump() for _ in res])  # type: ignore
                 return res if isinstance(res, Response) else JSONResponse(content=res)
 
             if isinstance(path, Api):
@@ -171,6 +329,10 @@ class Server(Service):
                             await request.json(),
                         )
                     )
+                if isinstance(res, ModelBase):
+                    return JSONResponse(content=res.dump())
+                if res and isinstance(res, list) and isinstance(res[0], ModelBase):
+                    return JSONResponse(content=[_.dump() for _ in res])
                 return res if isinstance(res, Response) else JSONResponse(content=res)
         return Response(status_code=401)
 
@@ -211,10 +373,18 @@ class Server(Service):
 
     def run(
         self,
+        manager: Launart | None = None,
         *,
         loop: asyncio.AbstractEventLoop | None = None,
         stop_signal: Iterable[signal.Signals] = (signal.SIGINT,),
     ):
-        manager = it(Launart)
+        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_server-0.9.2 → satori_python_server-0.11.0}/src/satori/server/adapter.py

@@ -3,40 +3,31 @@ from typing import Any, AsyncIterator, Dict, List
 
 from launart import Service
 
-from satori.const import Api
-
 from ..model import Event, Login
 from .model import Request
 
 
 class Adapter(Service):
     @abstractmethod
-    def get_platform(self) -> str:
-        ...
+    def get_platform(self) -> str: ...
 
     @abstractmethod
-    def publisher(self) -> AsyncIterator[Event]:
-        ...
+    def publisher(self) -> AsyncIterator[Event]: ...
 
     @abstractmethod
-    def validate_headers(self, headers: Dict[str, Any]) -> bool:
-        ...
+    def validate_headers(self, headers: Dict[str, Any]) -> bool: ...
 
     @abstractmethod
-    def authenticate(self, token: str) -> bool:
-        ...
+    def authenticate(self, token: str) -> bool: ...
 
     @abstractmethod
-    async def get_logins(self) -> List[Login]:
-        ...
+    async def get_logins(self) -> List[Login]: ...
 
     @abstractmethod
-    async def call_api(self, request: Request[Api]) -> Any:
-        ...
+    async def call_api(self, request: Request[Any]) -> Any: ...
 
     @abstractmethod
-    async def call_internal_api(self, request: Request[str]) -> Any:
-        ...
+    async def call_internal_api(self, request: Request[Any]) -> Any: ...
 
     @property
     def id(self):

satori_python_server-0.11.0/src/satori/server/model.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, AsyncIterator, Generic, Protocol, TypeVar, Union, runtime_checkable
+
+from satori.const import Api
+from satori.model import Event, Login
+
+JsonType = Union[list, dict, str, int, bool, float, None]
+TA = TypeVar("TA", str, Api)
+TP = TypeVar("TP")
+
+
+@dataclass
+class Request(Generic[TP]):
+    headers: dict[str, Any]
+    action: str
+    params: TP
+
+
+@runtime_checkable
+class Provider(Protocol):
+    def publisher(self) -> AsyncIterator[Event]: ...
+
+    def authenticate(self, token: str) -> bool: ...
+
+    async def get_logins(self) -> list[Login]: ...
+
+
+@runtime_checkable
+class Router(Protocol):
+    def validate_headers(self, headers: dict[str, Any]) -> bool: ...
+
+    async def call_api(self, request: Request[Any]) -> Any: ...
+
+    async def call_internal_api(self, request: Request[Any]) -> Any: ...

satori_python_server-0.11.0/src/satori/server/route.py

@@ -0,0 +1,240 @@
+from typing import Any, Awaitable, Dict, List, Protocol, TypeVar, Union
+from typing_extensions import NotRequired, TypeAlias, TypedDict
+
+from satori.model import Channel, Guild, Login, Member, MessageObject, ModelBase, PageResult, Role, User
+
+from .model import Request
+
+T = TypeVar("T")
+R = TypeVar("R", covariant=True)
+
+
+class Router(Protocol[T, R]):
+    def __call__(self, request: Request[T]) -> Awaitable[R]: ...
+
+
+INTERAL: TypeAlias = Router[
+    Any, Union[ModelBase, List[ModelBase], Dict[str, Any], List[Dict[str, Any]], None]
+]
+
+
+class MessageParam(TypedDict):
+    channel_id: str
+    content: str
+
+
+MESSAGE_CREATE: TypeAlias = Router[MessageParam, Union[List[MessageObject], List[Dict[str, Any]]]]
+MESSAGE_GET: TypeAlias = Router[MessageParam, Union[MessageObject, Dict[str, Any]]]
+MESSAGE_DELETE: TypeAlias = Router[MessageParam, None]
+
+
+class MessageUpdateParam(TypedDict):
+    channel_id: str
+    message_id: str
+    content: str
+
+
+MESSAGE_UPDATE: TypeAlias = Router[MessageUpdateParam, None]
+
+
+class MessageListParam(TypedDict):
+    channel_id: str
+    next: NotRequired[str]
+
+
+MESSAGE_LIST: TypeAlias = Router[MessageListParam, Union[PageResult[MessageObject], Dict[str, Any]]]
+
+
+class ChannelParam(TypedDict):
+    channel_id: str
+
+
+CHANNEL_GET: TypeAlias = Router[ChannelParam, Union[Channel, Dict[str, Any]]]
+CHANNEL_DELETE: TypeAlias = Router[ChannelParam, None]
+
+
+class ChannelListParam(TypedDict):
+    guild_id: str
+    next: NotRequired[str]
+
+
+CHANNEL_LIST: TypeAlias = Router[ChannelListParam, Union[PageResult[Channel], Dict[str, Any]]]
+
+
+class ChanneCreateParam(TypedDict):
+    guild_id: str
+    data: dict
+
+
+CHANNEL_CREATE: TypeAlias = Router[ChanneCreateParam, Union[Channel, Dict[str, Any]]]
+
+
+class ChanneUpdateParam(TypedDict):
+    channel_id: str
+    data: dict
+
+
+CHANNEL_UPDATE: TypeAlias = Router[ChanneUpdateParam, None]
+
+
+class ChannelMuteParam(TypedDict):
+    channel_id: str
+    duration: float
+
+
+CHANNEL_MUTE: TypeAlias = Router[ChannelMuteParam, None]
+
+
+class UserChannelCreateParam(TypedDict):
+    user_id: str
+    guild_id: NotRequired[str]
+
+
+ROUTE_USER_CHANNEL_CREATE: TypeAlias = Router[UserChannelCreateParam, Union[Channel, Dict[str, Any]]]
+
+
+class GuildGetParam(TypedDict):
+    guild_id: str
+
+
+GUILD_GET: TypeAlias = Router[GuildGetParam, Union[Guild, Dict[str, Any]]]
+
+
+class GuildListParam(TypedDict):
+    next: NotRequired[str]
+
+
+GUILD_LIST: TypeAlias = Router[GuildListParam, Union[PageResult[Guild], Dict[str, Any]]]
+
+
+class GuildMemberGetParam(TypedDict):
+    guild_id: str
+    user_id: str
+
+
+GUILD_MEMBER_GET: TypeAlias = Router[GuildMemberGetParam, Union[Member, Dict[str, Any]]]
+
+
+class GuildXXXListParam(TypedDict):
+    guild_id: str
+    next: NotRequired[str]
+
+
+GUILD_MEMBER_LIST: TypeAlias = Router[GuildXXXListParam, Union[PageResult[Member], Dict[str, Any]]]
+
+
+class GuildMemberKickParam(TypedDict):
+    guild_id: str
+    user_id: str
+    permanent: NotRequired[bool]
+
+
+GUILD_MEMBER_KICK: TypeAlias = Router[GuildMemberKickParam, None]
+
+
+class GuildMemberMuteParam(TypedDict):
+    guild_id: str
+    user_id: str
+    duration: float
+
+
+GUILD_MEMBER_MUTE: TypeAlias = Router[GuildMemberMuteParam, None]
+
+
+class GuildMemberRoleParam(TypedDict):
+    guild_id: str
+    user_id: str
+    role_id: str
+
+
+GUILD_MEMBER_ROLE_SET: TypeAlias = Router[GuildMemberRoleParam, None]
+GUILD_MEMBER_ROLE_UNSET: TypeAlias = Router[GuildMemberRoleParam, None]
+
+GUILD_ROLE_LIST: TypeAlias = Router[GuildXXXListParam, Union[PageResult[Role], Dict[str, Any]]]
+
+
+class GuildRoleCreateParam(TypedDict):
+    guild: str
+    role: dict
+
+
+GUILD_ROLE_CREATE: TypeAlias = Router[GuildRoleCreateParam, Union[Role, Dict[str, Any]]]
+
+
+class GuildRoleUpdateParam(TypedDict):
+    guild: str
+    role_id: str
+    role: dict
+
+
+GUILD_ROLE_UPDATE: TypeAlias = Router[GuildRoleUpdateParam, None]
+
+
+class GuildRoleDeleteParam(TypedDict):
+    guild: str
+    role_id: str
+
+
+GUILD_ROLE_DELETE: TypeAlias = Router[GuildRoleDeleteParam, None]
+
+
+class ReactionCreateParam(TypedDict):
+    channel_id: str
+    message_id: str
+    emoji: str
+
+
+REACTION_CREATE: TypeAlias = Router[ReactionCreateParam, None]
+
+
+class ReactionDeleteParam(TypedDict):
+    channel_id: str
+    message_id: str
+    emoji: str
+    user_id: NotRequired[str]
+
+
+REACTION_DELETE: TypeAlias = Router[ReactionDeleteParam, None]
+
+
+class ReactionClearParam(TypedDict):
+    channel_id: str
+    message_id: str
+    emoji: NotRequired[str]
+
+
+REACTION_CLEAR: TypeAlias = Router[ReactionClearParam, None]
+
+
+class ReactionListParam(TypedDict):
+    channel_id: str
+    message_id: str
+    emoji: str
+    next: NotRequired[str]
+
+
+REACTION_LIST: TypeAlias = Router[ReactionListParam, Union[PageResult[User], Dict[str, Any]]]
+LOGIN_GET: TypeAlias = Router[Any, Union[Login, Dict[str, Any]]]
+
+
+class UserGetParam(TypedDict):
+    user_id: str
+
+
+USER_GET: TypeAlias = Router[UserGetParam, Union[User, Dict[str, Any]]]
+
+
+class FriendListParam(TypedDict):
+    next: NotRequired[str]
+
+
+FRIEND_LIST: TypeAlias = Router[FriendListParam, Union[PageResult[User], Dict[str, Any]]]
+
+
+class ApproveParam(TypedDict):
+    message_id: str
+    approve: bool
+    comment: str
+
+
+APPROVE: TypeAlias = Router[ApproveParam, None]

satori_python_server-0.9.2/src/satori/server/model.py

@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, AsyncIterator, Generic, Protocol, TypeVar, runtime_checkable
-
-from satori.const import Api
-from satori.model import Event, Login
-
-TA = TypeVar("TA", str, Api)
-
-
-@dataclass
-class Request(Generic[TA]):
-    headers: dict[str, Any]
-    action: TA
-    params: Any
-
-
-@runtime_checkable
-class Provider(Protocol):
-    def publisher(self) -> AsyncIterator[Event]:
-        ...
-
-    def authenticate(self, token: str) -> bool:
-        ...
-
-    async def get_logins(self) -> list[Login]:
-        ...
-
-
-@runtime_checkable
-class Router(Protocol):
-    def validate_headers(self, headers: dict[str, Any]) -> bool:
-        ...
-
-    async def call_api(self, request: Request[Api]) -> Any:
-        ...
-
-    async def call_internal_api(self, request: Request[str]) -> Any:
-        ...