u-toolkit 0.1.19__py3-none-any.whl → 0.1.20__py3-none-any.whl

u_toolkit/fastapi/cbv.py

@@ -1,440 +0,0 @@
-import inspect
-import re
-from collections.abc import Callable
-from enum import Enum, StrEnum, auto
-from functools import partial, update_wrapper, wraps
-from typing import (
-    Generic,
-    Literal,
-    NamedTuple,
-    NotRequired,
-    TypeVar,
-    TypedDict,
-    cast,
-    overload,
-)
-
-from fastapi import APIRouter, Depends
-from pydantic.alias_generators import to_snake
-
-from u_toolkit.decorators import DefineMethodParams, define_method_handler
-from u_toolkit.fastapi.helpers import get_depend_from_annotation, is_depend
-from u_toolkit.fastapi.responses import Response, build_responses
-from u_toolkit.helpers import is_annotated
-from u_toolkit.merge import deep_merge_dict
-from u_toolkit.signature import (
-    list_parameters,
-    update_parameters,
-    with_parameter,
-)
-
-
-_T = TypeVar("_T")
-
-
-LiteralUpperMethod = Literal[
-    "GET",
-    "POST",
-    "PATCH",
-    "PUT",
-    "DELETE",
-    "OPTIONS",
-    "HEAD",
-    "TRACE",
-]
-LiteralLowerMethod = Literal[
-    "get",
-    "post",
-    "patch",
-    "put",
-    "delete",
-    "options",
-    "head",
-    "trace",
-]
-
-
-class Methods(StrEnum):
-    GET = auto()
-    POST = auto()
-    PATCH = auto()
-    PUT = auto()
-    DELETE = auto()
-    OPTIONS = auto()
-    HEAD = auto()
-    TRACE = auto()
-
-
-RequestMethod = Methods | LiteralLowerMethod | LiteralUpperMethod
-
-
-METHOD_PATTERNS = {
-    method: re.compile(f"^({method}_|{method})", re.IGNORECASE)
-    for method in Methods
-}
-
-
-_FnName = str
-
-
-_MethodInfo = tuple[RequestMethod, re.Pattern[str]]
-
-
-def get_method(name: str) -> _MethodInfo | None:
-    for method, method_pattern in METHOD_PATTERNS.items():
-        if method_pattern.search(name):
-            return method, method_pattern
-    return None
-
-
-class EndpointInfo(NamedTuple):
-    handle: Callable
-    original_handle_name: str
-    handle_name: str
-    method: RequestMethod
-    method_pattern: re.Pattern
-    path: str
-
-
-def iter_endpoints(
-    cls: type[_T],
-    valid_method: Callable[[str, Callable], list[_MethodInfo] | None]
-    | None = None,
-):
-    prefix = ""
-
-    if not cls.__name__.startswith("_"):
-        prefix += f"/{to_snake(cls.__name__)}"
-
-    for name, handle in inspect.getmembers(
-        cls,
-        lambda arg: inspect.ismethoddescriptor(arg) or inspect.isfunction(arg),
-    ):
-        paths = [prefix]
-
-        methods: list[_MethodInfo] = []
-        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)
-
-        for method, pattern in methods:
-            handle_name = name if from_valid_method else pattern.sub("", name)
-            path = handle_name.replace("__", "/")
-            if path:
-                paths.append(path)
-
-            yield EndpointInfo(
-                handle=handle,
-                original_handle_name=name,
-                handle_name=handle_name,
-                path="/".join(paths),
-                method=method,
-                method_pattern=pattern,
-            )
-
-
-def iter_dependencies(cls: type[_T]):
-    _split = re.compile(r"\s+|:|=")
-    dependencies: dict = dict(inspect.getmembers(cls, is_depend))
-    for name, type_ in inspect.get_annotations(cls).items():
-        if is_annotated(type_):
-            dependency = get_depend_from_annotation(type_)
-            dependencies[name] = dependency
-
-    for line in inspect.getsource(cls).split("\n"):
-        token: str = _split.split(line.strip(), 1)[0]
-        for name, dep in dependencies.items():
-            if name == token:
-                yield token, dep
-
-
-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]
-
-
-CBVRoutesInfoT = TypeVar("CBVRoutesInfoT", bound=CBVRoutesInfo)
-
-
-class CBVRouteInfo(CBVRoutesInfo, Generic[_T]):
-    methods: NotRequired[list[RequestMethod] | None]
-    response_model: NotRequired[type[_T] | None]
-    status: NotRequired[int | None]
-    summary: NotRequired[str | None]
-    description: NotRequired[str | None]
-    name: NotRequired[str | None]
-
-
-class CBV(Generic[CBVRoutesInfoT]):
-    def __init__(self, router: APIRouter | None = None) -> None:
-        self.router = router or APIRouter()
-
-        self.state: dict[type, dict[_FnName, CBVRouteInfo]] = {}
-        self.routes_extra: dict[
-            type,
-            tuple[
-                CBVRoutesInfoT | None,
-                Callable[[type[_T]], _T] | None,  # type: ignore
-            ],
-        ] = {}
-        self.initialed_state: dict[type[_T], _T] = {}  # type: ignore
-
-    def create_route(
-        self,
-        *,
-        cls: type[_T],
-        path: str,
-        method: RequestMethod,
-        method_name: str,
-    ):
-        class_routes_info = self.routes_extra[cls][0] or {}
-
-        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 = class_routes_info.get("dependencies") or []
-        endpoint_dependencies = (
-            self.state[cls][method_name].get("dependencies") or []
-        )
-        dependencies = class_dependencies + endpoint_dependencies
-
-        class_responses = class_routes_info.get("responses") or []
-        endpoint_responses = (
-            self.state[cls][method_name].get("responses") or []
-        )
-        responses = build_responses(*class_responses, *endpoint_responses)
-
-        status_code = self.state[cls][method_name].get("status")
-
-        deprecated = self.state[cls][method_name].get(
-            "deprecated", class_routes_info.get("deprecated")
-        )
-
-        response_model = self.state[cls][method_name].get("response_model")
-
-        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
-
-        summary = self.state[cls][method_name].get("summary")
-        description = self.state[cls][method_name].get("description")
-        name = self.state[cls][method_name].get("name")
-        return self.router.api_route(
-            path,
-            methods=endpoint_methods,
-            tags=tags,
-            dependencies=dependencies,
-            response_model=response_model,
-            responses=responses,
-            status_code=status_code,
-            deprecated=deprecated,
-            summary=summary,
-            description=description,
-            name=name,
-        )
-
-    def info(  # noqa: PLR0913
-        self,
-        *,
-        path: str | None = None,
-        methods: list[RequestMethod] | None = None,
-        tags: list[str | Enum] | None = None,
-        dependencies: list | None = None,
-        responses: list[Response] | None = None,
-        response_model: type[_T] | None = None,
-        summary: str | None = None,
-        description: str | None = None,
-        name: str | None = None,
-        status: int | None = None,
-        deprecated: bool | None = None,
-    ):
-        state = self.state
-        initial_state = self._initial_state
-        data = CBVRouteInfo(
-            path=path,
-            methods=methods,
-            tags=tags,
-            dependencies=dependencies,
-            responses=responses,
-            response_model=response_model,
-            status=status,
-            deprecated=deprecated,
-            summary=summary,
-            description=description,
-            name=name,
-        )
-
-        def handle(params: DefineMethodParams):
-            initial_state(params.method_class)
-            deep_merge_dict(
-                state,
-                {params.method_class: {params.method_name: data}},
-            )
-
-        return define_method_handler(handle)
-
-    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(cls):
-            default_data[endpoint.original_handle_name] = {}
-
-        self.state.setdefault(cls, default_data)
-        result = self._build_cls(cls)
-        self.initialed_state[cls] = result
-        return result
-
-    def _build_cls(self, cls: type[_T]) -> _T:
-        if cls in self.routes_extra and (build := self.routes_extra[cls][1]):
-            return build(cls)  # type: ignore
-        return cls()
-
-    def __create_class_dependencies_injector(self, cls: type[_T]):
-        """将类的依赖添加到函数实例上
-
-        ```python
-        @cbv
-        class A:
-            a = Depends(lambda: id(object()))
-
-            def get(self):
-                # 使得每次 self.a 可以访问到当前请求的依赖
-                print(self.a)
-        ```
-        """
-
-        def collect_cls_dependencies(**kwargs):
-            return kwargs
-
-        parameters = [
-            inspect.Parameter(
-                name=name,
-                kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                default=dep,
-            )
-            for name, dep in iter_dependencies(cls)
-        ]
-
-        has_cls_deps = bool(parameters)
-        if has_cls_deps:
-            update_parameters(collect_cls_dependencies, *parameters)
-
-        def new_fn(method_name, kwargs):
-            instance = self._build_cls(cls)
-            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)
-
-        def decorator(method: Callable):
-            method_name = method.__name__
-
-            cls_fn = getattr(cls, method_name)
-            sign_cls_fn = partial(cls_fn)
-            update_wrapper(sign_cls_fn, cls_fn)
-
-            if has_cls_deps:
-                parameters, *_ = with_parameter(
-                    sign_cls_fn,
-                    name=collect_cls_dependencies.__name__,
-                    default=Depends(collect_cls_dependencies),
-                )
-            else:
-                parameters = list_parameters(sign_cls_fn)
-
-            update_parameters(sign_cls_fn, *(parameters[1:]))
-
-            if inspect.iscoroutinefunction(method):
-
-                @wraps(sign_cls_fn)
-                async def awrapper(*args, **kwargs):
-                    fn = new_fn(method_name, kwargs)
-                    return await fn(*args, **kwargs)
-
-                return awrapper
-
-            @wraps(sign_cls_fn)
-            def wrapper(*args, **kwargs):
-                fn = new_fn(method_name, kwargs)
-                return fn(*args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-    @overload
-    def __call__(self, cls: type[_T], /) -> type[_T]: ...
-    @overload
-    def __call__(
-        self,
-        *,
-        info: CBVRoutesInfoT | None = None,
-        build: Callable[[type[_T]], _T] | None = None,
-    ) -> Callable[[type[_T]], type[_T]]: ...
-
-    def __call__(self, *args, **kwargs):
-        info = None
-        build: Callable | None = None
-
-        def decorator(cls: type[_T]) -> type[_T]:
-            instance = self._initial_state(cls)
-            self.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)
-
-            return cls
-
-        if args:
-            return decorator(args[0])
-
-        info = kwargs.get("info") or None
-        build = kwargs.get("build")
-
-        return decorator

u_toolkit/fastapi/config.py

@@ -1,9 +0,0 @@
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class FastAPISettings(BaseSettings):
-    model_config = SettingsConfigDict(
-        env_prefix="FASTAPI_",
-        env_file=(".env", ".env.prod", ".env.dev", ".env.test"),
-        extra="ignore",
-    )

u_toolkit/fastapi/exception.py

@@ -1,163 +0,0 @@
-import inspect
-from collections.abc import Callable, Sequence
-from typing import Any, Generic, Literal, Protocol, TypeVar, cast
-
-from fastapi import Response, status
-from fastapi.responses import JSONResponse, ORJSONResponse
-from fastapi.utils import is_body_allowed_for_status_code
-from pydantic import BaseModel, create_model
-
-from u_toolkit.pydantic.type_vars import BaseModelT
-
-
-try:
-    import orjson  # type: ignore
-except ImportError:  # pragma: nocover
-    orjson = None  # type: ignore
-
-
-class WrapperError(BaseModel, Generic[BaseModelT]):
-    @classmethod
-    def create(
-        cls: type["WrapperError[BaseModelT]"],
-        model: BaseModelT,
-    ) -> "WrapperError[BaseModelT]":
-        raise NotImplementedError
-
-
-WrapperErrorT = TypeVar("WrapperErrorT", bound=WrapperError)
-
-
-class EndpointError(WrapperError[BaseModelT], Generic[BaseModelT]):
-    error: BaseModelT
-
-    @classmethod
-    def create(cls, model: BaseModelT):
-        return cls(error=model)
-
-
-class HTTPErrorInterface(Protocol):
-    status: int
-
-    @classmethod
-    def response_class(cls) -> type[BaseModel]: ...
-
-
-class NamedHTTPError(Exception, Generic[WrapperErrorT, BaseModelT]):
-    status: int = status.HTTP_400_BAD_REQUEST
-    code: str | None = None
-    targets: Sequence[Any] | None = None
-    target_transform: Callable[[Any], Any] | None = None
-    message: str | None = None
-    wrapper: (
-        type[WrapperError[BaseModelT]]
-        | tuple[WrapperErrorT, Callable[[BaseModelT], WrapperErrorT]]
-        | None
-    ) = None
-
-    @classmethod
-    def error_name(cls):
-        return cls.__name__.removesuffix("Error")
-
-    @classmethod
-    def model_class(cls) -> type[BaseModelT]:
-        type_ = cls.error_name()
-        error_code = cls.code or type_
-        kwargs = {
-            "code": (Literal[error_code], ...),
-            "message": (Literal[cls.message] if cls.message else str, ...),
-        }
-        if cls.targets:
-            kwargs["target"] = (Literal[*cls.transformed_targets()], ...)
-
-        return cast(type[BaseModelT], create_model(f"{type_}Model", **kwargs))
-
-    @classmethod
-    def error_code(cls):
-        return cls.code or cls.error_name()
-
-    @classmethod
-    def transformed_targets(cls) -> list[str]:
-        if cls.targets:
-            result = []
-            for i in cls.targets:
-                if cls.target_transform:
-                    result.append(cls.target_transform(i))
-                else:
-                    result.append(i)
-            return result
-        return []
-
-    def __init__(
-        self,
-        *,
-        message: str | None = None,
-        target: str | None = None,
-        headers: dict[str, str] | None = None,
-    ) -> None:
-        kwargs: dict[str, Any] = {
-            "code": self.error_code(),
-            "message": message or self.message or "operation failed",
-        }
-
-        if target:
-            if self.target_transform:
-                target = self.target_transform(target)
-            kwargs["target"] = target
-            kwargs["message"] = kwargs["message"].format(target=target)
-
-        self.model = self.model_class()(**kwargs)
-        create: Callable[[BaseModelT], BaseModel] | None = None
-        if inspect.isclass(self.wrapper):
-            create = self.wrapper.create
-        elif isinstance(self.wrapper, tuple):
-            create = self.wrapper[1]
-        self.data: BaseModel = (
-            create(self.model) if create is not None else self.model
-        )
-
-        self.headers = headers
-
-    def __str__(self) -> str:
-        return f"{self.status}: {self.data.error.code}"  # type: ignore
-
-    def __repr__(self) -> str:
-        return f"{self.model_class: str(self.error)}"
-
-    @classmethod
-    def response_class(cls):
-        model = cls.model_class()
-
-        if cls.wrapper:
-            wrapper: Any
-            if inspect.isclass(cls.wrapper):
-                wrapper = cls.wrapper
-            else:
-                wrapper = cls.wrapper[0]
-            return wrapper[model]
-
-        return model
-
-    @classmethod
-    def response_schema(cls):
-        return {cls.status: {"model": cls.response_class()}}
-
-
-def named_http_error_handler(_, exc: NamedHTTPError):
-    headers = exc.headers
-
-    if not is_body_allowed_for_status_code(exc.status):
-        return Response(status_code=exc.status, headers=headers)
-
-    if orjson:
-        return ORJSONResponse(
-            exc.data.model_dump(exclude_none=True),
-            status_code=exc.status,
-            headers=headers,
-        )
-
-    return JSONResponse(
-        exc.data.model_dump(exclude_none=True),
-        status_code=exc.status,
-        headers=headers,
-    )

u_toolkit/fastapi/helpers.py

@@ -1,18 +0,0 @@
-from typing import Annotated, Any, get_args
-
-from fastapi.params import Depends
-
-
-def is_depend(value: Any):
-    return isinstance(value, Depends)
-
-
-def get_depend_from_annotation(annotation: Annotated):
-    args = list(get_args(annotation))
-    # 因为 FastAPI 好像也是取最后的依赖运行的, 所以这里也将参数反转
-    args.reverse()
-    for arg in args:
-        if is_depend(arg):
-            return arg
-
-    raise ValueError

u_toolkit/fastapi/lifespan.py

@@ -1,67 +0,0 @@
-import asyncio
-from collections.abc import Awaitable, Callable, Coroutine
-from contextlib import (
-    AbstractAsyncContextManager,
-    AbstractContextManager,
-    AsyncExitStack,
-    asynccontextmanager,
-)
-from typing import TypeVar
-
-from fastapi import FastAPI
-
-
-Hook = Callable[
-    [FastAPI],
-    Awaitable[None] | Coroutine[None, None, None] | None,
-]
-
-HookT = TypeVar("HookT", bound=Hook)
-
-ContextManager = Callable[
-    [FastAPI],
-    AbstractContextManager | AbstractAsyncContextManager,
-]
-
-ContextManagerT = TypeVar("ContextManagerT", bound=ContextManager)
-
-
-class Lifespan:
-    def __init__(self) -> None:
-        self._startup_hooks: list[Hook] = []
-        self._shutdown_hooks: list[Hook] = []
-        self._context_managers: list[ContextManager] = []
-
-    def on_startup(self, fn: HookT) -> HookT:
-        self._startup_hooks.append(fn)
-        return fn
-
-    def on_shutdown(self, fn: HookT) -> HookT:
-        self._shutdown_hooks.append(fn)
-        return fn
-
-    def on_context(self, fn: ContextManagerT) -> ContextManagerT:
-        self._context_managers.append(fn)
-        return fn
-
-    @asynccontextmanager
-    async def __call__(self, _app: FastAPI):
-        for hook in self._startup_hooks:
-            ret = hook(_app)
-            if asyncio.iscoroutine(ret):
-                await ret
-
-        async with AsyncExitStack() as stack:
-            for ctx in self._context_managers:
-                i = ctx(_app)
-                if isinstance(i, AbstractContextManager):
-                    stack.enter_context(i)
-                elif isinstance(i, AbstractAsyncContextManager):
-                    await stack.enter_async_context(i)
-
-            yield
-
-        for hook in self._shutdown_hooks:
-            ret = hook(_app)
-            if asyncio.iscoroutine(ret):
-                await ret