satori-python-core 0.16.7__tar.gz → 0.17.0__tar.gz

{satori_python_core-0.16.7 → satori_python_core-0.17.0}/.mina/core.toml

@@ -15,7 +15,7 @@ dependencies = [
 description = "Satori Protocol SDK for python, specify common part"
 license = {text = "MIT"}
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10,<4.0"
 classifiers = [
     "Typing :: Typed",
     "Development Status :: 4 - Beta",
@@ -31,3 +31,4 @@ classifiers = [
 [project.urls]
 homepage = "https://github.com/RF-Tar-Railt/satori-python"
 repository = "https://github.com/RF-Tar-Railt/satori-python"
+

{satori_python_core-0.16.7 → satori_python_core-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satori-python-core
-Version: 0.16.7
+Version: 0.17.0
 Summary: Satori Protocol SDK for python, specify common part
 Home-page: https://github.com/RF-Tar-Railt/satori-python
 Author-Email: RF-Tar-Railt <rf_tar_railt@qq.com>
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.12
 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-Python: <4.0,>=3.10
 Requires-Dist: loguru>=0.7.2
 Requires-Dist: yarl>=1.9.4
 Requires-Dist: typing-extensions>=4.7.0

{satori_python_core-0.16.7 → satori_python_core-0.17.0}/pyproject.toml

@@ -11,7 +11,7 @@ dependencies = [
 ]
 description = "Satori Protocol SDK for python, specify common part"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10,<4.0"
 classifiers = [
     "Typing :: Typed",
     "Development Status :: 4 - Beta",
@@ -23,7 +23,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Operating System :: OS Independent",
 ]
-version = "0.16.7"
+version = "0.17.0"
 
 [project.license]
 text = "MIT"
@@ -39,7 +39,7 @@ requires = [
 ]
 build-backend = "mina.backend"
 
-[tool.pdm.dev-dependencies]
+[dependency-groups]
 dev = [
     "isort>=5.13.2",
     "black>=24.4.0",
@@ -49,6 +49,7 @@ dev = [
     "mina-build<0.6,>=0.5.1",
     "pdm-mina>=0.3.2",
     "nonechat<0.7.0,>=0.6.0",
+    "uvicorn[standard]>=0.35.0",
 ]
 
 [tool.pdm.build]
@@ -74,21 +75,21 @@ source = "file"
 path = "src/satori/__init__.py"
 
 [tool.black]
-line-length = 110
+line-length = 120
 include = "\\.pyi?$"
 extend-exclude = ""
 
 [tool.isort]
 profile = "black"
-line_length = 110
+line_length = 120
 skip_gitignore = true
 extra_standard_library = [
     "typing_extensions",
 ]
 
 [tool.ruff]
-line-length = 110
-target-version = "py39"
+line-length = 120
+target-version = "py310"
 exclude = [
     "exam.py",
 ]
@@ -108,12 +109,12 @@ ignore = [
     "F403",
     "F405",
     "C901",
-    "UP037",
+    "UP038",
 ]
 
 [tool.pyright]
 pythonPlatform = "All"
-pythonVersion = "3.9"
+pythonVersion = "3.10"
 typeCheckingMode = "basic"
 reportShadowedImports = false
 disableBytesTypePromotions = true

{satori_python_core-0.16.7 → satori_python_core-0.17.0}/src/satori/__init__.py

@@ -23,6 +23,7 @@ from .element import Superscript as Superscript
 from .element import Text as Text
 from .element import Underline as Underline
 from .element import Video as Video
+from .element import register_element as register_element
 from .element import select as select
 from .element import transform as transform
 from .model import ArgvInteraction as ArgvInteraction
@@ -41,4 +42,4 @@ from .model import Role as Role
 from .model import Upload as Upload
 from .model import User as User
 
-__version__ = "0.16.7"
+__version__ = "0.17.0"

{satori_python_core-0.16.7 → satori_python_core-0.17.0}/src/satori/element.py

@@ -1,23 +1,57 @@
 from base64 import b64encode
-from dataclasses import InitVar, dataclass, field, fields
+from collections.abc import Callable, Sequence
+from dataclasses import InitVar, dataclass, field
 from io import BytesIO
 from pathlib import Path
-from typing import Any, ClassVar, Optional, TypeVar, Union, get_args, overload
+from types import UnionType
+from typing import Any, ClassVar, Final, TypeVar, Union, final, get_args, get_origin, overload
 from typing_extensions import override
 
 from .parser import Element as RawElement
-from .parser import escape, param_case
+from .parser import escape, param_case, parse
 from .parser import select as select_raw
+from .utils import decode
 
 TE = TypeVar("TE", bound="Element")
 
 
+def conv_bool(v: str) -> bool:
+    if v.lower() not in ("true", "false"):
+        raise ValueError(v)
+    return v.lower() == "true"
+
+
 @dataclass(repr=False)
 class Element:
     _attrs: dict[str, Any] = field(init=False, default_factory=dict)
     _children: list["Element"] = field(init=False, default_factory=list)
 
     __names__: ClassVar[tuple[str, ...]]
+    __convert_fields__: ClassVar[dict[str, Callable[[str], Any]]]
+
+    def __init_subclass__(cls, **kwargs):
+        cls.__convert_fields__ = {}
+        annotations = cls.__annotations__
+        for name, typ in annotations.items():
+            if name.startswith("_"):
+                continue
+            # _type = get_args(typ)[0] if hasattr(typ, "__origin__") else typ
+            orig = get_origin(typ)
+            if orig in (Union, UnionType):
+                args = get_args(typ)
+                if len(args) == 2 and type(None) in args:
+                    _type = args[0] if args[1] is type(None) else args[1]
+                else:
+                    _type = args[0]
+            else:
+                _type = typ
+            if _type is not str:
+                if _type is bool:
+                    cls.__convert_fields__[name] = conv_bool
+                elif _type in (list, dict):
+                    cls.__convert_fields__[name] = decode
+                else:
+                    cls.__convert_fields__[name] = _type
 
     @property
     def children(self) -> list["Element"]:
@@ -29,24 +63,21 @@ class Element:
 
     @classmethod
     def unpack(cls, attrs: dict[str, Any]):
-        obj = cls(**{k: v for k, v in attrs.items() if k in cls.__names__})  # type: ignore
-        obj._attrs.update({k: v for k, v in attrs.items() if k not in cls.__names__})
+        data = {}
+        names = getattr(cls, "__names__", None)
+        for name in cls.__dataclass_fields__.keys():
+            if name not in attrs:
+                continue
+            if name in cls.__convert_fields__:
+                data[name] = cls.__convert_fields__[name](attrs[name])
+            else:
+                data[name] = attrs[name]
+        obj = cls(**{k: v for k, v in data.items() if names is None or k in names})  # type: ignore
+        obj._attrs.update(data)
         return obj
 
     def __post_init__(self):
-        for f in fields(self):
-            if f.name in ("_attrs", "_children"):
-                continue
-            _type = get_args(f.type)[0] if hasattr(f.type, "__origin__") else f.type
-            if _type is not str and isinstance(attr := getattr(self, f.name), str):
-                if _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, _type(attr))  # type: ignore
-            self._attrs[f.name] = getattr(self, f.name)
-        self._attrs = {k: v for k, v in self._attrs.items() if v is not None}
+        self._attrs = {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
 
     def attributes(self) -> str:
         def _attr(key: str, value: Any):
@@ -82,7 +113,7 @@ class Element:
             elem += ", { " + ", ".join(repr(i) for i in self._children) + " }"
         return elem + ")"
 
-    def __call__(self, *content: Union[str, "Element"]):
+    def __call__(self, *content: "str | Element"):
         self._children.extend(Text(i) if isinstance(i, str) else i for i in content)
         self.__post_call__()
         return self
@@ -103,22 +134,20 @@ class Text(Element):
     def dumps(self, strip: bool = False) -> str:
         return self.text if strip else escape(self.text)
 
-    __names__ = ("text",)
-
 
 @dataclass(repr=False)
 class At(Element):
     """<at> 元素用于提及某个或某些用户。"""
 
-    id: Optional[str] = None
-    name: Optional[str] = None
-    role: Optional[str] = None
-    type: Optional[str] = None
+    id: str | None = None
+    name: str | None = None
+    role: str | None = None
+    type: str | None = None
 
     @staticmethod
     def role_(
         role: str,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> "At":
         return At(role=role, name=name)
 
@@ -126,15 +155,13 @@ class At(Element):
     def all(here: bool = False) -> "At":
         return At(type="here" if here else "all")
 
-    __names__ = ("id", "name", "role", "type")
-
 
 @dataclass(repr=False)
 class Sharp(Element):
     """<sharp> 元素用于提及某个频道。"""
 
     id: str
-    name: Optional[str] = None
+    name: str | None = None
 
 
 @dataclass(repr=False)
@@ -143,8 +170,6 @@ class Link(Element):
 
     href: str
 
-    __names__ = ("href",)
-
     def __post_call__(self):
         if not self._children:
             return
@@ -165,26 +190,26 @@ class Link(Element):
 @dataclass(repr=False)
 class Resource(Element):
     src: str
-    title: Optional[str] = None
-    extra: InitVar[Optional[dict[str, Any]]] = None
-    cache: Optional[bool] = None
-    timeout: Optional[int] = None
+    title: str | None = None
+    extra: InitVar[dict[str, Any] | None] = None
+    cache: bool | None = None
+    timeout: int | None = None
 
     __names__ = ("src", "title")
 
     @classmethod
     def of(
         cls,
-        url: Optional[str] = None,
-        path: Optional[Union[str, Path]] = None,
-        raw: Optional[Union[bytes, BytesIO]] = None,
-        mime: Optional[str] = None,
-        name: Optional[str] = None,
-        duration: Optional[float] = None,
-        poster: Optional[str] = None,
-        extra: Optional[dict[str, Any]] = None,
-        cache: Optional[bool] = None,
-        timeout: Optional[int] = None,
+        url: str | None = None,
+        path: str | Path | None = None,
+        raw: bytes | BytesIO | None = None,
+        mime: str | None = None,
+        name: str | None = None,
+        duration: float | None = None,
+        poster: str | None = None,
+        extra: dict[str, Any] | None = None,
+        cache: bool | None = None,
+        timeout: int | None = None,
         **kwargs,
     ):
         data: dict[str, Any] = {"extra": extra or kwargs}
@@ -209,7 +234,7 @@ class Resource(Element):
             data["timeout"] = timeout
         return cls(**data)
 
-    def __post_init__(self, extra: Optional[dict[str, Any]] = None):
+    def __post_init__(self, extra: dict[str, Any] | None = None):
         super().__post_init__()
         if extra:
             self._attrs.update(extra)
@@ -219,8 +244,8 @@ class Resource(Element):
 class Image(Resource):
     """<img> 元素用于表示图片。"""
 
-    width: Optional[int] = None
-    height: Optional[int] = None
+    width: int | None = None
+    height: int | None = None
 
     __names__ = ("src", "title", "width", "height")
 
@@ -234,8 +259,8 @@ class Image(Resource):
 class Audio(Resource):
     """<audio> 元素用于表示语音。"""
 
-    duration: Optional[float] = None
-    poster: Optional[str] = None
+    duration: float | None = None
+    poster: str | None = None
 
     __names__ = ("src", "title", "duration", "poster")
 
@@ -244,10 +269,10 @@ class Audio(Resource):
 class Video(Resource):
     """<video> 元素用于表示视频。"""
 
-    width: Optional[int] = None
-    height: Optional[int] = None
-    duration: Optional[float] = None
-    poster: Optional[str] = None
+    width: int | None = None
+    height: int | None = None
+    duration: float | None = None
+    poster: str | None = None
 
     __names__ = ("src", "title", "width", "height", "duration", "poster")
 
@@ -256,7 +281,7 @@ class Video(Resource):
 class File(Resource):
     """<file> 元素用于表示文件。"""
 
-    poster: Optional[str] = None
+    poster: str | None = None
 
     __names__ = ("src", "title", "poster")
 
@@ -267,7 +292,7 @@ class Style(Element):
 
     __names__ = ()
 
-    def __init__(self, *text: Union[str, Text, "Style"]):
+    def __init__(self, *text: "str | Text | Style"):
         super().__init__()
         self.__call__(*text)
 
@@ -374,16 +399,14 @@ class Message(Element):
     子元素对应于消息的内容。如果其没有子元素，则消息不会被发送。
     """
 
-    __names__ = ("id", "forward")
-
-    id: Optional[str]
-    forward: Optional[bool]
+    id: str | None
+    forward: bool | None
 
     def __init__(
         self,
-        id: Optional[str] = None,
-        forward: Optional[bool] = None,
-        content: Optional[list[Union[str, Element]]] = None,
+        id: str | None = None,
+        forward: bool | None = None,
+        content: list[str | Element] | None = None,
     ):
         self.id = id
         self.forward = forward
@@ -405,10 +428,8 @@ class Author(Element):
     """<author> 元素用于表示消息的作者。它的子元素会被渲染为作者的名字。"""
 
     id: str
-    name: Optional[str] = None
-    avatar: Optional[str] = None
-
-    __names__ = ("id", "name", "avatar")
+    name: str | None = None
+    avatar: str | None = None
 
 
 @dataclass(repr=False)
@@ -416,23 +437,21 @@ class Button(Element):
     """<button> 元素用于表示一个按钮。它的子元素会被渲染为按钮的文本。"""
 
     type: str
-    id: Optional[str] = None
-    href: Optional[str] = None
-    text: Optional[str] = None
-    theme: Optional[str] = None
-
-    __names__ = ("type", "id", "href", "text", "theme")
+    id: str | None = None
+    href: str | None = None
+    text: str | None = None
+    theme: str | None = None
 
     @classmethod
-    def action(cls, button_id: str, theme: Optional[str] = None):
+    def action(cls, button_id: str, theme: str | None = None):
         return Button("action", id=button_id, theme=theme)
 
     @classmethod
-    def link(cls, url: str, theme: Optional[str] = None):
+    def link(cls, url: str, theme: str | None = None):
         return Button("link", href=url, theme=theme)
 
     @classmethod
-    def input(cls, text: str, theme: Optional[str] = None):
+    def input(cls, text: str, theme: str | None = None):
         return Button("input", text=text, theme=theme)
 
     def attributes(self) -> str:
@@ -460,18 +479,15 @@ class Button(Element):
 class Custom(Element):
     """自定义元素用于构造标准元素以外的元素"""
 
-    type: str
-
     __names__ = ()
 
     def __init__(
         self,
         type: str,
-        attrs: Optional[dict[str, Any]] = None,
-        children: Optional[list[Union[str, Element]]] = None,
+        attrs: dict[str, Any] | None = None,
+        children: Sequence[str | Element] | None = None,
     ):
         self.type = type
-        super().__init__()
         if not hasattr(self, "_attrs"):
             self._attrs = attrs or {}
         else:
@@ -500,6 +516,17 @@ class Raw(Element):
         return self.content if strip else escape(self.content)
 
 
+def register_element(cls: type[TE], tag: str | None = None) -> type[TE]:
+    """注册一个自定义元素类，使其可以被 `transform` 函数识别。
+
+    该类必须继承自 `Element`; 必要时还需要定义 `__names__` 类变量以指定可接受的属性名。
+    """
+    if not issubclass(cls, Element):
+        raise TypeError("cls must be a subclass of Element")
+    ELEMENT_TYPE_MAP[tag or cls.__name__.lower()] = cls
+    return cls
+
+
 ELEMENT_TYPE_MAP = {
     "text": Text,
     "at": At,
@@ -571,14 +598,14 @@ def transform(elements: list[RawElement]) -> list[Element]:
 
 
 @overload
-def select(elements: Union[Element, list[Element]], query: type[TE]) -> list[TE]: ...
+def select(elements: Element | list[Element], query: type[TE]) -> list[TE]: ...
 
 
 @overload
-def select(elements: Union[Element, list[Element]], query: str) -> list[Element]: ...
+def select(elements: Element | list[Element], query: str) -> list[Element]: ...
 
 
-def select(elements: Union[Element, list[Element]], query: Union[type[TE], str]):
+def select(elements: Element | list[Element], query: type[TE] | str):
     if not elements:
         return []
     if isinstance(elements, Element):
@@ -596,39 +623,44 @@ def select(elements: Union[Element, list[Element]], query: Union[type[TE], str])
     return results
 
 
-class E:
-    text = Text
-    at = At
-    at_role = At.role_
-    at_all = At.all
-    sharp = Sharp
-    link = Link
-    image = Image.of
-    audio = Audio.of
-    video = Video.of
-    file = File.of
-    resource = Resource
-    bold = Bold
-    italic = Italic
-    underline = Underline
-    strikethrough = Strikethrough
-    spoiler = Spoiler
-    code = Code
-    sup = Superscript
-    sub = Subscript
-    br = Br
-    paragraph = Paragraph
-    message = Message
-    quote = Quote
-    author = Author
-    custom = Custom
-    raw = Raw
-    button = Button
-    action_button = Button.action
-    link_button = Button.link
-    input_button = Button.input
-
-    select = select
-
-    def __new__(cls, *args, **kwargs):
-        raise TypeError("E is not instantiable")
+@final
+class _E:
+    def __init__(self):
+        self.text = Text
+        self.at = At
+        self.at_role = At.role_
+        self.at_all = At.all
+        self.sharp = Sharp
+        self.link = Link
+        self.image = Image.of
+        self.audio = Audio.of
+        self.video = Video.of
+        self.file = File.of
+        self.resource = Resource
+        self.bold = Bold
+        self.italic = Italic
+        self.underline = Underline
+        self.strikethrough = Strikethrough
+        self.spoiler = Spoiler
+        self.code = Code
+        self.sup = Superscript
+        self.sub = Subscript
+        self.br = Br
+        self.paragraph = Paragraph
+        self.message = Message
+        self.quote = Quote
+        self.author = Author
+        self.raw = Raw
+        self.button = Button
+        self.action_button = Button.action
+        self.link_button = Button.link
+        self.input_button = Button.input
+        self.select = select
+
+    def __call__(self, elem: str, context: dict | None = None) -> Custom:
+        """创建一个自定义元素"""
+        e = parse(elem, context)[0]
+        return Custom(e.type, e.attrs, transform(e.children))
+
+
+E: Final = _E()

{satori_python_core-0.16.7 → satori_python_core-0.17.0}/src/satori/model.py

@@ -1,12 +1,12 @@
 import mimetypes
-from collections.abc import AsyncIterable, Awaitable
-from dataclasses import asdict, dataclass, field, fields
+from collections.abc import AsyncIterable, Awaitable, Callable
+from dataclasses import Field, dataclass, field
 from datetime import datetime
 from enum import IntEnum
 from os import PathLike
 from pathlib import Path
-from typing import IO, Any, Callable, ClassVar, Generic, Literal, Optional, TypeVar, Union
-from typing_extensions import TypeAlias
+from typing import IO, Any, ClassVar, Generic, Literal, TypeAlias, TypeVar
+from typing_extensions import Self
 
 from .element import Element, transform
 from .parser import Element as RawElement
@@ -19,15 +19,15 @@ class ModelBase:
     _raw_data: dict[str, Any] = field(init=False, default_factory=dict, repr=False, compare=False, hash=False)
 
     @classmethod
-    def parse(cls, raw: dict):
-        fs = fields(cls)
+    def parse(cls: type[Self], raw: dict) -> Self:
+        fs: dict[str, Field] = cls.__dataclass_fields__
         data = {}
-        for fd in fs:
-            if fd.name in raw:
-                if fd.name in cls.__converter__:
-                    data[fd.name] = cls.__converter__[fd.name](raw[fd.name])
+        for name in fs.keys():
+            if name in raw:
+                if name in cls.__converter__:
+                    data[name] = cls.__converter__[name](raw[name])
                 else:
-                    data[fd.name] = raw[fd.name]
+                    data[name] = raw[name]
         obj = cls(**data)  # type: ignore
         obj._raw_data = raw
         return obj
@@ -47,8 +47,8 @@ class ChannelType(IntEnum):
 class Channel(ModelBase):
     id: str
     type: ChannelType = ChannelType.TEXT
-    name: Optional[str] = None
-    parent_id: Optional[str] = None
+    name: str | None = None
+    parent_id: str | None = None
 
     __converter__ = {"type": ChannelType}
 
@@ -64,8 +64,8 @@ class Channel(ModelBase):
 @dataclass
 class Guild(ModelBase):
     id: str
-    name: Optional[str] = None
-    avatar: Optional[str] = None
+    name: str | None = None
+    avatar: str | None = None
 
     def dump(self):
         res = {"id": self.id}
@@ -79,10 +79,10 @@ class Guild(ModelBase):
 @dataclass
 class User(ModelBase):
     id: str
-    name: Optional[str] = None
-    nick: Optional[str] = None
-    avatar: Optional[str] = None
-    is_bot: Optional[bool] = None
+    name: str | None = None
+    nick: str | None = None
+    avatar: str | None = None
+    is_bot: bool | None = None
 
     def dump(self):
         res: dict[str, Any] = {"id": self.id}
@@ -99,10 +99,10 @@ class User(ModelBase):
 
 @dataclass
 class Member(ModelBase):
-    user: Optional[User] = None
-    nick: Optional[str] = None
-    avatar: Optional[str] = None
-    joined_at: Optional[datetime] = None
+    user: User | None = None
+    nick: str | None = None
+    avatar: str | None = None
+    joined_at: datetime | None = None
 
     __converter__ = {"user": User.parse, "joined_at": lambda ts: datetime.fromtimestamp(int(ts) / 1000)}
 
@@ -122,7 +122,7 @@ class Member(ModelBase):
 @dataclass
 class Role(ModelBase):
     id: str
-    name: Optional[str] = None
+    name: str | None = None
 
     def dump(self):
         res = {"id": self.id}
@@ -188,8 +188,8 @@ class Login(ModelBase):
 
 @dataclass
 class LoginPartial(Login):
-    platform: Optional[str] = None
-    user: Optional[User] = None
+    platform: str | None = None
+    user: User | None = None
 
 
 @dataclass
@@ -199,7 +199,7 @@ class ArgvInteraction(ModelBase):
     options: Any
 
     def dump(self):
-        return asdict(self)
+        return {"name": self.name, "arguments": self.arguments, "options": self.options}
 
 
 @dataclass
@@ -207,7 +207,7 @@ class ButtonInteraction(ModelBase):
     id: str
 
     def dump(self):
-        return asdict(self)
+        return {"id": self.id}
 
 
 class Opcode(IntEnum):
@@ -227,8 +227,8 @@ class Opcode(IntEnum):
 
 @dataclass
 class Identify(ModelBase):
-    token: Optional[str] = None
-    sn: Optional[int] = None
+    token: str | None = None
+    sn: int | None = None
 
     @classmethod
     def parse(cls, raw: dict):
@@ -237,11 +237,11 @@ class Identify(ModelBase):
         return super().parse(raw)
 
     @property
-    def sequence(self) -> Optional[int]:
+    def sequence(self) -> int | None:
         return self.sn
 
     def dump(self):
-        return asdict(self)
+        return {k: v for k, v in (("token", self.token), ("sn", self.sn)) if v is not None}
 
 
 @dataclass
@@ -252,7 +252,7 @@ class Ready(ModelBase):
     __converter__ = {"logins": lambda raw: [LoginPartial.parse(login) for login in raw]}
 
     def dump(self):
-        return asdict(self)
+        return {"logins": [login.dump() for login in self.logins], "proxy_urls": self.proxy_urls}
 
 
 @dataclass
@@ -262,7 +262,7 @@ class MetaPayload(ModelBase):
     proxy_urls: list[str]
 
     def dump(self):
-        return asdict(self)
+        return {"proxy_urls": self.proxy_urls}
 
 
 @dataclass
@@ -275,40 +275,46 @@ class Meta(ModelBase):
     __converter__ = {"logins": lambda raw: [LoginPartial.parse(login) for login in raw]}
 
     def dump(self):
-        return asdict(self)
+        return {"logins": [login.dump() for login in self.logins], "proxy_urls": self.proxy_urls}
 
 
 @dataclass
 class MessageObject(ModelBase):
     id: str
     content: str
-    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
+    channel: Channel | None = None
+    guild: Guild | None = None
+    member: Member | None = None
+    user: User | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = 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,
+        channel: Channel | None = None,
+        guild: Guild | None = None,
+        member: Member | None = None,
+        user: User | None = None,
+        created_at: datetime | None = None,
+        updated_at: datetime | None = None,
     ):
-        return cls(id, "".join(str(i) for i in content), channel, guild, member, user, created_at, updated_at)
+        obj = cls(id, "".join(str(i) for i in content), channel, guild, member, user, created_at, updated_at)
+        obj._parsed_message = content
+        return obj
 
     @property
     def message(self) -> list[Element]:
-        return transform(parse(self.content))
+        if hasattr(self, "_parsed_message"):
+            return self._parsed_message
+        self._parsed_message = transform(parse(self.content))
+        return self._parsed_message
 
     @message.setter
     def message(self, value: list[Element]):
+        self._parsed_message = value
         self.content = "".join(str(i) for i in value)
 
     @classmethod
@@ -347,22 +353,22 @@ class MessageObject(ModelBase):
 @dataclass
 class MessageReceipt(ModelBase):
     id: str
-    content: Optional[str] = None
+    content: str | None = None
 
     @classmethod
     def from_elements(
         cls,
         id: str,
-        content: Optional[list[Element]] = None,
+        content: list[Element] | None = None,
     ):
         return cls(id, "".join(str(i) for i in content) if content else None)
 
     @property
-    def message(self) -> Optional[list[Element]]:
+    def message(self) -> list[Element] | None:
         return transform(parse(self.content)) if self.content else None
 
     @message.setter
-    def message(self, value: Optional[list[Element]]):
+    def message(self, value: list[Element] | None):
         self.content = "".join(str(i) for i in value) if value else None
 
     @classmethod
@@ -384,18 +390,18 @@ class Event(ModelBase):
     type: str
     timestamp: datetime
     login: Login
-    argv: Optional[ArgvInteraction] = None
-    button: Optional[ButtonInteraction] = None
-    channel: Optional[Channel] = None
-    guild: Optional[Guild] = None
-    member: Optional[Member] = None
-    message: Optional[MessageObject] = None
-    operator: Optional[User] = None
-    role: Optional[Role] = None
-    user: Optional[User] = None
-
-    _type: Optional[str] = None
-    _data: Optional[dict] = None
+    argv: ArgvInteraction | None = None
+    button: ButtonInteraction | None = None
+    channel: Channel | None = None
+    guild: Guild | None = None
+    member: Member | None = None
+    message: MessageObject | None = None
+    operator: User | None = None
+    role: Role | None = None
+    user: User | None = None
+
+    _type: str | None = None
+    _data: dict | None = None
 
     sn: int = 0
 
@@ -474,10 +480,10 @@ T = TypeVar("T", bound=ModelBase)
 @dataclass
 class PageResult(ModelBase, Generic[T]):
     data: list[T]
-    next: Optional[str] = None
+    next: str | None = None
 
     @classmethod
-    def parse(cls, raw: dict, parser: Optional[Callable[[dict], T]] = None) -> "PageResult[T]":
+    def parse(cls, raw: dict, parser: Callable[[dict], T] | None = None) -> "PageResult[T]":
         data = [(parser or ModelBase.parse)(item) for item in raw["data"]]
         return cls(data, raw.get("next"))  # type: ignore
 
@@ -490,10 +496,10 @@ class PageResult(ModelBase, Generic[T]):
 
 @dataclass
 class PageDequeResult(PageResult[T]):
-    prev: Optional[str] = None
+    prev: str | None = None
 
     @classmethod
-    def parse(cls, raw: dict, parser: Optional[Callable[[dict], T]] = None) -> "PageDequeResult[T]":
+    def parse(cls, raw: dict, parser: Callable[[dict], T] | None = None) -> "PageDequeResult[T]":
         data = [(parser or ModelBase.parse)(item) for item in raw["data"]]
         return cls(data, raw.get("next"), raw.get("prev"))  # type: ignore
 
@@ -507,9 +513,7 @@ class PageDequeResult(PageResult[T]):
 
 
 class IterablePageResult(Generic[T], AsyncIterable[T], Awaitable[PageResult[T]]):
-    def __init__(
-        self, func: Callable[[Optional[str]], Awaitable[PageResult[T]]], initial_page: Optional[str] = None
-    ):
+    def __init__(self, func: Callable[[str | None], Awaitable[PageResult[T]]], initial_page: str | None = None):
         self.func = func
         self.next_page = initial_page
 
@@ -535,9 +539,9 @@ Order: TypeAlias = Literal["asc", "desc"]
 
 @dataclass
 class Upload:
-    file: Union[bytes, IO[bytes], PathLike]
+    file: bytes | IO[bytes] | PathLike
     mimetype: str = "image/png"
-    name: Optional[str] = None
+    name: str | None = None
 
     def __post_init__(self):
         if isinstance(self.file, PathLike):

{satori_python_core-0.16.7 → satori_python_core-0.17.0}/src/satori/parser.py

@@ -1,9 +1,8 @@
 import re
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from dataclasses import dataclass, field
 from enum import IntEnum
-from typing import Any, Callable, Literal, Optional, TypedDict, TypeVar, Union, cast
-from typing_extensions import TypeAlias
+from typing import Any, Literal, Optional, TypeAlias, TypedDict, TypeVar, Union, cast
 
 T = TypeVar("T")
 
@@ -29,18 +28,14 @@ def camel_case(source: str) -> str:
 
 
 def param_case(source: str) -> str:
-    return re.sub(
-        ".[A-Z]+", lambda mat: mat[0][0] + "-" + mat[0][1:].lower(), uncapitalize(source).replace("_", "-")
-    )
+    return re.sub(".[A-Z]+", lambda mat: mat[0][0] + "-" + mat[0][1:].lower(), uncapitalize(source).replace("_", "-"))
 
 
 def snake_case(source: str) -> str:
-    return re.sub(
-        ".[A-Z]", lambda mat: mat[0][0] + "_" + mat[0][1:].lower(), uncapitalize(source).replace("-", "_")
-    )
+    return re.sub(".[A-Z]", lambda mat: mat[0][0] + "_" + mat[0][1:].lower(), uncapitalize(source).replace("-", "_"))
 
 
-def ensure_list(value: Union[T, list[T], None]) -> list[T]:
+def ensure_list(value: T | list[T] | None) -> list[T]:
     return value if isinstance(value, list) else [value] if value else []
 
 
@@ -73,12 +68,12 @@ class Element:
     type: str
     attrs: dict[str, Any]
     children: list["Element"]
-    source: Optional[str] = None
+    source: str | None = None
 
     def __init__(
         self,
-        type: Union[str, Render[Fragment, Any]],
-        attrs: Optional[dict[str, Any]] = None,
+        type: str | Render[Fragment, Any],
+        attrs: dict[str, Any] | None = None,
         *children: Fragment,
     ) -> None:
         self.attrs = {}
@@ -174,7 +169,7 @@ def parse_selector(input: str) -> list[list[Selector]]:
     return [_quert(q) for q in input.split(",")]
 
 
-def select(source: Union[str, list[Element]], query: Union[str, list[list[Selector]]]) -> list[Element]:
+def select(source: str | list[Element], query: str | list[list[Selector]]) -> list[Element]:
     if not source or not query:
         return []
     if isinstance(source, str):
@@ -237,9 +232,7 @@ tag_pat2 = re.compile(
     r"(?P<comment><!--[\s\S]*?-->)|(?P<tag><(/?)([^!\s>/]*)([^>]*?)\s*(/?)>)|(?P<curly>\{(?P<derivative>[@:/#][^\s\}]*)?[\s\S]*?\})"
 )
 attr_pat1 = re.compile(r"([^\s=]+)(?:=\"(?P<value1>[^\"]*)\"|='(?P<value2>[^']*)')?", re.S)
-attr_pat2 = re.compile(
-    r"([^\s=]+)(?:=\"(?P<value1>[^\"]*)\"|='(?P<value2>[^']*)'|=\{(?P<value3>[^\}]+)\})?", re.S
-)
+attr_pat2 = re.compile(r"([^\s=]+)(?:=\"(?P<value1>[^\"]*)\"|='(?P<value2>[^']*)'|=\{(?P<curly>[^\}]+)\})?", re.S)
 
 
 class Position(IntEnum):
@@ -264,7 +257,7 @@ class StackItem(TypedDict):
     slot: str
 
 
-def fold_tokens(tokens: list[Union[str, Token]]) -> list[Union[str, Token]]:
+def fold_tokens(tokens: list[str | Token]) -> list[str | Token]:
     stack: list[StackItem] = [
         {
             "token": Token(
@@ -279,7 +272,7 @@ def fold_tokens(tokens: list[Union[str, Token]]) -> list[Union[str, Token]]:
         }
     ]
 
-    def push_token(*tokens: Union[str, Token]):
+    def push_token(*tokens: str | Token):
         token = stack[0]["token"]
         token.children[stack[0]["slot"]].extend(tokens)
 
@@ -302,7 +295,7 @@ def fold_tokens(tokens: list[Union[str, Token]]) -> list[Union[str, Token]]:
     return stack[-1]["token"].children["default"]
 
 
-def parse_tokens(tokens: list[Union[str, Token]], context: Optional[dict] = None) -> list[Element]:
+def parse_tokens(tokens: list[str | Token], context: dict | None = None) -> list[Element]:
     result: list[Element] = []
     for token in tokens:
         if isinstance(token, str):
@@ -313,12 +306,12 @@ def parse_tokens(tokens: list[Union[str, Token]], context: Optional[dict] = None
             while mat := attr_pat.search(token.extra):
                 key = mat.group(1)
                 groupdict = mat.groupdict()
-                v = groupdict.get("value1") or groupdict.get("value2")
-                v3 = groupdict.get("value3")
-                if v3 and context is not None:
-                    attrs[key] = interpolate(v3, context)
-                elif v is not None:
-                    attrs[key] = unescape(v)
+                v2 = groupdict.get("value2", groupdict.get("value1"))
+                curly = groupdict.get("curly")
+                if curly and context is not None:
+                    attrs[key] = interpolate(curly, context)
+                elif v2 is not None:
+                    attrs[key] = unescape(v2)
                 elif key.startswith("no-"):
                     attrs[key[3:]] = False
                 else:
@@ -348,8 +341,8 @@ def parse_tokens(tokens: list[Union[str, Token]], context: Optional[dict] = None
     return result
 
 
-def parse(src: str, context: Optional[dict] = None):
-    tokens: list[Union[str, Token]] = []
+def parse(src: str, context: dict | None = None):
+    tokens: list[str | Token] = []
 
     def push_text(text: str):
         if text:

satori_python_core-0.17.0/src/satori/utils.py

@@ -0,0 +1,33 @@
+import socket
+
+
+def get_public_ip():
+    st = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        st.connect(("10.255.255.255", 1))
+        IP = st.getsockname()[0]
+    except Exception:
+        IP = "localhost"
+    finally:
+        st.close()
+    return IP
+
+
+try:
+    from msgspec.json import Decoder, Encoder  # noqa: F401
+
+    decoder = Decoder()
+    encoder = Encoder()
+
+    decode = decoder.decode
+
+    def encode(obj):
+        return encoder.encode(obj).decode()
+
+except ImportError:
+    import json
+
+    def encode(obj):
+        return json.dumps(obj, separators=(",", ":"), ensure_ascii=False)
+
+    decode = json.loads

satori_python_core-0.16.7/src/satori/utils.py

@@ -1,17 +0,0 @@
-import socket
-
-
-def get_public_ip():
-    st = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    try:
-        st.connect(("10.255.255.255", 1))
-        IP = st.getsockname()[0]
-    except Exception:
-        IP = "localhost"
-    finally:
-        st.close()
-    return IP
-
-
-if __name__ == "__main__":
-    print(get_public_ip())  # noqa: T201