🐛 fix(sqla): dependency injection type check

Author: ProgramRipper

nonebot_plugin_orm/param.py

@@ -9,6 +9,7 @@
 
 from pydantic.fields import FieldInfo
 from nonebot.dependencies import Param
+from nonebot.typing import origin_is_union
 from nonebot.params import Depends, DependParam
 from sqlalchemy import Row, Result, ScalarResult, select
 from sqlalchemy.sql.selectable import ExecutableReturnsRows
@@ -37,32 +38,32 @@
     AsyncIterator[Sequence[Row[Tuple[Any, ...]]]]: Option(
         True,
         False,
-        methodcaller("partitions"),
+        (methodcaller("partitions"),),
     ),
     AsyncIterator[Sequence[Tuple[Any, ...]]]: Option(
         True,
         False,
-        methodcaller("partitions"),
+        (methodcaller("partitions"),),
     ),
     AsyncIterator[Sequence[Any]]: Option(
         True,
         True,
-        methodcaller("partitions"),
+        (methodcaller("partitions"),),
     ),
     Iterator[Sequence[Row[Tuple[Any, ...]]]]: Option(
         False,
         False,
-        methodcaller("partitions"),
+        (methodcaller("partitions"),),
     ),
     Iterator[Sequence[Tuple[Any, ...]]]: Option(
         False,
         False,
-        methodcaller("partitions"),
+        (methodcaller("partitions"),),
     ),
     Iterator[Sequence[Any]]: Option(
         False,
         True,
-        methodcaller("partitions"),
+        (methodcaller("partitions"),),
     ),
     AsyncResult[Tuple[Any, ...]]: Option(
         True,
@@ -91,26 +92,31 @@
     Sequence[Row[Tuple[Any, ...]]]: Option(
         True,
         False,
+        (),
         methodcaller("all"),
     ),
     Sequence[Tuple[Any, ...]]: Option(
         True,
         False,
+        (),
         methodcaller("all"),
     ),
     Sequence[Any]: Option(
         True,
         True,
+        (),
         methodcaller("all"),
     ),
     Tuple[Any, ...]: Option(
         True,
         False,
+        (),
         methodcaller("one_or_none"),
     ),
     Any: Option(
         True,
         True,
+        (),
         methodcaller("one_or_none"),
     ),
 }
@@ -149,20 +155,31 @@ def _check_param(
             depends_inner = param.default
 
         for pattern, option in PATTERNS.items():
-            if models := generic_issubclass(pattern, type_annotation):
+            if models := cast(
+                "list[Any]", generic_issubclass(pattern, type_annotation)
+            ):
                 break
         else:
-            models, option = None, Option()
+            models, option = [], Option()
+
+        for index, model in enumerate(models):
+            if origin_is_union(get_origin(model)):
+                models[index] = next(
+                    (
+                        arg
+                        for arg in get_args(model)
+                        if isclass(arg) and issubclass(arg, Model)
+                    ),
+                    None,
+                )
 
-        if not isinstance(models, tuple):
-            models = (models,)
+            if not (isclass(models[index]) and issubclass(models[index], Model)):
+                models = []
+                break
 
         if depends_inner is not None:
             statement = depends_inner.dependency
-        elif all(map(isclass, models)) and all(
-            map(issubclass, cast(Tuple[type, ...], models), repeat(Model))
-        ):
-            models = cast(Tuple[Type[Model], ...], models)
+        elif models:
             # NOTE: statement is generated (see below)
             statement = select(*models).where(
                 *(

nonebot_plugin_orm/utils.py

@@ -11,7 +11,7 @@
 from operator import methodcaller
 from typing_extensions import Annotated
 from dataclasses import field, dataclass
-from inspect import Parameter, Signature, isclass
+from inspect import Parameter, Signature
 from collections.abc import Callable, Iterable, Generator
 from typing import TYPE_CHECKING, Any, TypeVar, Coroutine
 from importlib.metadata import Distribution, PackageNotFoundError, distribution
@@ -89,8 +89,8 @@ def flush(self):
 class Option:
     stream: bool = True
     scalars: bool = False
+    calls: tuple[methodcaller, ...] = field(default_factory=tuple)
     result: methodcaller | None = None
-    calls: tuple[methodcaller] = field(default_factory=tuple)
 
 
 @dataclass
@@ -122,12 +122,12 @@ async def __call__(self, *, _session: async_scoped_session, **params: Any) -> An
         else:
             result = await _session.execute(self.statement, params)
 
-        for call in self.option.calls:
-            result = call(result)
-
         if self.option.scalars:
             result = result.scalars()
 
+        for call in self.option.calls:
+            result = call(result)
+
         if call := self.option.result:
             result = call(result)
 
@@ -140,14 +140,17 @@ def __hash__(self) -> int:
         return hash((self.statement, self.option))
 
 
-def generic_issubclass(scls: Any, cls: Any) -> Any:
-    if cls is Any:
-        return True
+def generic_issubclass(scls: Any, cls: Any) -> bool | list[Any]:
+    if isinstance(cls, tuple):
+        return _map_generic_issubclass(repeat(scls), cls)
 
     if scls is Any:
-        return cls
+        return [cls]
+
+    if cls is Any:
+        return True
 
-    if isclass(scls) and (isclass(cls) or isinstance(cls, tuple)):
+    with suppress(TypeError):
         return issubclass(scls, cls)
 
     scls_origin, scls_args = get_origin(scls) or scls, get_args(scls)
@@ -158,15 +161,17 @@ def generic_issubclass(scls: Any, cls: Any) -> Any:
             return generic_issubclass(scls_args[0], cls_args)
 
         if len(cls_args) == 2 and cls_args[1] is Ellipsis:
-            return all(map(generic_issubclass, scls_args, repeat(cls_args[0])))
+            return _map_generic_issubclass(
+                scls_args, repeat(cls_args[0]), failfast=True
+            )
 
     if scls_origin is Annotated:
         return generic_issubclass(scls_args[0], cls)
     if cls_origin is Annotated:
         return generic_issubclass(scls, cls_args[0])
 
     if origin_is_union(scls_origin):
-        return all(map(generic_issubclass, scls_args, repeat(cls)))
+        return _map_generic_issubclass(scls_args, repeat(cls), failfast=True)
     if origin_is_union(cls_origin):
         return generic_issubclass(scls, cls_args)
 
@@ -182,9 +187,25 @@ def generic_issubclass(scls: Any, cls: Any) -> Any:
     if not cls_args:
         return True
 
-    return len(scls_args) == len(cls_args) and all(
-        map(generic_issubclass, scls_args, cls_args)
-    )
+    if len(scls_args) != len(cls_args):
+        return False
+
+    return _map_generic_issubclass(scls_args, cls_args, failfast=True)
+
+
+def _map_generic_issubclass(
+    scls: Iterable[Any], cls: Iterable[Any], *, failfast: bool = False
+) -> bool | list[Any]:
+    results = []
+    for scls_arg, cls_arg in zip(scls, cls):
+        if not (result := generic_issubclass(scls_arg, cls_arg)) and failfast:
+            return False
+        elif isinstance(result, list):
+            results.extend(result)
+        elif not isinstance(result, bool):
+            results.append(result)
+
+    return results or False
 
 
 def return_progressbar(func: Callable[_P, Iterable[_T]]) -> Callable[_P, Iterable[_T]]:
@@ -217,7 +238,11 @@ def get_parent_plugins(plugin: Plugin | None) -> Generator[Plugin, Any, None]:
 def is_editable(plugin: Plugin) -> bool:
     *_, plugin = get_parent_plugins(plugin)
 
-    path = files(plugin.module)
+    try:
+        path = files(plugin.module)
+    except TypeError:
+        return False
+
     if not isinstance(path, Path) or "site-packages" in path.parts:
         return False