nonebot-plugin-werewolf 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

nonebot_plugin_werewolf/__init__.py

@@ -2,13 +2,14 @@ from nonebot import require
 from nonebot.plugin import PluginMetadata, inherit_supported_adapters
 
 require("nonebot_plugin_alconna")
-require("nonebot_plugin_userinfo")
+require("nonebot_plugin_uninfo")
 require("nonebot_plugin_waiter")
 
 from . import matchers as matchers
+from . import players as players
 from .config import Config
 
-__version__ = "1.1.1"
+__version__ = "1.1.3"
 __plugin_meta__ = PluginMetadata(
     name="狼人杀",
     description="适用于 Nonebot2 的狼人杀插件",
@@ -18,8 +19,11 @@ __plugin_meta__ = PluginMetadata(
     config=Config,
     supported_adapters=inherit_supported_adapters(
         "nonebot_plugin_alconna",
-        "nonebot_plugin_userinfo",
+        "nonebot_plugin_uninfo",
         "nonebot_plugin_waiter",
     ),
-    extra={"author": "wyf7685"},
+    extra={
+        "Author": "wyf7685",
+        "Bug Tracker": "https://github.com/wyf7685/nonebot-plugin-werewolf/issues",
+    },
 )

nonebot_plugin_werewolf/_timeout.py

@@ -0,0 +1,110 @@
+import asyncio
+import enum
+import sys
+from types import TracebackType
+from typing import final
+
+if sys.version_info >= (3, 11):
+    from asyncio.timeouts import timeout as timeout
+
+else:
+    # ruff: noqa: S101
+
+    class _State(enum.Enum):
+        CREATED = "created"
+        ENTERED = "active"
+        EXPIRING = "expiring"
+        EXPIRED = "expired"
+        EXITED = "finished"
+
+    @final
+    class Timeout:
+        def __init__(self, when: float | None) -> None:
+            self._state = _State.CREATED
+            self._timeout_handler: asyncio.Handle | None = None
+            self._task: asyncio.Task | None = None
+            if when is not None:
+                when = asyncio.get_running_loop().time() + when
+            self._when = when
+
+        def when(self) -> float | None:
+            return self._when
+
+        def reschedule(self, when: float | None) -> None:
+            if self._state is not _State.ENTERED:
+                if self._state is _State.CREATED:
+                    raise RuntimeError("Timeout has not been entered")
+                raise RuntimeError(
+                    f"Cannot change state of {self._state.value} Timeout",
+                )
+
+            self._when = when
+
+            if self._timeout_handler is not None:
+                self._timeout_handler.cancel()
+
+            if when is None:
+                self._timeout_handler = None
+            else:
+                loop = asyncio.get_running_loop()
+                if when <= loop.time():
+                    self._timeout_handler = loop.call_soon(self._on_timeout)
+                else:
+                    self._timeout_handler = loop.call_at(when, self._on_timeout)
+
+        def expired(self) -> bool:
+            return self._state in (_State.EXPIRING, _State.EXPIRED)
+
+        def __repr__(self) -> str:
+            info = [""]
+            if self._state is _State.ENTERED:
+                when = round(self._when, 3) if self._when is not None else None
+                info.append(f"when={when}")
+            info_str = " ".join(info)
+            return f"<Timeout [{self._state.value}]{info_str}>"
+
+        async def __aenter__(self) -> "Timeout":
+            if self._state is not _State.CREATED:
+                raise RuntimeError("Timeout has already been entered")
+            task = asyncio.current_task()
+            if task is None:
+                raise RuntimeError("Timeout should be used inside a task")
+            self._state = _State.ENTERED
+            self._task = task
+            self.reschedule(self._when)
+            return self
+
+        async def __aexit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: TracebackType | None,
+        ) -> bool | None:
+            assert self._state in (_State.ENTERED, _State.EXPIRING)
+
+            if self._timeout_handler is not None:
+                self._timeout_handler.cancel()
+                self._timeout_handler = None
+
+            if self._state is _State.EXPIRING:
+                self._state = _State.EXPIRED
+
+                if exc_type is asyncio.CancelledError:
+                    raise TimeoutError from exc_val
+            elif self._state is _State.ENTERED:
+                self._state = _State.EXITED
+
+            return None
+
+        def _on_timeout(self) -> None:
+            assert self._state is _State.ENTERED
+            assert self._task is not None
+            self._task.cancel()
+            self._state = _State.EXPIRING
+            self._timeout_handler = None
+
+    def timeout(delay: float | None) -> Timeout:
+        return Timeout(delay)
+
+
+__all__ = ["timeout"]

nonebot_plugin_werewolf/config.py

@@ -1,11 +1,14 @@
-from typing import Literal, Self, overload
+from typing import Any, Literal, overload
 
 from nonebot import get_plugin_config, logger
 from nonebot.compat import PYDANTIC_V2
 from pydantic import BaseModel, Field
+from typing_extensions import Self
 
 from .constant import (
     Role,
+    RolePresetConfig,
+    RolePresetDict,
     default_priesthood_proirity,
     default_role_preset,
     default_werewolf_priority,
@@ -17,12 +20,12 @@ else:
     from pydantic import root_validator
 
     @overload
-    def model_validator(*, mode: Literal["before"]): ...  # noqa: ANN201
+    def model_validator(*, mode: Literal["before"]) -> Any: ...  # noqa: ANN401
 
     @overload
-    def model_validator(*, mode: Literal["after"]): ...  # noqa: ANN201
+    def model_validator(*, mode: Literal["after"]) -> Any: ...  # noqa: ANN401
 
-    def model_validator(*, mode: Literal["before", "after"]):
+    def model_validator(*, mode: Literal["before", "after"]) -> Any:
         return root_validator(
             pre=mode == "before",  # pyright: ignore[reportArgumentType]
             allow_reuse=True,
@@ -30,16 +33,10 @@ else:
 
 
 class PluginConfig(BaseModel):
-    enable_poke: bool = Field(default=True)
-    role_preset: list[tuple[int, int, int, int]] | dict[int, tuple[int, int, int]] = (
-        Field(default_factory=default_role_preset.copy)
-    )
-    werewolf_priority: list[Role] = Field(
-        default_factory=default_werewolf_priority.copy
-    )
-    priesthood_proirity: list[Role] = Field(
-        default_factory=default_priesthood_proirity.copy
-    )
+    enable_poke: bool = True
+    role_preset: RolePresetConfig = default_role_preset.copy()
+    werewolf_priority: list[Role] = default_werewolf_priority.copy()
+    priesthood_proirity: list[Role] = default_priesthood_proirity.copy()
     joker_probability: float = Field(default=0.0, ge=0.0, le=1.0)
 
     @model_validator(mode="after")
@@ -47,7 +44,7 @@ class PluginConfig(BaseModel):
         if isinstance(self.role_preset, list):
             for preset in self.role_preset:
                 if preset[0] != sum(preset[1:]):
-                    raise RuntimeError(
+                    raise ValueError(
                         "配置项 `role_preset` 错误: "
                         f"预设总人数为 {preset[0]}, 实际总人数为 {sum(preset[1:])} "
                         f"({', '.join(map(str, preset[1:]))})"
@@ -59,19 +56,19 @@ class PluginConfig(BaseModel):
 
         min_length = max(i[0] for i in self.role_preset.values())
         if len(self.werewolf_priority) < min_length:
-            raise RuntimeError(
+            raise ValueError(
                 f"配置项 `werewolf_priority` 错误: 应至少为 {min_length} 项"
             )
 
         min_length = max(i[1] for i in self.role_preset.values())
         if len(self.priesthood_proirity) < min_length:
-            raise RuntimeError(
+            raise ValueError(
                 f"配置项 `priesthood_proirity` 错误: 应至少为 {min_length} 项"
             )
 
         return self
 
-    def get_role_preset(self) -> dict[int, tuple[int, int, int]]:
+    def get_role_preset(self) -> RolePresetDict:
         if isinstance(self.role_preset, list):
             self.role_preset = {i[0]: i[1:] for i in self.role_preset}
         return self.role_preset

nonebot_plugin_werewolf/constant.py

@@ -5,7 +5,7 @@ from enum import Enum, auto
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from .player import Player
+    from .players import Player
 
 
 class Role(Enum):
@@ -52,7 +52,7 @@ class GameState:
     killed: Player | None = None
     shoot: tuple[Player, Player] | tuple[None, None] = (None, None)
     antidote: set[Player] = dataclasses.field(default_factory=set)
-    poison: set[tuple[Player, Player]] = dataclasses.field(default_factory=set)
+    poison: set[Player] = dataclasses.field(default_factory=set)
     protected: set[Player] = dataclasses.field(default_factory=set)
 
 
@@ -71,7 +71,22 @@ role_name_conv: dict[Role | RoleGroup, str] = {
     RoleGroup.Others: "其他",
 }
 
-default_role_preset: dict[int, tuple[int, int, int]] = {
+role_emoji: dict[Role, str] = {
+    Role.Werewolf: "🐺",
+    Role.WolfKing: "🐺👑",
+    Role.Prophet: "🔮",
+    Role.Witch: "🧙‍♀️",
+    Role.Hunter: "🕵️",
+    Role.Guard: "🛡️",
+    Role.Idiot: "👨🏻‍🦲",
+    Role.Joker: "🤡",
+    Role.Civilian: "👨🏻‍🌾",
+}
+
+RolePresetDict = dict[int, tuple[int, int, int]]
+RolePresetConfig = RolePresetDict | list[tuple[int, int, int, int]]
+
+default_role_preset: RolePresetDict = {
     # 总人数: (狼, 神, 民)
     6: (1, 2, 3),
     7: (2, 2, 3),

nonebot_plugin_werewolf/exception.py

@@ -10,7 +10,7 @@ class Error(Exception):
     """插件错误类型基类"""
 
 
-class GameFinishedError(Error):
+class GameFinished(Error):  # noqa: N818
     """游戏结束时抛出，无视游戏进程进入结算"""
 
     status: GameStatus