satori-python-core 0.11.4__tar.gz → 0.12.0__tar.gz

{satori_python_core-0.11.4 → satori_python_core-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satori-python-core
-Version: 0.11.4
+Version: 0.12.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>
@@ -19,7 +19,7 @@ Project-URL: Repository, https://github.com/RF-Tar-Railt/satori-python
 Requires-Python: >=3.8
 Requires-Dist: loguru>=0.7.2
 Requires-Dist: yarl>=1.9.4
-Requires-Dist: typing-extensions>=4.10.0
+Requires-Dist: typing-extensions>=4.7.0
 Description-Content-Type: text/markdown
 
 # satori-python

{satori_python_core-0.11.4 → satori_python_core-0.12.0}/pyproject.toml

@@ -7,7 +7,7 @@ authors = [
 dependencies = [
     "loguru>=0.7.2",
     "yarl>=1.9.4",
-    "typing-extensions>=4.10.0",
+    "typing-extensions>=4.7.0",
 ]
 description = "Satori Protocol SDK for python, specify common part"
 readme = "README.md"
@@ -23,7 +23,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Operating System :: OS Independent",
 ]
-version = "0.11.4"
+version = "0.12.0"
 
 [project.license]
 text = "MIT"
@@ -41,9 +41,9 @@ build-backend = "mina.backend"
 [tool.pdm.dev-dependencies]
 dev = [
     "isort>=5.13.2",
-    "black>=24.2.0",
-    "ruff>=0.3.2",
-    "pre-commit>=3.6.2",
+    "black>=24.4.0",
+    "ruff>=0.4.1",
+    "pre-commit>=3.7.0",
     "fix-future-annotations>=0.5.0",
     "mina-build<0.6,>=0.5.1",
     "pdm-mina>=0.3.2",

{satori_python_core-0.11.4 → satori_python_core-0.12.0}/src/satori/__init__.py

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

{satori_python_core-0.11.4 → satori_python_core-0.12.0}/src/satori/element.py

@@ -18,13 +18,17 @@ class Element:
 
     __names__: ClassVar[Tuple[str, ...]]
 
+    @property
+    def children(self) -> List["Element"]:
+        return self._children
+
     @property
     def tag(self) -> str:
         return self.__class__.__name__.lower()
 
     @classmethod
     def unpack(cls, attrs: Dict[str, Any]):
-        obj = cls(**{k: v for k, v in attrs.items() if k in cls.__names__})
+        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__})
         return obj
 
@@ -132,7 +136,7 @@ class Sharp(Element):
     name: Optional[str] = None
 
 
-@dataclass
+@dataclass(repr=False)
 class Link(Element):
     """<a> 元素用于显示一个链接。"""
 
@@ -163,7 +167,7 @@ class Resource(Element):
     title: Optional[str] = None
     extra: InitVar[Optional[Dict[str, Any]]] = None
     cache: Optional[bool] = None
-    timeout: Optional[str] = None
+    timeout: Optional[int] = None
 
     __names__ = ("src", "title")
 
@@ -178,7 +182,7 @@ class Resource(Element):
         poster: Optional[str] = None,
         extra: Optional[Dict[str, Any]] = None,
         cache: Optional[bool] = None,
-        timeout: Optional[str] = None,
+        timeout: Optional[int] = None,
         **kwargs,
     ):
         data: Dict[str, Any] = {"extra": extra}
@@ -537,7 +541,7 @@ def transform(elements: List[RawElement]) -> List[Element]:
         tag = elem.tag()
         if tag in ELEMENT_TYPE_MAP:
             seg_cls = ELEMENT_TYPE_MAP[tag]
-            msg.append(seg_cls.unpack(elem.attrs))
+            msg.append(seg_cls.unpack(elem.attrs)(*transform(elem.children)))
         elif tag in ("a", "link"):
             link = Link.unpack(elem.attrs)
             if elem.children:
@@ -547,6 +551,7 @@ def transform(elements: List[RawElement]) -> List[Element]:
             button = Button.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)))

{satori_python_core-0.11.4 → satori_python_core-0.12.0}/src/satori/model.py

@@ -1,16 +1,29 @@
-from dataclasses import asdict, dataclass
+from dataclasses import asdict, dataclass, field, fields
 from datetime import datetime
 from enum import IntEnum
-from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar
+from typing import Any, Callable, ClassVar, Dict, Generic, List, Literal, Optional, TypeVar
+from typing_extensions import TypeAlias
 
 from .element import Element, transform
+from .parser import Element as RawElement
 from .parser import parse
 
 
+@dataclass
 class ModelBase:
+    __converter__: ClassVar[Dict[str, Callable[[Any], Any]]] = {}
+
     @classmethod
     def parse(cls, raw: dict):
-        raise NotImplementedError
+        fs = fields(cls)
+        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])
+                else:
+                    data[fd.name] = raw[fd.name]
+        return cls(**data)  # type: ignore
 
     def dump(self) -> dict:
         raise NotImplementedError
@@ -30,11 +43,7 @@ class Channel(ModelBase):
     name: Optional[str] = None
     parent_id: Optional[str] = None
 
-    @classmethod
-    def parse(cls, raw: dict):
-        data = raw.copy()
-        data["type"] = ChannelType(raw["type"])
-        return cls(**data)
+    __converter__ = {"type": ChannelType}
 
     def dump(self):
         res = {"id": self.id, "type": self.type.value}
@@ -51,10 +60,6 @@ class Guild(ModelBase):
     name: Optional[str] = None
     avatar: Optional[str] = None
 
-    @classmethod
-    def parse(cls, raw: dict):
-        return cls(**raw)
-
     def dump(self):
         res = {"id": self.id}
         if self.name:
@@ -72,10 +77,6 @@ class User(ModelBase):
     avatar: Optional[str] = None
     is_bot: Optional[bool] = None
 
-    @classmethod
-    def parse(cls, raw: dict):
-        return cls(**raw)
-
     def dump(self):
         res: Dict[str, Any] = {"id": self.id}
         if self.name:
@@ -93,25 +94,17 @@ class User(ModelBase):
 class Member(ModelBase):
     user: Optional[User] = None
     nick: Optional[str] = None
-    name: Optional[str] = None
     avatar: Optional[str] = None
     joined_at: Optional[datetime] = None
 
-    @classmethod
-    def parse(cls, raw: dict):
-        data = raw.copy()
-        if "user" in raw:
-            data["user"] = User.parse(raw["user"])
-        if "joined_at" in raw:
-            data["joined_at"] = datetime.fromtimestamp(int(raw["joined_at"]) / 1000)
-        return cls(**data)
+    __converter__ = {"user": User.parse, "joined_at": lambda ts: datetime.fromtimestamp(int(ts) / 1000)}
 
     def dump(self):
         res = {}
         if self.user:
             res["user"] = self.user.dump()
-        if self.nick or self.name:
-            res["nick"] = self.nick or self.name
+        if self.nick:
+            res["nick"] = self.nick
         if self.avatar:
             res["avatar"] = self.avatar
         if self.joined_at:
@@ -124,10 +117,6 @@ class Role(ModelBase):
     id: str
     name: Optional[str] = None
 
-    @classmethod
-    def parse(cls, raw: dict):
-        return cls(**raw)
-
     def dump(self):
         res = {"id": self.id}
         if self.name:
@@ -149,17 +138,17 @@ class Login(ModelBase):
     user: Optional[User] = None
     self_id: Optional[str] = None
     platform: Optional[str] = None
+    features: List[str] = field(default_factory=list)
+    proxy_urls: List[str] = field(default_factory=list)
 
-    @classmethod
-    def parse(cls, raw: dict):
-        data = raw.copy()
-        if "user" in raw:
-            data["user"] = User(**raw["user"])
-        data["status"] = LoginStatus(data["status"])
-        return cls(**data)
+    __converter__ = {"user": User.parse, "status": LoginStatus}
 
     def dump(self):
-        res: Dict[str, Any] = {"status": self.status.value}
+        res: Dict[str, Any] = {
+            "status": self.status.value,
+            "features": self.features,
+            "proxy_urls": self.proxy_urls,
+        }
         if self.user:
             res["user"] = self.user.dump()
         if self.self_id:
@@ -175,10 +164,6 @@ class ArgvInteraction(ModelBase):
     arguments: list
     options: Any
 
-    @classmethod
-    def parse(cls, raw: dict):
-        return cls(**raw)
-
     def dump(self):
         return asdict(self)
 
@@ -187,10 +172,6 @@ class ArgvInteraction(ModelBase):
 class ButtonInteraction(ModelBase):
     id: str
 
-    @classmethod
-    def parse(cls, raw: dict):
-        return cls(**raw)
-
     def dump(self):
         return asdict(self)
 
@@ -245,23 +226,19 @@ class MessageObject(ModelBase):
 
     @classmethod
     def parse(cls, raw: dict):
-        data = {
-            "id": raw["id"],
-            "content": raw["content"],
-        }
-        if "channel" in raw:
-            data["channel"] = Channel.parse(raw["channel"])
-        if "guild" in raw:
-            data["guild"] = Guild.parse(raw["guild"])
-        if "member" in raw:
-            data["member"] = Member.parse(raw["member"])
-        if "user" in raw:
-            data["user"] = User.parse(raw["user"])
-        if "created_at" in raw:
-            data["created_at"] = datetime.fromtimestamp(int(raw["created_at"]) / 1000)
-        if "updated_at" in raw:
-            data["updated_at"] = datetime.fromtimestamp(int(raw["updated_at"]) / 1000)
-        return cls(**data)
+        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,
+        "guild": Guild.parse,
+        "member": Member.parse,
+        "user": User.parse,
+        "created_at": lambda ts: datetime.fromtimestamp(int(ts) / 1000),
+        "updated_at": lambda ts: datetime.fromtimestamp(int(ts) / 1000),
+    }
 
     def dump(self):
         res: Dict[str, Any] = {"id": self.id, "content": self.content}
@@ -281,7 +258,7 @@ class MessageObject(ModelBase):
 
 
 @dataclass
-class Event:
+class Event(ModelBase):
     id: int
     type: str
     platform: str
@@ -301,40 +278,19 @@ class Event:
     _type: Optional[str] = None
     _data: Optional[dict] = None
 
-    @classmethod
-    def parse(cls, raw: dict):
-        data = {
-            "id": raw["id"],
-            "type": raw["type"],
-            "platform": raw["platform"],
-            "self_id": raw["self_id"],
-            "timestamp": datetime.fromtimestamp(int(raw["timestamp"]) / 1000),
-        }
-        if "argv" in raw:
-            data["argv"] = ArgvInteraction.parse(raw["argv"])
-        if "button" in raw:
-            data["button"] = ButtonInteraction.parse(raw["button"])
-        if "channel" in raw:
-            data["channel"] = Channel.parse(raw["channel"])
-        if "guild" in raw:
-            data["guild"] = Guild.parse(raw["guild"])
-        if "login" in raw:
-            data["login"] = Login.parse(raw["login"])
-        if "member" in raw:
-            data["member"] = Member.parse(raw["member"])
-        if "message" in raw:
-            data["message"] = MessageObject.parse(raw["message"])
-        if "operator" in raw:
-            data["operator"] = User.parse(raw["operator"])
-        if "role" in raw:
-            data["role"] = Role.parse(raw["role"])
-        if "user" in raw:
-            data["user"] = User.parse(raw["user"])
-        if "_type" in raw:
-            data["_type"] = raw["_type"]
-        if "_data" in raw:
-            data["_data"] = raw["_data"]
-        return cls(**data)
+    __converter__ = {
+        "timestamp": lambda ts: datetime.fromtimestamp(int(ts) / 1000),
+        "argv": ArgvInteraction.parse,
+        "button": ButtonInteraction.parse,
+        "channel": Channel.parse,
+        "guild": Guild.parse,
+        "login": Login.parse,
+        "member": Member.parse,
+        "message": MessageObject.parse,
+        "operator": User.parse,
+        "role": Role.parse,
+        "user": User.parse,
+    }
 
     def dump(self):
         res = {
@@ -380,8 +336,8 @@ class PageResult(ModelBase, Generic[T]):
     next: Optional[str] = None
 
     @classmethod
-    def parse(cls, raw: dict, parser: Callable[[dict], T]) -> "PageResult[T]":
-        data = [parser(item) for item in raw["data"]]
+    def parse(cls, raw: dict, parser: Optional[Callable[[dict], T]] = None) -> "PageResult[T]":
+        data = [(parser or ModelBase.parse)(item) for item in raw["data"]]
         return cls(data, raw.get("next"))
 
     def dump(self):
@@ -389,3 +345,25 @@ class PageResult(ModelBase, Generic[T]):
         if self.next:
             res["next"] = self.next
         return res
+
+
+@dataclass
+class PageDequeResult(PageResult[T]):
+    prev: Optional[str] = None
+
+    @classmethod
+    def parse(cls, raw: dict, parser: Optional[Callable[[dict], T]] = None) -> "PageDequeResult[T]":
+        data = [(parser or ModelBase.parse)(item) for item in raw["data"]]
+        return cls(data, raw.get("next"), raw.get("prev"))
+
+    def dump(self):
+        res: dict = {"data": [item.dump() for item in self.data]}
+        if self.next:
+            res["next"] = self.next
+        if self.prev:
+            res["prev"] = self.prev
+        return res
+
+
+Direction: TypeAlias = Literal["before", "after", "around"]
+Order: TypeAlias = Literal["asc", "desc"]

{satori_python_core-0.11.4 → satori_python_core-0.12.0}/src/satori/parser.py

@@ -97,6 +97,8 @@ class Element:
             self.attrs["is"] = type
         else:
             self.type = type
+        if self.tag() == "text" and "content" in self.attrs:
+            self.attrs["text"] = self.attrs.pop("content")
 
     def tag(self):
         if self.type == "component":