u-toolkit 0.1.11__tar.gz → 0.1.13__tar.gz

{u_toolkit-0.1.11 → u_toolkit-0.1.13}/PKG-INFO

@@ -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 → u_toolkit-0.1.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "u-toolkit"
-version = "0.1.11"
+version = "0.1.13"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -30,6 +30,7 @@ dev = [
     "httpx>=0.28.1",
     "pytest>=8.3.5",
     "python-multipart>=0.0.20",
+    "rich>=14.0.0",
     "ruff>=0.11.6",
     "uvicorn>=0.34.2",
 ]

{u_toolkit-0.1.11 → u_toolkit-0.1.13}/src/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-0.1.11 → u_toolkit-0.1.13}/src/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 → u_toolkit-0.1.13}/tests/fastapi/test_cbv.py

@@ -83,7 +83,8 @@ class _NoPath:
         return data.username
 
     @cbv.info(methods=["DELETE"])
-    async def wtf(self):
+    async def post_wtf(self):
+        await asyncio.sleep(1)
         return 1
 
 
@@ -107,8 +108,9 @@ def test_cbv():
     value = "example"
     assert (
         client.post(
-            "/",
+            "/alala",
             data={"username": value, "password": value},
         ).json()
         == value
     )
+    assert client.delete("/post_wtf").json() == 1

{u_toolkit-0.1.11 → u_toolkit-0.1.13}/uv.lock

@@ -202,6 +202,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 },
 ]
 
+[[package]]
+name = "markdown-it-py"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 },
+]
+
 [[package]]
 name = "packaging"
 version = "25.0"
@@ -356,6 +377,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546 },
 ]
 
+[[package]]
+name = "rich"
+version = "14.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/53/830aa4c3066a8ab0ae9a9955976fb770fe9c6102117c8ec4ab3ea62d89e8/rich-14.0.0.tar.gz", hash = "sha256:82f1bc23a6a21ebca4ae0c45af9bdbc492ed20231dcb63f297d6d1021a9d5725", size = 224078 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0d/9b/63f4c7ebc259242c89b3acafdb37b41d1185c07ff0011164674e9076b491/rich-14.0.0-py3-none-any.whl", hash = "sha256:1c9491e1951aac09caffd42f448ee3d04e58923ffe14993f6e83068dc395d7e0", size = 243229 },
+]
+
 [[package]]
 name = "ruff"
 version = "0.11.6"
@@ -471,7 +505,7 @@ wheels = [
 
 [[package]]
 name = "u-toolkit"
-version = "0.1.1"
+version = "0.1.12"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },
@@ -492,6 +526,7 @@ dev = [
     { name = "httpx" },
     { name = "pytest" },
     { name = "python-multipart" },
+    { name = "rich" },
     { name = "ruff" },
     { name = "uvicorn" },
 ]
@@ -511,6 +546,7 @@ dev = [
     { name = "httpx", specifier = ">=0.28.1" },
     { name = "pytest", specifier = ">=8.3.5" },
     { name = "python-multipart", specifier = ">=0.0.20" },
+    { name = "rich", specifier = ">=14.0.0" },
     { name = "ruff", specifier = ">=0.11.6" },
     { name = "uvicorn", specifier = ">=0.34.2" },
 ]