AstrBot 3.5.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

astrbot/core/utils/session_waiter.py

@@ -1,24 +1,22 @@
-"""
-会话控制
-"""
+"""会话控制"""
 
 import abc
 import asyncio
-import time
-import functools
 import copy
+import functools
+import time
+from collections.abc import Awaitable, Callable
+from typing import Any
+
 import astrbot.core.message.components as Comp
-from typing import Dict, Any, Callable, Awaitable, List
 from astrbot.core.platform import AstrMessageEvent
 
-USER_SESSIONS: Dict[str, "SessionWaiter"] = {}  # 存储 SessionWaiter 实例
-FILTERS: List["SessionFilter"] = []  # 存储 SessionFilter 实例
+USER_SESSIONS: dict[str, "SessionWaiter"] = {}  # 存储 SessionWaiter 实例
+FILTERS: list["SessionFilter"] = []  # 存储 SessionFilter 实例
 
 
 class SessionController:
-    """
-    控制一个 Session 是否已经结束
-    """
+    """控制一个 Session 是否已经结束"""
 
     def __init__(self):
         self.future = asyncio.Future()
@@ -29,7 +27,7 @@ class SessionController:
         self.timeout: float | int = None
         """上次保持(keep)开始时的超时时间"""
 
-        self.history_chains: List[List[Comp.BaseMessageComponent]] = []
+        self.history_chains: list[list[Comp.BaseMessageComponent]] = []
 
     def stop(self, error: Exception = None):
         """立即结束这个会话"""
@@ -39,13 +37,14 @@ class SessionController:
             else:
                 self.future.set_result(None)
 
-    def keep(self, timeout: float | int = 0, reset_timeout=False):
+    def keep(self, timeout: float = 0, reset_timeout=False):
         """保持这个会话
 
         Args:
             timeout (float): 必填。会话超时时间。
             当 reset_timeout 设置为 True 时, 代表重置超时时间, timeout 必须 > 0, 如果 <= 0 则立即结束会话。
             当 reset_timeout 设置为 False 时, 代表继续维持原来的超时时间, 新 timeout = 原来剩余的timeout + timeout (可以 < 0)
+
         """
         new_ts = time.time()
 
@@ -81,7 +80,7 @@ class SessionController:
             pass  # 避免报错
         # finally:
 
-    def get_history_chains(self) -> List[List[Comp.BaseMessageComponent]]:
+    def get_history_chains(self) -> list[list[Comp.BaseMessageComponent]]:
         """获取历史消息链"""
         return self.history_chains
 
@@ -92,7 +91,6 @@ class SessionFilter:
     @abc.abstractmethod
     def filter(self, event: AstrMessageEvent) -> str:
         """根据事件返回一个会话标识符"""
-        pass
 
 
 class DefaultSessionFilter(SessionFilter):
@@ -120,7 +118,9 @@ class SessionWaiter:
         """需要保证一个 session 同时只有一个 trigger"""
 
     async def register_wait(
-        self, handler: Callable[[str], Awaitable[Any]], timeout: int = 30
+        self,
+        handler: Callable[[str], Awaitable[Any]],
+        timeout: int = 30,
     ) -> Any:
         """等待外部输入并处理"""
         self.handler = handler
@@ -149,7 +149,7 @@ class SessionWaiter:
     @classmethod
     async def trigger(cls, session_id: str, event: AstrMessageEvent):
         """外部输入触发会话处理"""
-        session = USER_SESSIONS.get(session_id, None)
+        session = USER_SESSIONS.get(session_id)
         if not session or session.session_controller.future.done():
             return
 
@@ -157,7 +157,7 @@ class SessionWaiter:
             if not session.session_controller.future.done():
                 if session.record_history_chains:
                     session.session_controller.history_chains.append(
-                        [copy.deepcopy(comp) for comp in event.get_messages()]
+                        [copy.deepcopy(comp) for comp in event.get_messages()],
                     )
                 try:
                     # TODO: 这里使用 create_task，跟踪 task，防止超时后这里 handler 仍然在执行
@@ -167,8 +167,7 @@ class SessionWaiter:
 
 
 def session_waiter(timeout: int = 30, record_history_chains: bool = False):
-    """
-    装饰器：自动将函数注册为 SessionWaiter 处理函数，并等待外部输入触发执行。
+    """装饰器：自动将函数注册为 SessionWaiter 处理函数，并等待外部输入触发执行。
 
     :param timeout: 超时时间（秒）
     :param record_history_chain: 是否自动记录历史消息链。可以通过 controller.get_history_chains() 获取。深拷贝。

astrbot/core/utils/shared_preferences.py

@@ -1,38 +1,178 @@
-import json
+import asyncio
 import os
+import threading
+from typing import Any, TypeVar, overload
+
+from astrbot.core.db import BaseDatabase
+from astrbot.core.db.po import Preference
+
+from .astrbot_path import get_astrbot_data_path
+
+_VT = TypeVar("_VT")
 
 
 class SharedPreferences:
-    def __init__(self, path="data/shared_preferences.json"):
-        self.path = path
-        self._data = self._load_preferences()
-
-    def _load_preferences(self):
-        if os.path.exists(self.path):
-            try:
-                with open(self.path, "r") as f:
-                    return json.load(f)
-            except json.JSONDecodeError:
-                os.remove(self.path)
-        return {}
-
-    def _save_preferences(self):
-        with open(self.path, "w") as f:
-            json.dump(self._data, f, indent=4, ensure_ascii=False)
-            f.flush()
-
-    def get(self, key, default=None):
-        return self._data.get(key, default)
-
-    def put(self, key, value):
-        self._data[key] = value
-        self._save_preferences()
-
-    def remove(self, key):
-        if key in self._data:
-            del self._data[key]
-            self._save_preferences()
-
-    def clear(self):
-        self._data.clear()
-        self._save_preferences()
+    def __init__(self, db_helper: BaseDatabase, json_storage_path=None):
+        if json_storage_path is None:
+            json_storage_path = os.path.join(
+                get_astrbot_data_path(),
+                "shared_preferences.json",
+            )
+        self.path = json_storage_path
+        self.db_helper = db_helper
+
+        self._sync_loop = asyncio.new_event_loop()
+        t = threading.Thread(target=self._sync_loop.run_forever, daemon=True)
+        t.start()
+
+    async def get_async(
+        self,
+        scope: str,
+        scope_id: str,
+        key: str,
+        default: _VT = None,
+    ) -> _VT:
+        """获取指定范围和键的偏好设置"""
+        if scope_id is not None and key is not None:
+            result = await self.db_helper.get_preference(scope, scope_id, key)
+            if result:
+                ret = result.value["val"]
+            else:
+                ret = default
+            return ret
+
+    async def range_get_async(
+        self,
+        scope: str,
+        scope_id: str | None = None,
+        key: str | None = None,
+    ) -> list[Preference]:
+        """获取指定范围的偏好设置
+        Note: 返回 Preference 列表，其中的 value 属性是一个 dict，value["val"] 为值。scope_id 和 key 可以为 None，这时返回该范围下所有的偏好设置。
+        """
+        ret = await self.db_helper.get_preferences(scope, scope_id, key)
+        return ret
+
+    async def session_get(
+        self,
+        umo: str | None,
+        key: str | None = None,
+        default: _VT = None,
+    ) -> _VT | list[Preference]:
+        """获取会话范围的偏好设置
+
+        Note: 当 umo 或者 key 为 None，时，返回 Preference 列表，其中的 value 属性是一个 dict，value["val"] 为值。
+        """
+        if umo is None or key is None:
+            return await self.range_get_async("umo", umo, key)
+        return await self.get_async("umo", umo, key, default)
+
+    @overload
+    async def global_get(self, key: None, default: Any = None) -> list[Preference]: ...
+
+    @overload
+    async def global_get(self, key: str, default: _VT = None) -> _VT: ...
+
+    async def global_get(
+        self,
+        key: str | None,
+        default: _VT = None,
+    ) -> _VT | list[Preference]:
+        """获取全局范围的偏好设置
+
+        Note: 当 scope_id 或者 key 为 None，时，返回 Preference 列表，其中的 value 属性是一个 dict，value["val"] 为值。
+        """
+        if key is None:
+            return await self.range_get_async("global", "global", key)
+        return await self.get_async("global", "global", key, default)
+
+    async def put_async(self, scope: str, scope_id: str, key: str, value: Any):
+        """设置指定范围和键的偏好设置"""
+        await self.db_helper.insert_preference_or_update(
+            scope,
+            scope_id,
+            key,
+            {"val": value},
+        )
+
+    async def session_put(self, umo: str, key: str, value: Any):
+        await self.put_async("umo", umo, key, value)
+
+    async def global_put(self, key: str, value: Any):
+        await self.put_async("global", "global", key, value)
+
+    async def remove_async(self, scope: str, scope_id: str, key: str):
+        """删除指定范围和键的偏好设置"""
+        await self.db_helper.remove_preference(scope, scope_id, key)
+
+    async def session_remove(self, umo: str, key: str):
+        await self.remove_async("umo", umo, key)
+
+    async def global_remove(self, key: str):
+        """删除全局偏好设置"""
+        await self.remove_async("global", "global", key)
+
+    async def clear_async(self, scope: str, scope_id: str):
+        """清空指定范围的所有偏好设置"""
+        await self.db_helper.clear_preferences(scope, scope_id)
+
+    # ====
+    # DEPRECATED METHODS
+    # ====
+
+    def get(
+        self,
+        key: str,
+        default: _VT = None,
+        scope: str | None = None,
+        scope_id: str | None = "",
+    ) -> _VT:
+        """获取偏好设置（已弃用）"""
+        if scope_id == "":
+            scope_id = "unknown"
+        if scope_id is None or key is None:
+            # result = asyncio.run(self.range_get_async(scope, scope_id, key))
+            raise ValueError(
+                "scope_id and key cannot be None when getting a specific preference.",
+            )
+        result = asyncio.run_coroutine_threadsafe(
+            self.get_async(scope or "unknown", scope_id or "unknown", key, default),
+            self._sync_loop,
+        ).result()
+
+        return result if result is not None else default
+
+    def range_get(
+        self,
+        scope: str,
+        scope_id: str | None = None,
+        key: str | None = None,
+    ) -> list[Preference]:
+        """获取指定范围的偏好设置（已弃用）"""
+        result = asyncio.run_coroutine_threadsafe(
+            self.range_get_async(scope, scope_id, key),
+            self._sync_loop,
+        ).result()
+
+        return result
+
+    def put(self, key, value, scope: str | None = None, scope_id: str | None = None):
+        """设置偏好设置（已弃用）"""
+        asyncio.run_coroutine_threadsafe(
+            self.put_async(scope or "unknown", scope_id or "unknown", key, value),
+            self._sync_loop,
+        ).result()
+
+    def remove(self, key, scope: str | None = None, scope_id: str | None = None):
+        """删除偏好设置（已弃用）"""
+        asyncio.run_coroutine_threadsafe(
+            self.remove_async(scope or "unknown", scope_id or "unknown", key),
+            self._sync_loop,
+        ).result()
+
+    def clear(self, scope: str | None = None, scope_id: str | None = None):
+        """清空偏好设置（已弃用）"""
+        asyncio.run_coroutine_threadsafe(
+            self.clear_async(scope or "unknown", scope_id or "unknown"),
+            self._sync_loop,
+        ).result()

astrbot/core/utils/t2i/__init__.py

@@ -8,6 +8,9 @@ class RenderStrategy(ABC):
 
     @abstractmethod
     def render_custom_template(
-        self, tmpl_str: str, tmpl_data: dict, return_url: bool
+        self,
+        tmpl_str: str,
+        tmpl_data: dict,
+        return_url: bool,
     ) -> str:
         pass