u-toolkit 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

u_toolkit/decorators.py

@@ -1,9 +1,8 @@
+import inspect
 from collections.abc import Callable
 from functools import wraps
 from typing import Generic, NamedTuple, TypeVar
 
-from u_toolkit.signature import list_parameters, update_parameters
-
 
 _FnT = TypeVar("_FnT", bound=Callable)
 
@@ -27,8 +26,13 @@ class DefineMethodDecorator(Generic[_T, _FnT]):
         self.register_method(DefineMethodParams(owner_class, name, self.fn))
 
     def __get__(self, instance: _T, owner_class: type[_T]):
-        parameters = list_parameters(self.fn)[1:]
-        update_parameters(self.fn, *parameters)
+        if inspect.iscoroutinefunction(self.fn):
+
+            @wraps(self.fn)
+            async def awrapper(*args, **kwargs):
+                return await self.fn(instance, *args, **kwargs)
+
+            return awrapper
 
         @wraps(self.fn)
         def wrapper(*args, **kwargs):

u_toolkit/fastapi/cbv.py

@@ -3,7 +3,16 @@ import re
 from collections.abc import Callable
 from enum import Enum, StrEnum, auto
 from functools import partial, update_wrapper, wraps
-from typing import Any, Literal, NamedTuple, Protocol, Self, TypeVar, cast
+from typing import (
+    Generic,
+    Literal,
+    NamedTuple,
+    NotRequired,
+    TypeVar,
+    TypedDict,
+    cast,
+    overload,
+)
 
 from fastapi import APIRouter, Depends
 from pydantic.alias_generators import to_snake
@@ -20,23 +29,7 @@ from u_toolkit.signature import (
 )
 
 
-class EndpointsClassInterface(Protocol):
-    dependencies: tuple | None = None
-    responses: tuple[Response, ...] | None = None
-    prefix: str | None = None
-    tags: tuple[str | Enum, ...] | None = None
-    deprecated: bool | None = None
-
-    @classmethod
-    def build_self(cls) -> Self:
-        return cls()
-
-
 _T = TypeVar("_T")
-EndpointsClassInterfaceT = TypeVar(
-    "EndpointsClassInterfaceT",
-    bound=EndpointsClassInterface,
-)
 
 
 LiteralUpperMethod = Literal[
@@ -84,15 +77,6 @@ METHOD_PATTERNS = {
 _FnName = str
 
 
-class EndpointInfo(NamedTuple):
-    handle: Callable
-    original_handle_name: str
-    handle_name: str
-    method: RequestMethod
-    method_pattern: re.Pattern
-    path: str
-
-
 _MethodInfo = tuple[RequestMethod, re.Pattern[str]]
 
 
@@ -103,9 +87,13 @@ def get_method(name: str) -> _MethodInfo | None:
     return None
 
 
-def valid_endpoint(name: str):
-    if get_method(name) is None:
-        raise ValueError("Invalid endpoint function.")
+class EndpointInfo(NamedTuple):
+    handle: Callable
+    original_handle_name: str
+    handle_name: str
+    method: RequestMethod
+    method_pattern: re.Pattern
+    path: str
 
 
 def iter_endpoints(
@@ -125,13 +113,19 @@ def iter_endpoints(
         paths = [prefix]
 
         methods: list[_MethodInfo] = []
-        if method := get_method(name):
+        from_valid_method = False
+
+        if valid_method:
+            if results := valid_method(name, handle):
+                methods.extend(results)
+            if methods:
+                from_valid_method = True
+
+        if not methods and (method := get_method(name)):
             methods.append(method)
-        elif valid_method:
-            methods.extend(valid_method(name, handle) or [])
 
         for method, pattern in methods:
-            handle_name = pattern.sub("", name)
+            handle_name = name if from_valid_method else pattern.sub("", name)
             path = handle_name.replace("__", "/")
             if path:
                 paths.append(path)
@@ -161,52 +155,53 @@ def iter_dependencies(cls: type[_T]):
                 yield token, dep
 
 
-_CBVEndpointParamName = Literal[
-    "path",
-    "tags",
-    "dependencies",
-    "responses",
-    "response_model",
-    "status",
-    "deprecated",
-    "methods",
-]
+class CBVRoutesInfo(TypedDict):
+    path: NotRequired[str | None]
+    tags: NotRequired[list[str | Enum] | None]
+    dependencies: NotRequired[list | None]
+    responses: NotRequired[list[Response] | None]
+    deprecated: NotRequired[bool | None]
+
+
+class CBVRouteInfo(CBVRoutesInfo, Generic[_T]):
+    methods: NotRequired[list[RequestMethod] | None]
+    response_model: NotRequired[type[_T] | None]
+    status: NotRequired[int | None]
 
 
 class CBV:
     def __init__(self, router: APIRouter | None = None) -> None:
         self.router = router or APIRouter()
 
-        self._state: dict[
-            type[EndpointsClassInterface],
-            dict[_FnName, dict[_CBVEndpointParamName, Any]],
-        ] = {}
-
-        self._initialed_state: dict[
-            type[EndpointsClassInterface], EndpointsClassInterface
+        self._state: dict[type, dict[_FnName, CBVRouteInfo]] = {}
+        self._cls_routes_extra: dict[
+            type, tuple[CBVRoutesInfo, Callable[[type[_T]], _T] | None]  # type: ignore
         ] = {}
+        self._initialed_state: dict[type[_T], _T] = {}  # type: ignore
 
     def create_route(
         self,
         *,
-        cls: type[EndpointsClassInterfaceT],
+        cls: type[_T],
         path: str,
         method: RequestMethod,
         method_name: str,
     ):
-        class_tags = list(cls.tags) if cls.tags else []
+        class_routes_info = self._cls_routes_extra[cls][0]
+
+        class_tags = class_routes_info.get("tags") or []
         endpoint_tags: list[str | Enum] = (
             self._state[cls][method_name].get("tags") or []
         )
         tags = class_tags + endpoint_tags
 
-        class_dependencies = list(cls.dependencies) if cls.dependencies else []
+        class_dependencies = class_routes_info.get("dependencies") or []
         endpoint_dependencies = (
             self._state[cls][method_name].get("dependencies") or []
         )
         dependencies = class_dependencies + endpoint_dependencies
 
-        class_responses = cls.responses or []
+        class_responses = class_routes_info.get("responses") or []
         endpoint_responses = (
             self._state[cls][method_name].get("responses") or []
         )
@@ -215,13 +210,14 @@ class CBV:
         status_code = self._state[cls][method_name].get("status")
 
         deprecated = self._state[cls][method_name].get(
-            "deprecated", cls.deprecated
+            "deprecated", class_routes_info.get("deprecated")
         )
 
         response_model = self._state[cls][method_name].get("response_model")
 
-        endpoint_methods = self._state[cls][method_name].get("methods") or [
-            method
+        endpoint_methods = [
+            i.upper()
+            for i in (self._state[cls][method_name].get("methods") or [method])
         ]
 
         path = self._state[cls][method_name].get("path") or path
@@ -245,22 +241,22 @@ class CBV:
         tags: list[str | Enum] | None = None,
         dependencies: list | None = None,
         responses: list[Response] | None = None,
-        response_model: Any | None = None,
+        response_model: type[_T] | None = None,
         status: int | None = None,
         deprecated: bool | None = None,
     ):
         state = self._state
         initial_state = self._initial_state
-        data: dict[_CBVEndpointParamName, Any] = {
-            "path": path,
-            "methods": methods,
-            "tags": tags,
-            "dependencies": dependencies,
-            "responses": responses,
-            "response_model": response_model,
-            "status": status,
-            "deprecated": deprecated,
-        }
+        data = CBVRouteInfo(
+            path=path,
+            methods=methods,
+            tags=tags,
+            dependencies=dependencies,
+            responses=responses,
+            response_model=response_model,
+            status=status,
+            deprecated=deprecated,
+        )
 
         def handle(params: DefineMethodParams):
             initial_state(params.method_class)
@@ -271,37 +267,27 @@ class CBV:
 
         return define_method_handler(handle)
 
-    def _initial_state(self, cls: type[_T]) -> EndpointsClassInterface:
-        if result := self._initialed_state.get(cls):  # type: ignore
-            return result
-
-        self._update_cls(cls)
-        n_cls = cast(type[EndpointsClassInterface], cls)
+    def _initial_state(self, cls: type[_T]) -> _T:
+        if result := self._initialed_state.get(cls):
+            return cast(_T, result)
 
         default_data = {}
-        for endpoint in iter_endpoints(n_cls):
+        for endpoint in iter_endpoints(cls):
             default_data[endpoint.original_handle_name] = {}
 
-        self._state.setdefault(n_cls, default_data)
-        result = self._build_cls(n_cls)
-        self._initialed_state[n_cls] = result
+        self._state.setdefault(cls, default_data)
+        result = self._build_cls(cls)
+        self._initialed_state[cls] = result
         return result
 
-    def _update_cls(self, cls: type[_T]):
-        for extra_name in EndpointsClassInterface.__annotations__:
-            if not hasattr(cls, extra_name):
-                setattr(cls, extra_name, None)
-
-            # TODO: 加个如果存在属性, 校验属性类型是否是预期的
-
     def _build_cls(self, cls: type[_T]) -> _T:
-        if inspect.isfunction(cls.__init__) and hasattr(cls, "build_self"):
-            return cast(type[EndpointsClassInterface], cls).build_self()  # type: ignore
+        if cls in self._cls_routes_extra and (
+            build := self._cls_routes_extra[cls][1]
+        ):
+            return build(cls)  # type: ignore
         return cls()
 
-    def __create_class_dependencies_injector(
-        self, cls: type[EndpointsClassInterfaceT]
-    ):
+    def __create_class_dependencies_injector(self, cls: type[_T]):
         """将类的依赖添加到函数实例上
 
         ```python
@@ -333,7 +319,7 @@ class CBV:
 
         def new_fn(method_name, kwargs):
             instance = self._build_cls(cls)
-            dependencies = kwargs.pop(collect_cls_dependencies.__name__)
+            dependencies = kwargs.pop(collect_cls_dependencies.__name__, {})
             for dep_name, dep_value in dependencies.items():
                 setattr(instance, dep_name, dep_value)
             return getattr(instance, method_name)
@@ -374,38 +360,61 @@ class CBV:
 
         return decorator
 
-    def __call__(self, cls: type[_T]) -> type[_T]:
-        instance = self._initial_state(cls)
-        cls_ = cast(type[EndpointsClassInterface], cls)
+    @overload
+    def __call__(self, cls: type[_T], /) -> type[_T]: ...
+    @overload
+    def __call__(
+        self,
+        *,
+        info: CBVRoutesInfo | None = None,
+        build: Callable[[type[_T]], _T] | None = None,
+    ) -> Callable[[type[_T]], type[_T]]: ...
+
+    def __call__(self, *args, **kwargs):
+        info: CBVRoutesInfo = {}
+        build: Callable | None = None
+
+        def decorator(cls: type[_T]) -> type[_T]:
+            instance = self._initial_state(cls)
+            self._cls_routes_extra[cls] = info, build
+
+            decorator = self.__create_class_dependencies_injector(cls)
+
+            def valid_method(
+                name: str, _handle: Callable
+            ) -> None | list[_MethodInfo]:
+                if (cls_state := self._state.get(cls)) and (
+                    method_state := cls_state.get(name)
+                ):
+                    methods: list[RequestMethod] = (
+                        method_state.get("methods") or []
+                    )
+                    result: list[_MethodInfo] = []
+                    for i in methods:
+                        method = Methods(i.lower())
+                        result.append((method, METHOD_PATTERNS[method]))
+                    return result
+
+                return None
+
+            for endpoint_info in iter_endpoints(cls, valid_method):
+                route = self.create_route(
+                    cls=cls,
+                    path=endpoint_info.path,
+                    method=endpoint_info.method,
+                    method_name=endpoint_info.original_handle_name,
+                )
+                method = getattr(instance, endpoint_info.original_handle_name)
+                endpoint = decorator(method)
+                endpoint.__name__ = endpoint_info.handle_name
+                route(endpoint)
 
-        decorator = self.__create_class_dependencies_injector(cls_)
+            return cls
 
-        def valid_method(
-            name: str, _handle: Callable
-        ) -> None | list[_MethodInfo]:
-            if (cls_state := self._state.get(cls_)) and (
-                method_state := cls_state.get(name)
-            ):
-                methods: list[RequestMethod] = (
-                    method_state.get("methods") or []
-                )
-                result: list[_MethodInfo] = []
-                for i in methods:
-                    method = Methods(i.lower())
-                    result.append((method, METHOD_PATTERNS[method]))
-                return result
-
-            return None
-
-        for endpoint_info in iter_endpoints(cls, valid_method):
-            route = self.create_route(
-                cls=cast(type[EndpointsClassInterface], cls),
-                path=endpoint_info.path,
-                method=endpoint_info.method,
-                method_name=endpoint_info.original_handle_name,
-            )
-            method = getattr(instance, endpoint_info.original_handle_name)
-            endpoint = decorator(method)
-            route(endpoint)
+        if args:
+            return decorator(args[0])
 
-        return cls
+        info.update(kwargs.get("info") or {})
+        build = kwargs.get("build")
+
+        return decorator

{u_toolkit-0.1.11.dist-info → u_toolkit-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: u-toolkit
-Version: 0.1.11
+Version: 0.1.13
 Summary: Add your description here
 Requires-Python: >=3.11
 Requires-Dist: pydantic>=2.11.3

{u_toolkit-0.1.11.dist-info → u_toolkit-0.1.13.dist-info}/RECORD

@@ -1,7 +1,7 @@
 u_toolkit/__init__.py,sha256=7f_bFg1UERA4gyh3HjCAjOZo2cBUgElpwgX5x-Xk2WA,238
 u_toolkit/alias_generators.py,sha256=KmPL1ViGJjptONffZUAX4ENvkldrwDylm_Ly5RYE8b4,963
 u_toolkit/datetime.py,sha256=GOG0xa6yKeqvFXJkImK5Pt7wsPXnHMlNKju8deniGJ4,644
-u_toolkit/decorators.py,sha256=NVQPvl8nByo11IRVtAi_kRRjhGvuHPlEme4dYTGZU0s,1261
+u_toolkit/decorators.py,sha256=1drP4aNDpGxoEGDdnJyWP3lIeMBPPfeWEUrG0J8CpzE,1330
 u_toolkit/enum.py,sha256=2yWmK8V1q0P5S3ltBED-TF2H09BmRbsBuqu3Th3G1NE,862
 u_toolkit/function.py,sha256=GAE6TIm5jpemUiNUPjzk7pIHrxwSSX7sHl1V5E735dE,252
 u_toolkit/helpers.py,sha256=K3FCz93K1nT4o7gWKVpMKy3k3BnirTPCSb8F8EFUrWk,112
@@ -11,7 +11,7 @@ u_toolkit/object.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 u_toolkit/path.py,sha256=IkyIHcU9hKBCOZfF30FrKf4CfL-MH91fjeYF9EY7eos,128
 u_toolkit/signature.py,sha256=-Q6n28PYBYYdd2OXBKESeVkL2rYpV6EaY3IVwQmzezQ,2161
 u_toolkit/fastapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-u_toolkit/fastapi/cbv.py,sha256=oxQFHWa48kZxxhL7UFeq9mUVqo9Q0QgQK_IllkyOFUk,11937
+u_toolkit/fastapi/cbv.py,sha256=q9A4HKguOVBfLeZmhnY9kfiP6FfAViZUo52m-5aKZhU,12219
 u_toolkit/fastapi/config.py,sha256=kGpokR9XXr1KxMA1GVKYkCdKwqIQAIwOJ-v6sGbqzAQ,267
 u_toolkit/fastapi/exception.py,sha256=P9apEEQvbBMmffiHX57768gmemMeAy69-nb-1JQZAZE,4624
 u_toolkit/fastapi/helpers.py,sha256=BCMMLxa1c6BMA_rKq-hCi0iyEjrR3Z5rPMeTvgaVJB0,447
@@ -30,7 +30,7 @@ u_toolkit/sqlalchemy/type_vars.py,sha256=m2VeV41CBIK_1QX3w2kgz-n556sILAGZ-Kaz3TD
 u_toolkit/sqlalchemy/orm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 u_toolkit/sqlalchemy/orm/fields.py,sha256=3zoYil23I6YLtc_59aHDt9w5l1NBTkePT9AfXI3DMiY,593
 u_toolkit/sqlalchemy/orm/models.py,sha256=V8vf4ps3phAmwxyaFYK7pw8Igz7h097o4QBjKB0gwC8,705
-u_toolkit-0.1.11.dist-info/METADATA,sha256=XqvuAjDSFm1JLYjz-ag0CVE3gmJ8EKs8BbGRk92yb6o,366
-u_toolkit-0.1.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-u_toolkit-0.1.11.dist-info/entry_points.txt,sha256=hTfAYCd5vvRiqgnJk2eBsoRIiIVB9pK8WZm3Q3jjKFU,45
-u_toolkit-0.1.11.dist-info/RECORD,,
+u_toolkit-0.1.13.dist-info/METADATA,sha256=CumVE1W_bIzTbM-fYPfOcaBFmEcT1rgWVwXF288NuGQ,366
+u_toolkit-0.1.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+u_toolkit-0.1.13.dist-info/entry_points.txt,sha256=hTfAYCd5vvRiqgnJk2eBsoRIiIVB9pK8WZm3Q3jjKFU,45
+u_toolkit-0.1.13.dist-info/RECORD,,