satori-python-core 1.3.2__tar.gz → 1.3.4__tar.gz

{satori_python_core-1.3.2 → satori_python_core-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satori-python-core
-Version: 1.3.2
+Version: 1.3.4
 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>
@@ -27,11 +27,11 @@ Description-Content-Type: text/markdown
 [![PyPI](https://img.shields.io/pypi/v/satori-python)](https://pypi.org/project/satori-python)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/satori-python)](https://www.python.org/)
 
-基于 [Satori](https://satori.chat/zh-CN/) 协议的 Python 开发工具包
+基于 [Satori](https://satori.chat/zh-CN/protocol) 协议的 Python 开发工具包
 
 ## 协议介绍
 
-[Satori Protocol](https://satori.chat/zh-CN/)
+[Satori Protocol](https://satori.chat/zh-CN/protocol)
 
 ### 协议端
 

{satori_python_core-1.3.2 → satori_python_core-1.3.4}/README.md

@@ -5,11 +5,11 @@
 [![PyPI](https://img.shields.io/pypi/v/satori-python)](https://pypi.org/project/satori-python)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/satori-python)](https://www.python.org/)
 
-基于 [Satori](https://satori.chat/zh-CN/) 协议的 Python 开发工具包
+基于 [Satori](https://satori.chat/zh-CN/protocol) 协议的 Python 开发工具包
 
 ## 协议介绍
 
-[Satori Protocol](https://satori.chat/zh-CN/)
+[Satori Protocol](https://satori.chat/zh-CN/protocol)
 
 ### 协议端
 

{satori_python_core-1.3.2 → satori_python_core-1.3.4}/pyproject.toml

@@ -21,7 +21,7 @@ classifiers = [
     "Programming Language :: Python :: 3.14",
     "Operating System :: OS Independent",
 ]
-version = "1.3.2"
+version = "1.3.4"
 
 [project.license]
 text = "MIT"
@@ -39,15 +39,14 @@ build-backend = "mina.backend"
 
 [dependency-groups]
 dev = [
-    "isort>=5.13.2",
-    "black>=24.4.0",
-    "ruff>=0.4.1",
+    "black>=26.3.0",
+    "ruff>=0.15.1",
     "pre-commit>=3.7.0",
-    "fix-future-annotations>=0.5.0",
     "mina-build<0.6,>=0.5.1",
     "pdm-mina>=0.3.2",
     "nonechat<0.7.0,>=0.6.0",
     "uvicorn[standard]>=0.37.0",
+    "pydantic>=2.13.1",
 ]
 
 [tool.pdm.build]
@@ -63,7 +62,7 @@ excludes = [
 
 [tool.pdm.scripts.format]
 composite = [
-    "isort ./src/ ./example/",
+    "ruff check --select I --fix ./src/ ./example/",
     "black ./src/ ./example/",
     "ruff check",
 ]
@@ -77,14 +76,6 @@ line-length = 120
 include = "\\.pyi?$"
 extend-exclude = ""
 
-[tool.isort]
-profile = "black"
-line_length = 120
-skip_gitignore = true
-extra_standard_library = [
-    "typing_extensions",
-]
-
 [tool.ruff]
 line-length = 120
 target-version = "py310"
@@ -94,6 +85,7 @@ exclude = [
     "exam2.py",
     "src/satori/_vendor/*",
 ]
+respect-gitignore = true
 
 [tool.ruff.lint]
 select = [
@@ -113,6 +105,12 @@ ignore = [
     "T201",
 ]
 
+[tool.ruff.lint.isort]
+extra-standard-library = [
+    "typing_extensions",
+]
+force-sort-within-sections = false
+
 [tool.pyright]
 pythonPlatform = "All"
 pythonVersion = "3.10"

{satori_python_core-1.3.2 → satori_python_core-1.3.4}/src/satori/__init__.py

@@ -45,7 +45,7 @@ from .model import Role as Role
 from .model import Upload as Upload
 from .model import User as User
 
-__version__ = "1.3.2"
+__version__ = "1.3.4"
 
 
 MessageReceipt = MessageObject

{satori_python_core-1.3.2 → satori_python_core-1.3.4}/src/satori/element.py

@@ -4,7 +4,7 @@ from dataclasses import InitVar, dataclass, field
 from io import BytesIO
 from pathlib import Path
 from types import UnionType
-from typing import Any, ClassVar, Final, TypeVar, Union, final, get_args, get_origin, overload
+from typing import Any, ClassVar, Final, Literal, TypeVar, Union, final, get_args, get_origin, overload
 from typing_extensions import Self, override
 
 from ._vendor.fleep import get
@@ -17,7 +17,7 @@ TE = TypeVar("TE", bound="Element")
 
 
 def conv_bool(v: str) -> bool:
-    if v.lower() not in ("true", "false"):
+    if v.lower() not in {"true", "false"}:
         raise ValueError(v)
     return v.lower() == "true"
 
@@ -28,13 +28,17 @@ class Element:
     _children: list["Element"] = field(init=False, default_factory=list)
 
     __names__: ClassVar[tuple[str, ...]]
-    __convert_fields__: ClassVar[dict[str, Callable[[str], Any]]]
+    __convert_fields__: ClassVar[dict[str, Literal[True] | Callable[[str], Any]]]
+    __unpack_names__: ClassVar[frozenset[str]]
 
     def __init_subclass__(cls, **kwargs):
-        cls.__convert_fields__ = {}
+        convert_fields = {}
+        for base in cls.__mro__:
+            if hasattr(base, "__convert_fields__"):
+                convert_fields.update(base.__convert_fields__)
         annotations = cls.__annotations__
         for name, typ in annotations.items():
-            if name.startswith("_"):
+            if name.startswith("_") or isinstance(typ, InitVar):
                 continue
             # _type = get_args(typ)[0] if hasattr(typ, "__origin__") else typ
             orig = get_origin(typ)
@@ -46,39 +50,49 @@ class Element:
                     _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
+            if _type is bool:
+                convert_fields[name] = conv_bool
+            elif _type in (list, dict):
+                convert_fields[name] = decode
+            else:
+                convert_fields[name] = True if _type is str else _type
+        cls.__convert_fields__ = convert_fields
+        names = getattr(cls, "__names__", None)
+        for base in cls.__mro__:
+            if parent_names := getattr(base, "__names__", None):
+                if names is None:
+                    names = parent_names
                 else:
-                    cls.__convert_fields__[name] = _type
-
-    @property
-    def children(self) -> list["Element"]:
-        return self._children
-
-    @property
-    def tag(self) -> str:
-        return self.__class__.__name__.lower()
+                    names = names + parent_names
+        cls.__unpack_names__ = frozenset(names if names is not None else annotations.keys())
 
     @classmethod
     def unpack(cls, attrs: dict[str, Any]):
         data = {}
-        names = getattr(cls, "__names__", None)
-        for name in cls.__dataclass_fields__.keys():
+        args = {}
+        convert_fields = cls.__convert_fields__
+        names = cls.__unpack_names__
+        for name in convert_fields:
             if name not in attrs:
                 continue
-            if name in cls.__convert_fields__:
-                data[name] = cls.__convert_fields__[name](attrs[name])
-            else:
+            convert = convert_fields[name]
+            if convert is True:
                 data[name] = attrs[name]
-        obj = cls(**{k: v for k, v in data.items() if names is None or k in names})  # type: ignore
+            else:
+                data[name] = convert(attrs[name])
+            if name in names:
+                args[name] = data[name]
+        obj = cls(**args)  # type: ignore
         obj._attrs.update(data)
         return obj
 
-    def __post_init__(self):
-        self._attrs = {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
+    @property
+    def children(self) -> list["Element"]:
+        return self._children
+
+    @property
+    def tag(self) -> str:
+        return self.__class__.__name__.lower()
 
     def attributes(self) -> str:
         def _attr(key: str, value: Any):
@@ -94,6 +108,8 @@ class Element:
         return "".join(_attr(k, v) for k, v in self._attrs.items())
 
     def dumps(self, strip: bool = False) -> str:
+        if not self._attrs:
+            self._attrs = {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
         if self.tag == "text" and "text" in self._attrs:
             return self._attrs["text"] if strip else escape(self._attrs["text"])
         inner = "".join(c.dumps(strip) for c in self._children)
@@ -124,6 +140,9 @@ class Element:
     def __getitem__(self, key: str) -> Any:
         return self._attrs[key]
 
+    def raw(self) -> RawElement:
+        return RawElement(self.tag, self._attrs, [c.raw() for c in self._children])
+
 
 @dataclass(repr=False)
 class Text(Element):
@@ -131,6 +150,13 @@ class Text(Element):
 
     text: str
 
+    @override
+    @classmethod
+    def unpack(cls, attrs: dict[str, Any]):
+        obj = cls(attrs["text"])
+        obj._attrs["text"] = attrs["text"]
+        return obj
+
     @override
     def dumps(self, strip: bool = False) -> str:
         return self.text if strip else escape(self.text)
@@ -145,6 +171,12 @@ class At(Element):
     role: str | None = None
     type: str | None = None
 
+    @classmethod
+    def unpack(cls, attrs: dict[str, Any]):
+        obj = cls(attrs.get("id"), attrs.get("name"), attrs.get("role"), attrs.get("type"))
+        obj._attrs.update(attrs)
+        return obj
+
     @staticmethod
     def role_(
         role: str,
@@ -164,6 +196,12 @@ class Emoji(Element):
     id: str
     name: str | None = None
 
+    @classmethod
+    def unpack(cls, attrs: dict[str, Any]):
+        obj = cls(attrs["id"], attrs.get("name"))
+        obj._attrs.update(attrs)
+        return obj
+
     def to_model(self):
         from .model import EmojiObject
 
@@ -177,6 +215,12 @@ class Sharp(Element):
     id: str
     name: str | None = None
 
+    @classmethod
+    def unpack(cls, attrs: dict[str, Any]):
+        obj = cls(attrs["id"], attrs.get("name"))
+        obj._attrs.update(attrs)
+        return obj
+
 
 @dataclass(repr=False)
 class Link(Element):
@@ -184,6 +228,12 @@ class Link(Element):
 
     href: str
 
+    @classmethod
+    def unpack(cls, attrs: dict[str, Any]):
+        obj = cls(attrs["href"])
+        obj._attrs.update(attrs)
+        return obj
+
     def __post_call__(self):
         if not self._children:
             return
@@ -255,7 +305,6 @@ class Resource(Element):
         return cls(**data)
 
     def __post_init__(self, extra: dict[str, Any] | None = None):
-        super().__post_init__()
         if extra:
             self._attrs.update(extra)
 
@@ -267,7 +316,7 @@ class Image(Resource):
     width: int | None = None
     height: int | None = None
 
-    __names__ = ("src", "title", "width", "height")
+    __names__ = ("width", "height")
 
     @property
     @override
@@ -282,7 +331,7 @@ class Audio(Resource):
     duration: float | None = None
     poster: str | None = None
 
-    __names__ = ("src", "title", "duration", "poster")
+    __names__ = ("duration", "poster")
 
 
 @dataclass(repr=False)
@@ -294,7 +343,7 @@ class Video(Resource):
     duration: float | None = None
     poster: str | None = None
 
-    __names__ = ("src", "title", "width", "height", "duration", "poster")
+    __names__ = ("width", "height", "duration", "poster")
 
 
 @dataclass(repr=False)
@@ -303,7 +352,7 @@ class File(Resource):
 
     poster: str | None = None
 
-    __names__ = ("src", "title", "poster")
+    __names__ = ("poster",)
 
 
 @dataclass(init=False, repr=False)
@@ -312,6 +361,12 @@ class Style(Element):
 
     __names__ = ()
 
+    @classmethod
+    def unpack(cls, attrs: dict[str, Any]):
+        obj = cls()
+        obj._attrs.update(attrs)
+        return obj
+
     def __init__(self, *text: "str | Text | Style"):
         super().__init__()
         self.__call__(*text)
@@ -422,6 +477,12 @@ class Message(Element):
     id: str | None
     forward: bool | None
 
+    @classmethod
+    def unpack(cls, attrs: dict[str, Any]):
+        obj = cls(attrs.get("id"), conv_bool(attrs["forward"]) if "forward" in attrs else None)
+        obj._attrs.update(attrs)
+        return obj
+
     def __init__(
         self,
         id: str | None = None,
@@ -451,6 +512,12 @@ class Author(Element):
     name: str | None = None
     avatar: str | None = None
 
+    @classmethod
+    def unpack(cls, attrs: dict[str, Any]):
+        obj = cls(attrs["id"], attrs.get("name"), attrs.get("avatar"))
+        obj._attrs.update(attrs)
+        return obj
+
 
 @dataclass(repr=False)
 class Button(Element):
@@ -462,6 +529,12 @@ class Button(Element):
     text: str | None = None
     theme: str | None = None
 
+    @classmethod
+    def unpack(cls, attrs: dict[str, Any]):
+        obj = cls(attrs["type"], attrs.get("id"), attrs.get("href"), attrs.get("text"), attrs.get("theme"))
+        obj._attrs.update(attrs)
+        return obj
+
     @classmethod
     def action(cls, button_id: str, theme: str | None = None):
         return Button("action", id=button_id, theme=theme)
@@ -533,7 +606,7 @@ class Raw(Element):
 
     @override
     def dumps(self, strip: bool = False):
-        return self.content if strip else escape(self.content)
+        return self.content
 
 
 def register_element(cls: type[TE], tag: str | None = None) -> type[TE]:
@@ -547,7 +620,7 @@ def register_element(cls: type[TE], tag: str | None = None) -> type[TE]:
     return cls
 
 
-ELEMENT_TYPE_MAP = {
+COMMON_TYPE_MAP = {
     "text": Text,
     "at": At,
     "emoji": Emoji,
@@ -558,6 +631,9 @@ ELEMENT_TYPE_MAP = {
     "video": Video,
     "file": File,
     "author": Author,
+    "button": Button,
+    "a": Link,
+    "link": Link,
 }
 
 STYLE_TYPE_MAP = {
@@ -586,35 +662,32 @@ STYLE_TYPE_MAP = {
     "br": Br,
 }
 
+ELEMENT_TYPE_MAP = {**COMMON_TYPE_MAP, **STYLE_TYPE_MAP}
+
 
 def transform(elements: list[RawElement]) -> list[Element]:
     msg = []
     for elem in elements:
         tag = elem.tag()
         if tag in ELEMENT_TYPE_MAP:
-            seg_cls = ELEMENT_TYPE_MAP[tag]
-            msg.append(seg_cls.unpack(elem.attrs)(*transform(elem.children)))
-        elif tag in ("a", "link"):
-            link = Link.unpack(elem.attrs)
-            if elem.children:
-                link(*transform(elem.children))
-            msg.append(link)
-        elif tag == "button":
-            button = Button.unpack(elem.attrs)
+            seg = ELEMENT_TYPE_MAP[tag].unpack(elem.attrs)
             if elem.children:
-                button(*transform(elem.children))
-            msg.append(button)
-        elif tag in STYLE_TYPE_MAP:
-            seg_cls = STYLE_TYPE_MAP[tag]
-            msg.append(seg_cls.unpack(elem.attrs)(*transform(elem.children)))
-        elif tag in ("br", "newline"):
-            msg.append(Br())
+                seg(*transform(elem.children))
+            msg.append(seg)
         elif tag == "message":
             msg.append(Message.unpack(elem.attrs)(*transform(elem.children)))
         elif tag == "quote":
-            msg.append(Quote.unpack(elem.attrs)(*transform(elem.children)))
+            quot = Quote.unpack(elem.attrs)
+            if elem.children:
+                quot(*transform(elem.children))
+            msg.append(quot)
+        elif tag in ("br", "newline"):
+            msg.append(Br())
         else:
-            msg.append(Custom(elem.type, elem.attrs)(*transform(elem.children)))
+            custom = Custom(tag, elem.attrs)
+            if elem.children:
+                custom(*transform(elem.children))
+            msg.append(custom)
     return msg
 
 

{satori_python_core-1.3.2 → satori_python_core-1.3.4}/src/satori/model.py

@@ -1,6 +1,8 @@
 import mimetypes
+import sys
+import typing
 from collections.abc import AsyncIterable, Awaitable, Callable
-from dataclasses import Field, dataclass, field
+from dataclasses import dataclass, field
 from datetime import datetime
 from enum import IntEnum
 from os import PathLike
@@ -12,17 +14,26 @@ from .element import Element, Emoji, transform
 from .parser import Element as RawElement
 from .parser import parse
 
+if sys.version_info >= (3, 12):
+    _generic_init_subclass = typing._generic_init_subclass
+else:
+    _generic_init_subclass = Generic.__init_subclass__.__func__
 
-@dataclass
+
+@dataclass(slots=True)
 class ModelBase:
     __converter__: ClassVar[dict[str, Callable[[Any], Any]]] = {}
     _raw_data: dict[str, Any] = field(init=False, default_factory=dict, repr=False, compare=False, hash=False)
 
+    @classmethod
+    def before_parse(cls, raw: dict):
+        pass
+
     @classmethod
     def parse(cls: type[Self], raw: dict) -> Self:
-        fs: dict[str, Field] = cls.__dataclass_fields__
         data = {}
-        for name in fs.keys():
+        cls.before_parse(data)
+        for name in cls.__dataclass_fields__:
             if name in raw:
                 if name in cls.__converter__:
                     data[name] = cls.__converter__[name](raw[name])
@@ -32,6 +43,42 @@ class ModelBase:
         obj._raw_data = raw
         return obj
 
+    def __init_subclass__(cls, **kwargs):
+        has_converter = False
+        keys = set()
+        for c in cls.__mro__:
+            if c is Generic:
+                _generic_init_subclass(cls, **kwargs)
+            if getattr(c, "__converter__", None):
+                has_converter = True
+            keys.update(getattr(c, "__annotations__", {}).keys())
+        keys = frozenset(k for k in keys if not k.startswith("_"))
+
+        def parse1(cls_: type[Self], raw: dict, _keys=keys) -> Self:
+            data = {k: v for k, v in raw.items() if k in _keys}
+            obj = cls_(**data)  # type: ignore
+            obj._raw_data = raw
+            return obj
+
+        def parse2(cls_: type[Self], raw: dict, _keys=keys) -> Self:
+            data = {}
+            cls_.before_parse(data)
+            for name in _keys:
+                if name in raw:
+                    if name in cls_.__converter__:
+                        data[name] = cls_.__converter__[name](raw[name])
+                    else:
+                        data[name] = raw[name]
+            obj = cls_(**data)  # type: ignore
+            obj._raw_data = raw
+            return obj
+
+        if "parse" not in cls.__dict__:
+            if has_converter:
+                cls.parse = classmethod(parse2)  # type: ignore
+            else:
+                cls.parse = classmethod(parse1)  # type: ignore
+
     def dump(self) -> dict:
         raise NotImplementedError
 
@@ -43,7 +90,7 @@ class ChannelType(IntEnum):
     VOICE = 3
 
 
-@dataclass
+@dataclass(slots=True)
 class Channel(ModelBase):
     id: str
     type: ChannelType = ChannelType.TEXT
@@ -61,7 +108,7 @@ class Channel(ModelBase):
         return res
 
 
-@dataclass
+@dataclass(slots=True)
 class Guild(ModelBase):
     id: str
     name: str | None = None
@@ -76,7 +123,7 @@ class Guild(ModelBase):
         return res
 
 
-@dataclass
+@dataclass(slots=True)
 class User(ModelBase):
     id: str
     name: str | None = None
@@ -97,7 +144,7 @@ class User(ModelBase):
         return res
 
 
-@dataclass
+@dataclass(slots=True)
 class Friend(ModelBase):
     user: User | None = None
     nick: str | None = None
@@ -117,7 +164,7 @@ class Friend(ModelBase):
         return res
 
 
-@dataclass
+@dataclass(slots=True)
 class Role(ModelBase):
     id: str
     name: str | None = None
@@ -126,7 +173,7 @@ class Role(ModelBase):
     def parse(cls, raw: str | dict):
         if isinstance(raw, str):
             return cls(id=raw)
-        return super().parse(raw)
+        return cls(raw["id"], raw.get("name"))
 
     def dump(self):
         res = {"id": self.id}
@@ -135,7 +182,7 @@ class Role(ModelBase):
         return res
 
 
-@dataclass
+@dataclass(slots=True)
 class Member(ModelBase):
     user: User | None = None
     nick: str | None = None
@@ -177,11 +224,11 @@ class LoginStatus(IntEnum):
     """正在重新连接"""
 
 
-@dataclass
+@dataclass(slots=True, kw_only=True)
 class Login(ModelBase):
-    sn: int
-    status: LoginStatus
-    adapter: str
+    sn: int = 0
+    status: LoginStatus = LoginStatus.ONLINE
+    adapter: str = "satori"
     platform: str
     user: User
     features: list[str] = field(default_factory=list)
@@ -203,29 +250,22 @@ class Login(ModelBase):
         return res
 
     @classmethod
-    def parse(cls, raw: dict):
+    def before_parse(cls, raw: dict):
         if "self_id" in raw and "user" not in raw:
             raw["user"] = {"id": raw["self_id"]}
-        if "sn" not in raw:
-            raw["sn"] = 0
-        if "adapter" not in raw:
-            raw["adapter"] = "satori"
-        if "status" not in raw:
-            raw["status"] = LoginStatus.ONLINE
-        return super().parse(raw)
 
     @property
     def id(self) -> str:
         return self.user.id
 
 
-@dataclass
+@dataclass(slots=True)
 class LoginPartial(Login):
     platform: str | None = None
     user: User | None = None
 
 
-@dataclass
+@dataclass(slots=True)
 class ArgvInteraction(ModelBase):
     name: str
     arguments: list
@@ -235,7 +275,7 @@ class ArgvInteraction(ModelBase):
         return {"name": self.name, "arguments": self.arguments, "options": self.options}
 
 
-@dataclass
+@dataclass(slots=True)
 class ButtonInteraction(ModelBase):
     id: str
     data: str | None = None
@@ -262,7 +302,7 @@ class Opcode(IntEnum):
     """元信息更新 (接收)"""
 
 
-@dataclass
+@dataclass(slots=True)
 class Identify(ModelBase):
     token: str | None = None
     sn: int | None = None
@@ -271,7 +311,7 @@ class Identify(ModelBase):
     def parse(cls, raw: dict):
         if "sequence" in raw and "sn" not in raw:
             raw["sn"] = raw["sequence"]
-        return super().parse(raw)
+        return cls(token=raw.get("token"), sn=raw.get("sn"))
 
     @property
     def sequence(self) -> int | None:
@@ -281,7 +321,7 @@ class Identify(ModelBase):
         return {k: v for k, v in (("token", self.token), ("sn", self.sn)) if v is not None}
 
 
-@dataclass
+@dataclass(slots=True)
 class Ready(ModelBase):
     logins: list[LoginPartial]
     proxy_urls: list[str] = field(default_factory=list)
@@ -292,7 +332,7 @@ class Ready(ModelBase):
         return {"logins": [login.dump() for login in self.logins], "proxy_urls": self.proxy_urls}
 
 
-@dataclass
+@dataclass(slots=True)
 class MetaPayload(ModelBase):
     """Meta 信令"""
 
@@ -302,7 +342,7 @@ class MetaPayload(ModelBase):
         return {"proxy_urls": self.proxy_urls}
 
 
-@dataclass
+@dataclass(slots=True)
 class Meta(ModelBase):
     """Meta 数据"""
 
@@ -315,7 +355,7 @@ class Meta(ModelBase):
         return {"logins": [login.dump() for login in self.logins], "proxy_urls": self.proxy_urls}
 
 
-@dataclass
+@dataclass(slots=True)
 class EmojiObject(ModelBase):
     id: str
     name: str | None = None
@@ -330,7 +370,7 @@ class EmojiObject(ModelBase):
         return Emoji(self.id, self.name)
 
 
-@dataclass
+@dataclass(slots=True)
 class MessageObject(ModelBase):
     id: str
     content: str = ""
@@ -342,6 +382,8 @@ class MessageObject(ModelBase):
     updated_at: datetime | None = None
     referrer: dict | None = None
 
+    _parsed_message: list[Element] | None = field(init=False, default=None, repr=False, compare=False, hash=False)
+
     @classmethod
     def from_elements(
         cls,
@@ -361,10 +403,10 @@ class MessageObject(ModelBase):
 
     @property
     def message(self) -> list[Element]:
-        if hasattr(self, "_parsed_message"):
+        if self._parsed_message is not None:
             return self._parsed_message
-        self._parsed_message = transform(parse(self.content))
-        return self._parsed_message
+        self._parsed_message = msg = transform(parse(self.content))
+        return msg
 
     @message.setter
     def message(self, value: list[Element]):
@@ -372,11 +414,10 @@ class MessageObject(ModelBase):
         self.content = "".join(str(i) for i in value)
 
     @classmethod
-    def parse(cls, raw: dict):
+    def before_parse(cls, raw: dict):
         if "elements" in raw and "content" not in raw:
             content = [RawElement(*item.values()) for item in raw["elements"]]
             raw["content"] = "".join(str(i) for i in content)
-        return super().parse(raw)
 
     __converter__ = {
         "channel": Channel.parse,
@@ -406,7 +447,7 @@ class MessageObject(ModelBase):
         return res
 
 
-@dataclass
+@dataclass(slots=True)
 class Event(ModelBase):
     type: str
     timestamp: datetime
@@ -444,7 +485,7 @@ class Event(ModelBase):
     }
 
     @classmethod
-    def parse(cls, raw: dict):
+    def before_parse(cls, raw: dict):
         if "id" in raw and "sn" not in raw:
             raw["sn"] = raw["id"]
         if "platform" in raw and "self_id" in raw and "login" not in raw:
@@ -458,7 +499,6 @@ class Event(ModelBase):
             if "login" not in raw:
                 raw["login"] = {"sn": 0, "status": LoginStatus.ONLINE, "platform": raw.get("platform", "unknown")}
             raw["login"]["user"] = {"id": raw["self_id"]}
-        return super().parse(raw)
 
     @property
     def platform(self):
@@ -509,7 +549,7 @@ class Event(ModelBase):
 T = TypeVar("T", bound=ModelBase)
 
 
-@dataclass
+@dataclass(slots=True)
 class PageResult(ModelBase, Generic[T]):
     data: list[T]
     next: str | None = None
@@ -526,7 +566,7 @@ class PageResult(ModelBase, Generic[T]):
         return res
 
 
-@dataclass
+@dataclass(slots=True)
 class PageDequeResult(PageResult[T]):
     prev: str | None = None
 
@@ -569,7 +609,7 @@ Direction: TypeAlias = Literal["before", "after", "around"]
 Order: TypeAlias = Literal["asc", "desc"]
 
 
-@dataclass
+@dataclass(slots=True)
 class Upload:
     file: bytes | IO[bytes] | PathLike
     mimetype: str = "image/png"

{satori_python_core-1.3.2 → satori_python_core-1.3.4}/src/satori/parser.py

@@ -12,27 +12,37 @@ def escape(text: str, inline: bool = False) -> str:
     return result.replace('"', """) if inline else result
 
 
+uc_escape_pat1 = re.compile(r"&#(\d+);")
+uc_escape_pat2 = re.compile(r"&#x([0-9a-f]+);")
+uc_escape_pat3 = re.compile(r"&(amp|#38|#x26);")
+
+
 def unescape(text: str) -> str:
     result = text.replace("&lt;", "<").replace("&gt;", ">").replace("&quot;", '"')
-    result = re.sub(r"&#(\d+);", lambda m: m[0] if m[1] == "38" else chr(int(m[1])), result)
-    result = re.sub(r"&#x([0-9a-f]+);", lambda m: m[0] if m[1] == "26" else chr(int(m[1], 16)), result)
-    return re.sub("&(amp|#38|#x26);", "&", result)
+    result = uc_escape_pat1.sub(lambda m: m[0] if m[1] == "38" else chr(int(m[1])), result)
+    result = uc_escape_pat2.sub(lambda m: m[0] if m[1] == "26" else chr(int(m[1], 16)), result)
+    return uc_escape_pat3.sub("&", result)
 
 
 def uncapitalize(source: str) -> str:
-    return source[0].lower() + source[1:]
+    return source[:1].lower() + source[1:]
+
+
+camel_pat = re.compile(r"[_-][a-z]")
+param_pat = re.compile(r".[A-Z]+")
+snake_pat = re.compile(r".[A-Z]")
 
 
 def camel_case(source: str) -> str:
-    return re.sub("[_-][a-z]", lambda mat: mat[0][1:].upper(), source)
+    return camel_pat.sub(lambda mat: mat[0][1:].upper(), source)
 
 
 def param_case(source: str) -> str:
-    return re.sub(".[A-Z]+", lambda mat: mat[0][0] + "-" + mat[0][1:].lower(), uncapitalize(source).replace("_", "-"))
+    return param_pat.sub(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 snake_pat.sub(lambda mat: mat[0][0] + "_" + mat[0][1:].lower(), uncapitalize(source).replace("-", "_"))
 
 
 def ensure_list(value: T | list[T] | None) -> list[T]:
@@ -49,9 +59,9 @@ def make_element(content: Union[str, bool, int, float, "Element"]) -> Optional["
     if isinstance(content, Element):
         return content
     if isinstance(content, (bool, int, float)):
-        return Element(type="text", attrs={"text": str(content)})
+        return Element.parse(type="text", attrs={"text": str(content)})
     if isinstance(content, str) and content:
-        return Element(type="text", attrs={"text": content})
+        return Element.parse(type="text", attrs={"text": content})
     if content is not None:
         raise ValueError(f"Invalid content: {content!r}")
 
@@ -68,7 +78,9 @@ class Element:
     type: str
     attrs: dict[str, Any]
     children: list["Element"]
-    source: str | None = None
+    source: str | None
+
+    __slots__ = ("type", "attrs", "children", "source")
 
     def __init__(
         self,
@@ -99,6 +111,31 @@ class Element:
             elif not self.attrs:
                 self.attrs["text"] = ""
 
+    @classmethod
+    def parse(
+        cls, type: str, attrs: dict[str, Any], children: list["Element"] | None = None, source: str | None = None
+    ) -> "Element":
+        elem = cls.__new__(cls)
+        elem.type = type
+        elem.attrs = {}
+        elem.children = []
+        elem.source = source
+        for k, v in attrs.items():
+            if v is None:
+                continue
+            if k == "children":
+                elem.children.extend(ensure_list(v))
+            else:
+                elem.attrs[camel_case(k)] = v
+        if children:
+            elem.children.extend(children)
+        if type == "text":
+            if "content" in elem.attrs:
+                elem.attrs["text"] = elem.attrs.pop("content")
+            elif not elem.attrs:
+                elem.attrs["text"] = ""
+        return elem
+
     def tag(self):
         if self.type == "component":
             if is_ := self.attrs.get("is"):
@@ -234,6 +271,9 @@ tag_pat2 = re.compile(
 attr_pat1 = re.compile(r"([^\s=]+)(?:=\"(?P<value1>[^\"]*)\"|='(?P<value2>[^']*)')?", re.S)
 attr_pat2 = re.compile(r"([^\s=]+)(?:=\"(?P<value1>[^\"]*)\"|='(?P<value2>[^']*)'|=\{(?P<curly>[^\}]+)\})?", re.S)
 
+space_pat1 = re.compile(r"^\s*\n\s*", re.MULTILINE)
+space_pat2 = re.compile(r"\s*\n\s*$", re.MULTILINE)
+
 
 class Position(IntEnum):
     OPEN = 0
@@ -242,7 +282,7 @@ class Position(IntEnum):
     CONTINUE = 3
 
 
-@dataclass
+@dataclass(slots=True)
 class Token:
     type: Literal["angle", "curly"]
     name: str
@@ -299,7 +339,7 @@ def parse_tokens(tokens: list[str | Token], context: dict | None = None) -> list
     result: list[Element] = []
     for token in tokens:
         if isinstance(token, str):
-            result.append(Element(type="text", attrs={"text": token}))
+            result.append(Element.parse(type="text", attrs={"text": token}))
         elif token.type == "angle":
             attrs = {}
             attr_pat = attr_pat2 if context is not None else attr_pat1
@@ -318,10 +358,10 @@ def parse_tokens(tokens: list[str | Token], context: dict | None = None) -> list
                     attrs[key] = True
                 token.extra = token.extra[mat.end() :]
             result.append(
-                Element(
+                Element.parse(
                     token.name,
                     attrs,
-                    *parse_tokens(token.children["default"], context) if token.children else [],
+                    parse_tokens(token.children["default"], context) if token.children else [],
                 )
             )
         elif not token.name:
@@ -351,9 +391,9 @@ def parse(src: str, context: dict | None = None):
     def parse_content(source: str, _start: bool, _end: bool):
         source = unescape(source)
         if _start:
-            source = re.sub(r"^\s*\n\s*", "", source, flags=re.MULTILINE)
+            source = space_pat1.sub("", source)
         if _end:
-            source = re.sub(r"\s*\n\s*$", "", source, flags=re.MULTILINE)
+            source = space_pat2.sub("", source)
         push_text(source)
 
     tag_pat = tag_pat2 if context is not None else tag_pat1

{satori_python_core-1.3.2 → satori_python_core-1.3.4}/src/satori/utils.py

@@ -24,10 +24,16 @@ try:
     def encode(obj):
         return encoder.encode(obj).decode()
 
+    def encode_bytes(obj):
+        return encoder.encode(obj)
+
 except ImportError:
     import json
 
     def encode(obj):
         return json.dumps(obj, separators=(",", ":"), ensure_ascii=False)
 
+    def encode_bytes(obj):
+        return json.dumps(obj, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+
     decode = json.loads