qq-botpy-sdk 2.1.2__tar.gz → 2.2.0__tar.gz

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qq-botpy-sdk
-Version: 2.1.2
+Version: 2.2.0
 Summary: Community-maintained async Python SDK for the QQ Bot Open Platform
 Author: Teahouse Studios
 License: MIT License
@@ -494,7 +494,7 @@ client = MyClient(
 
 | 文档 | 内容 |
 | --- | --- |
-| [API 参考](./docs/API.md) | 新高层接口、统一发送、媒体、REST 和 Interaction |
+| [API 参考](./docs/API.md) | 新高层接口、统一发送、媒体、素材管理、REST 和 Interaction |
 | [自定义菜单与指令面板](./docs/MENU_PANEL.md) | 声明式 Menu/Panel、启动同步和多副本部署风险 |
 | [群管理 API 与事件](./docs/GROUP_MANAGEMENT.md) | 群信息、群成员管理、入群审批、成员禁言、自动审批策略和群成员事件 |
 | [请求整流与接口限速](./docs/RATE_LIMITS.md) | 通道划分、文档核对后的接口配额表和整流配置 |

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/README.md

@@ -448,7 +448,7 @@ client = MyClient(
 
 | 文档 | 内容 |
 | --- | --- |
-| [API 参考](./docs/API.md) | 新高层接口、统一发送、媒体、REST 和 Interaction |
+| [API 参考](./docs/API.md) | 新高层接口、统一发送、媒体、素材管理、REST 和 Interaction |
 | [自定义菜单与指令面板](./docs/MENU_PANEL.md) | 声明式 Menu/Panel、启动同步和多副本部署风险 |
 | [群管理 API 与事件](./docs/GROUP_MANAGEMENT.md) | 群信息、群成员管理、入群审批、成员禁言、自动审批策略和群成员事件 |
 | [请求整流与接口限速](./docs/RATE_LIMITS.md) | 通道划分、文档核对后的接口配额表和整流配置 |

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/botpy/api.py

@@ -25,8 +25,11 @@ from .types import (
     group,
     menu,
     panel,
+    media_image,
 )
 
+from .types.media_image import MEDIA_IMAGE_CONTENT_TYPES, MEDIA_IMAGE_MAX_SIZE
+
 
 def _bounded_list(value: Sequence[Any], name: str, maximum: int) -> List[Any]:
     if isinstance(value, (str, bytes, bytearray)) or not isinstance(value, Sequence):
@@ -182,6 +185,21 @@ def _validate_panel(value: Mapping[str, Any]) -> Dict[str, Any]:
     return result
 
 
+_HEX_DIGITS = frozenset("0123456789abcdefABCDEF")
+
+
+def _validate_digest(value: Any, name: str, length: int) -> str:
+    if not isinstance(value, str) or len(value) != length or any(character not in _HEX_DIGITS for character in value):
+        raise ValueError(f"{name} must be a {length}-character hexadecimal string")
+    return value.lower()
+
+
+def _validate_media_image_content_type(content_type: Any) -> str:
+    if content_type not in MEDIA_IMAGE_CONTENT_TYPES:
+        raise ValueError("content_type must be 'image/png', 'image/jpeg', 'image/gif' or 'image/webp'")
+    return content_type
+
+
 def _validate_panel_scope(scope: str) -> str:
     if scope not in {"c2c", "group", "channel", "dm"}:
         raise ValueError("scope must be 'c2c', 'group', 'channel', or 'dm'")
@@ -2575,3 +2593,103 @@ class BotAPI:
         if srv_send_msg:
             return await self._request_message(route, json=payload, timeout=120)
         return await self._http.request(route, json=payload, timeout=120)
+
+    async def post_media_image_prepare(
+        self,
+        *,
+        file_name: str,
+        file_size: int,
+        content_type: str,
+        md5: str,
+        sha1: str,
+    ) -> media_image.MediaImagePrepareResponse:
+        """申请一张素材图片的上传，返回预签名直传地址。
+
+        ``file_name`` 的扩展名必须与 ``content_type`` 一致；``md5`` 与 ``sha1``
+        为文件内容的十六进制摘要，平台用它们登记上传任务。
+        """
+
+        _required_text(file_name, "file_name")
+        if "." not in file_name:
+            raise ValueError("file_name must include an extension")
+        if isinstance(file_size, bool) or not isinstance(file_size, int) or file_size <= 0:
+            raise ValueError("file_size must be a positive integer")
+        if file_size > MEDIA_IMAGE_MAX_SIZE:
+            raise ValueError(f"file_size must not exceed {MEDIA_IMAGE_MAX_SIZE} bytes")
+        _validate_media_image_content_type(content_type)
+        _validate_digest(md5, "md5", 32)
+        _validate_digest(sha1, "sha1", 40)
+
+        payload = {
+            "file_name": file_name,
+            "file_size": file_size,
+            "content_type": content_type,
+            "md5": md5.lower(),
+            "sha1": sha1.lower(),
+        }
+        route = Route("POST", "/v2/media-images/prepare")
+        return await self._http.request(route, json=payload, timeout=120)
+
+    async def put_media_image(
+        self,
+        presigned_url: str,
+        data: bytes,
+        *,
+        content_type: str,
+        timeout: float = 300,
+    ):
+        """把图片二进制 PUT 到 ``prepare`` 返回的预签名地址。
+
+        ``Content-Type`` 必须与 prepare 声明值完全一致，否则 COS 会拒绝（403）。
+        """
+
+        _validate_https_url(presigned_url, "presigned_url")
+        if not isinstance(data, bytes):
+            raise TypeError("data must be bytes")
+        if not data:
+            raise ValueError("data must not be empty")
+        if len(data) > MEDIA_IMAGE_MAX_SIZE:
+            raise ValueError(f"data must not exceed {MEDIA_IMAGE_MAX_SIZE} bytes")
+        _validate_media_image_content_type(content_type)
+        if isinstance(timeout, bool) or not isinstance(timeout, (int, float)) or timeout <= 0:
+            raise ValueError("timeout must be a positive number")
+
+        return await self._http.request_url(
+            "PUT",
+            presigned_url,
+            data=data,
+            headers={"Content-Type": content_type, "Content-Length": str(len(data))},
+            auth=False,
+            retries=2,
+            timeout=timeout,
+        )
+
+    async def post_media_image_complete(
+        self,
+        *,
+        upload_id: str,
+        md5: str,
+    ) -> media_image.MediaImageCompleteResponse:
+        """完成素材图片上传，返回 ``qqbot-media://`` 引用与 ``image_id``。"""
+
+        _required_text(upload_id, "upload_id")
+        _validate_digest(md5, "md5", 32)
+        route = Route("POST", "/v2/media-images/complete")
+        return await self._http.request(route, json={"upload_id": upload_id, "md5": md5.lower()}, timeout=120)
+
+    async def get_media_images(self, *, cursor: Optional[str] = None) -> media_image.MediaImageListResponse:
+        """分页查询当前机器人的有效素材图片，按上传时间倒序。"""
+
+        if cursor is not None and not isinstance(cursor, str):
+            raise TypeError("cursor must be a string or None")
+        route = Route("GET", "/v2/media-images")
+        if cursor:
+            return await self._http.request(route, params={"cursor": cursor})
+        return await self._http.request(route)
+
+    async def delete_media_image(self, image_id: str) -> Any:
+        """删除一张素材图片并释放数量配额；``image_id`` 不存在时平台返回 40035008。"""
+
+        _required_text(image_id, "image_id")
+        route = Route("DELETE", "/v2/media-images/{image_id}/delete", image_id=image_id)
+        return await self._http.request(route)

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/botpy/client.py

@@ -23,6 +23,7 @@ from .protocol.events import normalize_inbound_message
 from .protocol.constants import DEFAULT_API_BASE_URL
 from .protocol.errors import TransportError
 from .protocol.media import ChunkedMediaUploader, ProgressCallback
+from .protocol.media_image import MediaImageUploader, MediaImageUploadResult
 from .protocol.message import (
     LARGE_MEDIA_THRESHOLD,
     MAX_MEDIA_UPLOAD_SIZE,
@@ -607,6 +608,69 @@ class Client:
             raise RuntimeError("media upload response does not contain raw_url")
         return MediaUrlResult(upload=response, raw_url=raw_url, ttl=_coerce_ttl(response.get("ttl")))
 
+    async def upload_media_image(
+        self,
+        *,
+        data: Optional[bytes] = None,
+        local_path: Optional[Union[str, Path]] = None,
+        file_name: Optional[str] = None,
+        content_type: Optional[str] = None,
+        alt: Optional[str] = None,
+        timeout: float = 300,
+    ) -> MediaImageUploadResult:
+        """上传素材图片并返回 ``qqbot-media://`` 引用。
+
+        素材图片与富媒体消息的 ``file_info`` 不是同一套协议：这里只负责拿到引用，
+        通过 ``result.markdown`` 或 :meth:`send_markdown` 把图片嵌进 Markdown 消息。
+        ``data`` 与 ``local_path`` 必须二选一。
+        """
+
+        uploader = getattr(self, "_media_image_uploader", None)
+        if uploader is None:
+            uploader = MediaImageUploader(self.api, logger=_log)
+            self._media_image_uploader = uploader
+        return await uploader.upload(
+            data=data,
+            local_path=local_path,
+            file_name=file_name,
+            content_type=content_type,
+            alt=alt,
+            timeout=timeout,
+        )
+
+    async def list_media_images(self, *, cursor: Optional[str] = None) -> Mapping[str, Any]:
+        """分页查询当前机器人的有效素材图片。"""
+
+        return await self.api.get_media_images(cursor=cursor)
+
+    async def delete_media_image(self, image_id: str) -> Any:
+        """删除一张素材图片并释放配额。"""
+
+        return await self.api.delete_media_image(image_id)
+
+    async def send_markdown_image(
+        self,
+        target: ReplyTarget,
+        *,
+        data: Optional[bytes] = None,
+        local_path: Optional[Union[str, Path]] = None,
+        file_name: Optional[str] = None,
+        content_type: Optional[str] = None,
+        alt: Optional[str] = None,
+        keyboard: Optional[Mapping[str, Any]] = None,
+    ):
+        """上传素材图片并把它作为 Markdown 图片消息发出去。"""
+
+        uploaded = await Client.upload_media_image(
+            self,
+            data=data,
+            local_path=local_path,
+            file_name=file_name,
+            content_type=content_type,
+            alt=alt,
+        )
+        return await Client.send_markdown(self, target, uploaded.markdown, keyboard=keyboard)
+
     async def _upload_media(
         self,
         target: ReplyTarget,

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/botpy/middleware/control.py

@@ -135,7 +135,7 @@ def concurrency_guard(
             if max_processing_seconds > 0:
                 try:
                     await asyncio.wait_for(next_call(), timeout=max_processing_seconds)
-                except TimeoutError:
+                except asyncio.TimeoutError:
                     context.abort("concurrency:processing-timeout")
             else:
                 await next_call()

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/botpy/middleware/conversation.py

@@ -350,14 +350,16 @@ def _build_envelope(
                 sender = entry.sender_name or entry.sender_id
                 lines.append(f"{sender}: {entry.content[:200]}")
         if lines:
-            sections.append(f"<history>\n{'\n'.join(lines)}\n</history>")
+            history_text = "\n".join(lines)
+            sections.append(f"<history>\n{history_text}\n</history>")
 
     message_parts = []
     if context.message.content.strip():
         message_parts.append(context.message.content.strip())
     message_parts.extend(_attachment_label(attachment) for attachment in context.message.attachments)
     if message_parts:
-        sections.append(f"<message>\n{'\n'.join(message_parts)}\n</message>")
+        message_text = "\n".join(message_parts)
+        sections.append(f"<message>\n{message_text}\n</message>")
     return "\n\n".join(sections)
 
 

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/botpy/middleware/typing.py

@@ -65,7 +65,7 @@ async def _keepalive_loop(
         try:
             await asyncio.wait_for(stop_event.wait(), timeout=interval_seconds)
             return
-        except TimeoutError:
+        except asyncio.TimeoutError:
             await _safe_send(context, duration_seconds)
 
 

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/botpy/protocol/__init__.py

@@ -27,6 +27,13 @@ from .image import (
     parse_image_size,
 )
 from .media import ChunkedMediaUploader, ChunkedUploadProgress, ProgressCallback, UploadHashes
+from .media_image import (
+    MediaImageUploadApi,
+    MediaImageUploader,
+    MediaImageUploadResult,
+    format_media_image_markdown,
+    guess_media_image_content_type,
+)
 from .message import (
     CHUNKED_MEDIA_MAX_SIZE,
     LARGE_MEDIA_THRESHOLD,
@@ -137,6 +144,9 @@ __all__ = (
     "MAX_MEDIA_UPLOAD_SIZE",
     "MEDIA_FILE_SIZE_LIMITS",
     "MediaFileType",
+    "MediaImageUploadApi",
+    "MediaImageUploader",
+    "MediaImageUploadResult",
     "MediaSendResult",
     "MediaUrlResult",
     "MessageQuota",
@@ -189,8 +199,10 @@ __all__ = (
     "format_duration",
     "format_error_message",
     "format_file_size",
+    "format_media_image_markdown",
     "format_qqbot_markdown_image",
     "get_image_size_from_data_url",
+    "guess_media_image_content_type",
     "guess_mime_type",
     "has_qqbot_image_size",
     "is_audio_file",

qq_botpy_sdk-2.2.0/botpy/protocol/media_image.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+"""素材管理（media image）上传流程。
+
+平台要求先把 Markdown 消息要用的图片上传换取 ``qqbot-media://`` 引用：
+
+1. ``POST /v2/media-images/prepare`` 申请上传，得到预签名 URL；
+2. 用 HTTP ``PUT`` 把图片二进制直传到预签名 URL；
+3. ``POST /v2/media-images/complete`` 完成上传，得到 ``image_id`` 与引用链接。
+
+本模块把这三步串起来，并负责校验格式、大小与计算摘要。
+"""
+
+import asyncio
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping, Optional, Protocol, Tuple, Union
+
+from .. import logging
+from ..types.media_image import MEDIA_IMAGE_EXTENSIONS, MEDIA_IMAGE_MAX_SIZE
+from .image import ImageSize, parse_image_size
+
+
+class MediaImageUploadApi(Protocol):
+    """``MediaImageUploader`` 需要的最小 API 集合，便于测试替换。"""
+
+    async def post_media_image_prepare(self, **payload: Any) -> Mapping[str, Any]: ...
+
+    async def put_media_image(self, presigned_url: str, data: bytes, **kwargs: Any) -> Any: ...
+
+    async def post_media_image_complete(self, **payload: Any) -> Mapping[str, Any]: ...
+
+
+@dataclass(frozen=True)
+class MediaImageUploadResult:
+    """一次素材图片上传的结果。"""
+
+    image_id: str
+    url: str
+    ttl: int
+    preview_url: Optional[str]
+    upload_id: str
+    file_name: str
+    content_type: str
+    size: int
+    markdown: str
+
+
+def guess_media_image_content_type(file_name: str) -> Optional[str]:
+    """按扩展名返回平台的 MIME 类型；不支持的扩展名返回 ``None``。"""
+
+    if not isinstance(file_name, str) or not file_name:
+        return None
+    return MEDIA_IMAGE_EXTENSIONS.get(Path(file_name).suffix.lower())
+
+
+def format_media_image_markdown(url: str, *, alt: str = "", size: Optional[ImageSize] = None) -> str:
+    """生成 Markdown 图片语法；已知宽高时附带 ``#宽px #高px``。"""
+
+    if not isinstance(url, str) or not url:
+        raise ValueError("url must be a non-empty string")
+    if size is None:
+        return f"![{alt}]({url})"
+    return f"![{alt} #{size.width}px #{size.height}px]({url})"
+
+
+def _hash_media_image(data: bytes) -> Tuple[str, str]:
+    return hashlib.md5(data).hexdigest(), hashlib.sha1(data).hexdigest()
+
+
+class MediaImageUploader:
+    """执行素材图片的 prepare → PUT → complete 三步上传。"""
+
+    def __init__(self, api: MediaImageUploadApi, *, logger: Any = None) -> None:
+        self.api = api
+        self.logger = logger or logging.get_logger()
+
+    async def upload(
+        self,
+        *,
+        data: Optional[bytes] = None,
+        local_path: Optional[Union[str, Path]] = None,
+        file_name: Optional[str] = None,
+        content_type: Optional[str] = None,
+        alt: Optional[str] = None,
+        timeout: float = 300,
+    ) -> MediaImageUploadResult:
+        """上传一张图片并返回引用链接。
+
+        ``data`` 与 ``local_path`` 必须二选一；``content_type`` 省略时按扩展名推断。
+        ``alt`` 是 Markdown 图片的替代文本，省略时用文件名（不含扩展名）。
+        """
+
+        if (data is None) == (local_path is None):
+            raise ValueError("exactly one of data or local_path is required")
+        if file_name is not None and not isinstance(file_name, str):
+            raise TypeError("file_name must be a string")
+        if content_type is not None and not isinstance(content_type, str):
+            raise TypeError("content_type must be a string")
+        if alt is not None and not isinstance(alt, str):
+            raise TypeError("alt must be a string")
+        if isinstance(timeout, bool) or not isinstance(timeout, (int, float)) or timeout <= 0:
+            raise ValueError("timeout must be a positive number")
+
+        if data is not None:
+            if not isinstance(data, bytes):
+                raise TypeError("data must be bytes")
+            payload = data
+            display_name = file_name or "image.png"
+        else:
+            path = Path(local_path)
+            if path.is_symlink() or not path.is_file():
+                raise ValueError("local_path must point to a regular file and may not be a symlink")
+            payload = await asyncio.to_thread(path.read_bytes)
+            display_name = file_name or path.name
+
+        if not payload:
+            raise ValueError("image data must not be empty")
+        file_size = len(payload)
+        if file_size > MEDIA_IMAGE_MAX_SIZE:
+            raise ValueError(f"image size {file_size} exceeds the {MEDIA_IMAGE_MAX_SIZE} byte limit")
+
+        expected_type = guess_media_image_content_type(display_name)
+        if expected_type is None:
+            raise ValueError("file_name must end with .png, .jpg, .jpeg, .gif or .webp")
+        if content_type is not None and content_type != expected_type:
+            raise ValueError("content_type does not match the file_name extension")
+        content_type = content_type or expected_type
+
+        md5, sha1 = await asyncio.to_thread(_hash_media_image, payload)
+        prepared = await self.api.post_media_image_prepare(
+            file_name=display_name,
+            file_size=file_size,
+            content_type=content_type,
+            md5=md5,
+            sha1=sha1,
+        )
+        upload_id = prepared.get("upload_id")
+        presigned_url = prepared.get("presigned_url")
+        if not upload_id or not presigned_url:
+            raise RuntimeError("prepare 响应缺少 upload_id 或 presigned_url")
+
+        await self.api.put_media_image(
+            presigned_url,
+            payload,
+            content_type=content_type,
+            timeout=timeout,
+        )
+        completed = await self.api.post_media_image_complete(upload_id=upload_id, md5=md5)
+        image_url = completed.get("url")
+        if not image_url:
+            raise RuntimeError("complete 响应缺少 url")
+
+        size = parse_image_size(payload)
+        markdown = format_media_image_markdown(
+            image_url,
+            alt=alt if alt is not None else Path(display_name).stem,
+            size=size,
+        )
+        return MediaImageUploadResult(
+            image_id=str(completed.get("image_id") or ""),
+            url=image_url,
+            ttl=int(completed.get("ttl") or 0),
+            preview_url=completed.get("preview_url"),
+            upload_id=str(upload_id),
+            file_name=display_name,
+            content_type=content_type,
+            size=file_size,
+            markdown=markdown,
+        )

qq_botpy_sdk-2.2.0/botpy/types/media_image.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+from typing import List, Literal, TypedDict
+
+
+MediaImageContentType = Literal["image/png", "image/jpeg", "image/gif", "image/webp"]
+
+MEDIA_IMAGE_CONTENT_TYPES = frozenset({"image/png", "image/jpeg", "image/gif", "image/webp"})
+"""平台支持的素材图片 MIME 类型。"""
+
+MEDIA_IMAGE_MAX_SIZE = 10 * 1024 * 1024
+"""单张素材图片大小上限（10 MB）。"""
+
+MEDIA_IMAGE_MAX_COUNT = 100
+"""单个机器人可保存的有效素材图片数量上限。"""
+
+MEDIA_IMAGE_EXTENSIONS = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+}
+"""扩展名到 MIME 类型的映射；平台要求二者一致。"""
+
+
+class _MediaImagePrepareOptionalFields(TypedDict, total=False):
+    expires_in: int  # 预签名 URL 有效期（秒）
+
+
+class MediaImagePrepareResponse(_MediaImagePrepareOptionalFields):
+    upload_id: str  # 上传任务 ID，4 小时内有效
+    presigned_url: str  # 预签名上传 URL，用 HTTP PUT 直传图片二进制
+
+
+class _MediaImageCompleteOptionalFields(TypedDict, total=False):
+    ttl: int  # 滑动有效期窗口（秒），默认 7776000
+    preview_url: str  # 临时预览链接，短时效，请勿持久化
+
+
+class MediaImageCompleteResponse(_MediaImageCompleteOptionalFields):
+    image_id: str  # 图片 ID，用于查询与删除
+    url: str  # Markdown 引用链接：qqbot-media://image/v1/<token>
+
+
+class _MediaImageRecordOptionalFields(TypedDict, total=False):
+    file_name: str  # 上传时的文件名
+    preview_url: str  # 临时预览链接，短时效
+    created_at: int  # 上传时间（Unix 秒）
+    expires_at: int  # 过期时间（Unix 秒），每次被引用后自动顺延
+
+
+class MediaImageRecord(_MediaImageRecordOptionalFields):
+    image_id: str
+    url: str
+
+
+class _MediaImageListOptionalFields(TypedDict, total=False):
+    next_cursor: str  # 下一页游标，为空表示末页
+    total: int  # 当前有效图片总数
+
+
+class MediaImageListResponse(_MediaImageListOptionalFields):
+    images: List[MediaImageRecord]

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/botpy/types/message.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 from enum import Enum
-from typing import List, NotRequired, TypedDict
+from typing import List, TypedDict
 
 from .gateway import MessagePayload
 from .inline import Keyboard
@@ -66,11 +66,14 @@ class KeyboardPayload(TypedDict, total=False):
     content: Keyboard
 
 
-class Media(TypedDict):
+class _MediaOptionalFields(TypedDict, total=False):
+    raw_url: str  # 临时直链，可用于 Markdown 图片等内容；仅在平台返回时存在，随 ttl 过期
+
+
+class Media(_MediaOptionalFields):
     file_uuid: str  # 文件ID
     file_info: str  # 文件信息，用于发消息接口的media字段使用
     ttl: int  # 有效期，标识剩余多少秒到期，到期后 file_info 失效，当等于 0 时，表示可长期使用
-    raw_url: NotRequired[str]  # 临时直链，可用于 Markdown 图片等内容；仅在平台返回时存在，随 ttl 过期
 
 
 class Message(MessagePayload):

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/botpy/types/session.py

@@ -1,4 +1,4 @@
-from typing import Any, NotRequired, Optional, TypedDict
+from typing import Any, Optional, TypedDict
 
 from ..robot import Token
 
@@ -8,14 +8,17 @@ class ShardConfig(TypedDict):
     shard_count: int
 
 
-class Session(TypedDict):
+class _SessionOptionalFields(TypedDict, total=False):
+    ssl: Any
+    proxy: Any
+    reconnect_policy: Any
+    session_store: Any
+
+
+class Session(_SessionOptionalFields):
     session_id: str
     last_seq: Optional[int]
     intent: int
     token: Token
     url: str
     shards: ShardConfig
-    ssl: NotRequired[Any]
-    proxy: NotRequired[Any]
-    reconnect_policy: NotRequired[Any]
-    session_store: NotRequired[Any]

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qq-botpy-sdk"
-version = "2.1.2"
+version = "2.2.0"
 description = "Community-maintained async Python SDK for the QQ Bot Open Platform"
 readme = "README.md"
 requires-python = ">=3.10,<4.0"

{qq_botpy_sdk-2.1.2 → qq_botpy_sdk-2.2.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "qq-botpy-sdk"
-version = "2.1.2"
+version = "2.2.0"
 description = "Community-maintained async Python SDK for the QQ Bot Open Platform"
 authors = [{ name = "Teahouse Studios" }]
 readme = "README.md"