🍻 fix version 0.60.3

use Rule.HANDLER_PARAM_TYPES

Author: RF-Tar-Railt

src/nonebot_plugin_alconna/matcher.py

@@ -38,7 +38,19 @@
 from .extension import Extension, ExtensionExecutor
 from .i18n import Lang
 from .model import CompConfig
-from .params import CHECK, MIDDLEWARE, AlconnaParam, Check, ExtensionParam, _Dispatch, _seminal, assign, merge_path
+from .params import (
+    CHECK,
+    MIDDLEWARE,
+    AlconnaParam,
+    Check,
+    DependencyCacheParam,
+    ExtensionParam,
+    StackParam,
+    _Dispatch,
+    _seminal,
+    assign,
+    merge_path,
+)
 from .rule import AlconnaRule
 from .uniseg import Segment, Text, UniMessage, get_message_id, get_target
 from .uniseg.fallback import FallbackStrategy
@@ -1007,6 +1019,13 @@ def on_alconna(
                 command.formatter.add(command)
     except ValueError:
         pass
+    Rule.HANDLER_PARAM_TYPES = [
+        *Matcher.HANDLER_PARAM_TYPES[:-1],
+        StackParam,
+        DependencyCacheParam,
+        AlconnaParam,
+        DefaultParam,
+    ]
     _rule = AlconnaRule(
         command,
         skip_for_unmatch,
@@ -1024,6 +1043,8 @@ def on_alconna(
     executor.params = params = (
         ExtensionParam.new(executor),
         *Matcher.HANDLER_PARAM_TYPES[:-1],
+        StackParam,
+        DependencyCacheParam,
         AlconnaParam,
         DefaultParam,
     )

src/nonebot_plugin_alconna/params.py

@@ -10,11 +10,11 @@
 from nonebot.dependencies import Param
 from nonebot.internal.adapter import Bot, Event
 from nonebot.internal.matcher import Matcher
-from nonebot.internal.params import Depends
-from nonebot.typing import T_DependencyCache, T_State
+from nonebot.internal.params import DependencyCache, Depends
+from nonebot.typing import T_State, _DependentCallable
 from nonebot.utils import generic_check_issubclass
 from tarina import run_always_await
-from tarina.generic import get_origin
+from tarina.generic import get_origin, is_optional
 
 from .consts import ALCONNA_ARG_KEY, ALCONNA_ARG_KEYS, ALCONNA_EXEC_RESULT, ALCONNA_EXTENSION, ALCONNA_RESULT
 from .extension import Extension, ExtensionExecutor, SelectedExtensions
@@ -367,8 +367,10 @@ def __repr__(self) -> str:
     def _check_param(cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]) -> Optional[Self]:
         if param.annotation == AsyncExitStack:
             return cls(..., type=AsyncExitStack)
+        if param.annotation == Optional[AsyncExitStack]:
+            return cls(None, type=AsyncExitStack)
         if generic_check_issubclass(param.annotation, AsyncExitStack):
-            return cls(..., type=AsyncExitStack, default=None)
+            return cls(None, type=AsyncExitStack)
 
     @override
     async def _solve(self, stack: Optional[AsyncExitStack] = None, **kwargs: Any) -> Any:
@@ -387,11 +389,15 @@ def __repr__(self) -> str:
     @classmethod
     @override
     def _check_param(cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]) -> Optional[Self]:
-        if param.annotation == T_DependencyCache:
-            return cls(..., type=T_DependencyCache)
-        if generic_check_issubclass(param.annotation, T_DependencyCache):
-            return cls(..., type=T_DependencyCache, default=None)
+        if param.annotation == dict[_DependentCallable[Any], DependencyCache]:
+            return cls(..., type=dict[_DependentCallable[Any], DependencyCache])
+        if param.annotation == Optional[dict[_DependentCallable[Any], DependencyCache]]:
+            return cls(None, type=dict[_DependentCallable[Any], DependencyCache])
+        if is_optional(param.annotation, dict[_DependentCallable[Any], DependencyCache]):
+            return cls(None, type=dict[_DependentCallable[Any], DependencyCache])
 
     @override
-    async def _solve(self, dependency_cache: Optional[T_DependencyCache] = None, **kwargs: Any) -> Any:
+    async def _solve(
+        self, dependency_cache: Optional[dict[_DependentCallable[Any], DependencyCache]] = None, **kwargs: Any
+    ) -> Any:
         return dependency_cache

src/nonebot_plugin_alconna/rule.py

@@ -1,6 +1,6 @@
 import asyncio
 from contextlib import AsyncExitStack
-from typing import Any, Literal, Optional, Union
+from typing import Any, ClassVar, Literal, Optional, Union
 import weakref
 
 from arclet.alconna import Alconna, Arparma, CompSession, command_manager, output_manager
@@ -21,7 +21,6 @@
 from .extension import ExtensionExecutor, SelectedExtensions, _DependentExecutor
 from .i18n import Lang
 from .model import CommandResult, CompConfig
-from .params import DependencyCacheParam, StackParam
 from .uniseg import UniMessage, UniMsg
 from .uniseg.constraint import UNISEG_MESSAGE
 
@@ -214,7 +213,10 @@ def destroy(self) -> None:
 
     @property
     def rule(self) -> Rule:
-        return Rule(self)
+        class _Rule(Rule):
+            HANDLER_PARAM_TYPES: ClassVar = list(self.executor.params)
+
+        return _Rule(self)
 
     def __repr__(self) -> str:
         return f"Alconna(command={self.command()!r})"
@@ -293,10 +295,9 @@ async def __call__(
         bot: Bot,
         event: Event,
         state: T_State,
-        stack: Optional[AsyncExitStack] = StackParam(),  # type: ignore
-        dependency_cache: Optional[dict[_DependentCallable[Any], DependencyCache]] = DependencyCacheParam(),  # type: ignore
+        stack: Optional[AsyncExitStack] = None,
+        dependency_cache: Optional[dict[_DependentCallable[Any], DependencyCache]] = None,
     ) -> bool:
-
         if self.before_rules.checkers and not await self.before_rules(bot, event, state, stack, dependency_cache):
             return False
         if event.get_type() == "meta_event":