satori-python-core 0.13.2__tar.gz → 0.14.0__tar.gz

{satori_python_core-0.13.2 → satori_python_core-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: satori-python-core
-Version: 0.13.2
+Version: 0.14.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>

{satori_python_core-0.13.2 → satori_python_core-0.14.0}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Operating System :: OS Independent",
 ]
-version = "0.13.2"
+version = "0.14.0"
 
 [project.license]
 text = "MIT"
@@ -85,7 +85,7 @@ extra_standard_library = [
 
 [tool.ruff]
 line-length = 110
-target-version = "py38"
+target-version = "py39"
 exclude = [
     "exam.py",
 ]
@@ -110,7 +110,7 @@ ignore = [
 
 [tool.pyright]
 pythonPlatform = "All"
-pythonVersion = "3.8"
+pythonVersion = "3.9"
 typeCheckingMode = "basic"
 reportShadowedImports = false
 disableBytesTypePromotions = true

{satori_python_core-0.13.2 → satori_python_core-0.14.0}/src/satori/__init__.py

@@ -43,4 +43,4 @@ from .model import Role as Role
 from .model import Upload as Upload
 from .model import User as User
 
-__version__ = "0.13.2"
+__version__ = "0.14.0"

{satori_python_core-0.13.2 → satori_python_core-0.14.0}/src/satori/element.py

@@ -2,7 +2,7 @@ from base64 import b64encode
 from dataclasses import InitVar, dataclass, field, fields
 from io import BytesIO
 from pathlib import Path
-from typing import Any, ClassVar, Dict, List, Optional, Tuple, Type, TypeVar, Union, get_args, overload
+from typing import Any, ClassVar, Optional, TypeVar, Union, get_args, overload
 from typing_extensions import override
 
 from .parser import Element as RawElement
@@ -14,13 +14,13 @@ TE = TypeVar("TE", bound="Element")
 
 @dataclass(repr=False)
 class Element:
-    _attrs: Dict[str, Any] = field(init=False, default_factory=dict)
-    _children: List["Element"] = field(init=False, default_factory=list)
+    _attrs: dict[str, Any] = field(init=False, default_factory=dict)
+    _children: list["Element"] = field(init=False, default_factory=list)
 
-    __names__: ClassVar[Tuple[str, ...]]
+    __names__: ClassVar[tuple[str, ...]]
 
     @property
-    def children(self) -> List["Element"]:
+    def children(self) -> list["Element"]:
         return self._children
 
     @property
@@ -28,7 +28,7 @@ class Element:
         return self.__class__.__name__.lower()
 
     @classmethod
-    def unpack(cls, attrs: Dict[str, Any]):
+    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__})
         return obj
@@ -166,7 +166,7 @@ class Link(Element):
 class Resource(Element):
     src: str
     title: Optional[str] = None
-    extra: InitVar[Optional[Dict[str, Any]]] = None
+    extra: InitVar[Optional[dict[str, Any]]] = None
     cache: Optional[bool] = None
     timeout: Optional[int] = None
 
@@ -181,19 +181,19 @@ class Resource(Element):
         mime: Optional[str] = None,
         name: Optional[str] = None,
         poster: Optional[str] = None,
-        extra: Optional[Dict[str, Any]] = None,
+        extra: Optional[dict[str, Any]] = None,
         cache: Optional[bool] = None,
         timeout: Optional[int] = None,
         **kwargs,
     ):
-        data: Dict[str, Any] = {"extra": extra}
+        data: dict[str, Any] = {"extra": extra or kwargs}
         if url is not None:
-            data = {"src": url}
+            data |= {"src": url}
         elif path:
-            data = {"src": Path(path).as_uri()}
+            data |= {"src": Path(path).as_uri()}
         elif raw and mime:
             bd = raw.getvalue() if isinstance(raw, BytesIO) else raw
-            data = {"src": f"data:{mime};base64,{b64encode(bd).decode('utf-8')}"}
+            data |= {"src": f"data:{mime};base64,{b64encode(bd).decode('utf-8')}"}
         else:
             raise ValueError(f"{cls} need at least one of url, path and raw")
         if name is not None:
@@ -206,7 +206,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: Optional[dict[str, Any]] = None):
         super().__post_init__()
         if extra:
             self._attrs.update(extra)
@@ -380,7 +380,7 @@ class Message(Element):
         self,
         id: Optional[str] = None,
         forward: Optional[bool] = None,
-        content: Optional[List[Union[str, Element]]] = None,
+        content: Optional[list[Union[str, Element]]] = None,
     ):
         self.id = id
         self.forward = forward
@@ -464,8 +464,8 @@ class Custom(Element):
     def __init__(
         self,
         type: str,
-        attrs: Optional[Dict[str, Any]] = None,
-        children: Optional[List[Union[str, Element]]] = None,
+        attrs: Optional[dict[str, Any]] = None,
+        children: Optional[list[Union[str, Element]]] = None,
     ):
         self.type = type
         super().__init__()
@@ -536,7 +536,7 @@ STYLE_TYPE_MAP = {
 }
 
 
-def transform(elements: List[RawElement]) -> List[Element]:
+def transform(elements: list[RawElement]) -> list[Element]:
     msg = []
     for elem in elements:
         tag = elem.tag()
@@ -568,14 +568,14 @@ def transform(elements: List[RawElement]) -> List[Element]:
 
 
 @overload
-def select(elements: Union[Element, List[Element]], query: Type[TE]) -> List[TE]: ...
+def select(elements: Union[Element, list[Element]], query: type[TE]) -> list[TE]: ...
 
 
 @overload
-def select(elements: Union[Element, List[Element]], query: str) -> List[Element]: ...
+def select(elements: Union[Element, list[Element]], query: str) -> list[Element]: ...
 
 
-def select(elements: Union[Element, List[Element]], query: Union[Type[TE], str]):
+def select(elements: Union[Element, list[Element]], query: Union[type[TE], str]):
     if not elements:
         return []
     if isinstance(elements, Element):

{satori_python_core-0.13.2 → satori_python_core-0.14.0}/src/satori/model.py

@@ -4,7 +4,7 @@ from datetime import datetime
 from enum import IntEnum
 from os import PathLike
 from pathlib import Path
-from typing import IO, Any, Callable, ClassVar, Dict, Generic, List, Literal, Optional, TypeVar, Union
+from typing import IO, Any, Callable, ClassVar, Generic, Literal, Optional, TypeVar, Union
 from typing_extensions import TypeAlias
 
 from .element import Element, transform
@@ -14,7 +14,7 @@ from .parser import parse
 
 @dataclass
 class ModelBase:
-    __converter__: ClassVar[Dict[str, Callable[[Any], Any]]] = {}
+    __converter__: ClassVar[dict[str, Callable[[Any], Any]]] = {}
 
     @classmethod
     def parse(cls, raw: dict):
@@ -81,7 +81,7 @@ class User(ModelBase):
     is_bot: Optional[bool] = None
 
     def dump(self):
-        res: Dict[str, Any] = {"id": self.id}
+        res: dict[str, Any] = {"id": self.id}
         if self.name:
             res["name"] = self.name
         if self.nick:
@@ -141,13 +141,13 @@ 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)
+    features: list[str] = field(default_factory=list)
+    proxy_urls: list[str] = field(default_factory=list)
 
     __converter__ = {"user": User.parse, "status": LoginStatus}
 
     def dump(self):
-        res: Dict[str, Any] = {
+        res: dict[str, Any] = {
             "status": self.status.value,
             "features": self.features,
             "proxy_urls": self.proxy_urls,
@@ -195,7 +195,7 @@ class Identify(ModelBase):
 
 @dataclass
 class Ready(ModelBase):
-    logins: List[Login]
+    logins: list[Login]
 
 
 @dataclass
@@ -213,7 +213,7 @@ class MessageObject(ModelBase):
     def from_elements(
         cls,
         id: str,
-        content: List[Element],
+        content: list[Element],
         channel: Optional[Channel] = None,
         guild: Optional[Guild] = None,
         member: Optional[Member] = None,
@@ -224,7 +224,7 @@ class MessageObject(ModelBase):
         return cls(id, "".join(str(i) for i in content), channel, guild, member, user, created_at, updated_at)
 
     @property
-    def message(self) -> List[Element]:
+    def message(self) -> list[Element]:
         return transform(parse(self.content))
 
     @classmethod
@@ -244,7 +244,7 @@ class MessageObject(ModelBase):
     }
 
     def dump(self):
-        res: Dict[str, Any] = {"id": self.id, "content": self.content}
+        res: dict[str, Any] = {"id": self.id, "content": self.content}
         if self.channel:
             res["channel"] = self.channel.dump()
         if self.guild:
@@ -335,7 +335,7 @@ T = TypeVar("T", bound=ModelBase)
 
 @dataclass
 class PageResult(ModelBase, Generic[T]):
-    data: List[T]
+    data: list[T]
     next: Optional[str] = None
 
     @classmethod

{satori_python_core-0.13.2 → satori_python_core-0.14.0}/src/satori/parser.py

@@ -1,7 +1,8 @@
 import re
+from collections.abc import Iterable
 from dataclasses import dataclass, field
 from enum import IntEnum
-from typing import Any, Callable, Dict, Iterable, List, Literal, Optional, TypedDict, TypeVar, Union, cast
+from typing import Any, Callable, Literal, Optional, TypedDict, TypeVar, Union, cast
 from typing_extensions import TypeAlias
 
 T = TypeVar("T")
@@ -39,13 +40,13 @@ def snake_case(source: str) -> str:
     )
 
 
-def ensure_list(value: Union[T, List[T], None]) -> List[T]:
+def ensure_list(value: Union[T, list[T], None]) -> list[T]:
     return value if isinstance(value, list) else [value] if value else []
 
 
 S = TypeVar("S")
-Fragment: TypeAlias = Union[str, "Element", List[Union[str, "Element"]]]
-Render: TypeAlias = Callable[[dict, List["Element"], S], T]
+Fragment: TypeAlias = Union[str, "Element", list[Union[str, "Element"]]]
+Render: TypeAlias = Callable[[dict, list["Element"], S], T]
 Visitor: TypeAlias = Callable[["Element", S], T]
 
 
@@ -60,7 +61,7 @@ def make_element(content: Union[str, bool, int, float, "Element"]) -> Optional["
         raise ValueError(f"Invalid content: {content!r}")
 
 
-def make_elements(content: Fragment) -> List["Element"]:
+def make_elements(content: Fragment) -> list["Element"]:
     if isinstance(content, list):
         res = [make_element(c) for c in content]
     else:
@@ -70,14 +71,14 @@ def make_elements(content: Fragment) -> List["Element"]:
 
 class Element:
     type: str
-    attrs: Dict[str, Any]
-    children: List["Element"]
+    attrs: dict[str, Any]
+    children: list["Element"]
     source: Optional[str] = None
 
     def __init__(
         self,
         type: Union[str, Render[Fragment, Any]],
-        attrs: Optional[Dict[str, Any]] = None,
+        attrs: Optional[dict[str, Any]] = None,
         *children: Fragment,
     ) -> None:
         self.attrs = {}
@@ -97,8 +98,11 @@ 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")
+        if self.tag() == "text":
+            if "content" in self.attrs:
+                self.attrs["text"] = self.attrs.pop("content")
+            elif not self.attrs:
+                self.attrs["text"] = ""
 
     def tag(self):
         if self.type == "component":
@@ -151,8 +155,8 @@ class Selector:
 comb_pat = re.compile(" *([ >+~]) *")
 
 
-def parse_selector(input: str) -> List[List[Selector]]:
-    def _quert(query: str) -> List[Selector]:
+def parse_selector(input: str) -> list[list[Selector]]:
+    def _quert(query: str) -> list[Selector]:
         selectors = []
         combinator = " "
         while mat := comb_pat.search(query):
@@ -170,7 +174,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: Union[str, list[Element]], query: Union[str, list[list[Selector]]]) -> list[Element]:
     if not source or not query:
         return []
     if isinstance(source, str):
@@ -179,10 +183,10 @@ def select(source: Union[str, List[Element]], query: Union[str, List[List[Select
         query = parse_selector(query)
     if not query:
         return []
-    adjacent: List[List[Selector]] = []
+    adjacent: list[list[Selector]] = []
     results = []
     for index, elem in enumerate(source):
-        inner: List[List[Selector]] = []
+        inner: list[list[Selector]] = []
         local = [*query, *adjacent]
         adjacent = []
         matched = False
@@ -252,7 +256,7 @@ class Token:
     positon: Position
     source: str
     extra: str
-    children: Dict[str, List[Union[str, "Token"]]] = field(default_factory=dict)
+    children: dict[str, list[Union[str, "Token"]]] = field(default_factory=dict)
 
 
 class StackItem(TypedDict):
@@ -260,8 +264,8 @@ class StackItem(TypedDict):
     slot: str
 
 
-def fold_tokens(tokens: List[Union[str, Token]]) -> List[Union[str, Token]]:
-    stack: List[StackItem] = [
+def fold_tokens(tokens: list[Union[str, Token]]) -> list[Union[str, Token]]:
+    stack: list[StackItem] = [
         {
             "token": Token(
                 type="angle",
@@ -298,8 +302,8 @@ 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]:
-    result: List[Element] = []
+def parse_tokens(tokens: list[Union[str, Token]], context: Optional[dict] = None) -> list[Element]:
+    result: list[Element] = []
     for token in tokens:
         if isinstance(token, str):
             result.append(Element(type="text", attrs={"text": token}))
@@ -345,7 +349,7 @@ def parse_tokens(tokens: List[Union[str, Token]], context: Optional[dict] = None
 
 
 def parse(src: str, context: Optional[dict] = None):
-    tokens: List[Union[str, Token]] = []
+    tokens: list[Union[str, Token]] = []
 
     def push_text(text: str):
         if text: