u-toolkit 0.1.0__tar.gz

u_toolkit-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

u_toolkit-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: u-toolkit
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.11.3
+Provides-Extra: fastapi
+Requires-Dist: pydantic-settings>=2.9.1; extra == 'fastapi'
+Provides-Extra: sqlalchemy
+Requires-Dist: sqlalchemy>=2.0.40; extra == 'sqlalchemy'

u_toolkit-0.1.0/pyproject.toml

@@ -0,0 +1,89 @@
+[project]
+name = "u-toolkit"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "pydantic>=2.11.3",
+]
+
+[project.scripts]
+u-toolkit = "u_toolkit:main"
+
+[project.optional-dependencies]
+sqlalchemy = [
+    "sqlalchemy>=2.0.40",
+]
+fastapi = [
+    "pydantic-settings>=2.9.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "devtools>=0.12.2",
+    "pytest>=8.3.5",
+    "ruff>=0.11.6",
+    "uvicorn>=0.34.2",
+]
+fastapi = [
+    "fastapi>=0.115.12",
+]
+
+
+
+[tool.ruff]
+line-length = 79
+fix = true
+
+[tool.ruff.format]
+quote-style = "double"
+skip-magic-trailing-comma = false
+docstring-code-format = true
+docstring-code-line-length = 72
+
+[tool.ruff.lint]
+# select = [
+#     "F", # Pyflakes
+#     "E", # pycodestyle
+#     "I", # isort
+#     "N", # pep8-naming
+#     "UP", # pyupgrade
+#     "B", # flake8-bugbear
+#     "A", # flake8-builtins,
+#     "DJ", # flake8-django
+#     "ISC", # flake8-implicit-str-concat
+#     "ICN", # flake8-import-conventions
+#     "SIM", # flake8-simplify
+#     "PTH", # flake8-use-pathlib
+# ]
+# ignore = ["E111", "E114", "E117", "B008", "ISC001"]
+select = ["ALL"]
+ignore = ["D", "ANN", "E114", "E117", "B008", "ISC001", "PGH003", "FA102", "PLW2901", "DTZ005", "COM812", "TCH", "TD", "FIX001", "FIX002", "S605", "S607", "S101", "RUF001", "EM101", "TRY003", "ERA001", "B010"]
+
+[tool.ruff.lint.per-file-ignores]
+"**/__init__.py" = ["F401"]
+"tests/**/*.py" = ["UP031", "E402"]
+"notebook/**/*.ipynb" = ["ALL"]
+"src/main.py" = ["F401"]
+
+# https://docs.astral.sh/ruff/settings/#lintflake8-errmsg
+# Maximum string length for string literals in exception messages.
+[tool.ruff.lint.flake8-errmsg]
+max-string-length = 20
+
+# https://docs.astral.sh/ruff/settings/#lintisort
+[tool.ruff.lint.isort]
+case-sensitive = true
+lines-after-imports = 2
+
+# https://docs.astral.sh/ruff/settings/#lint_pycodestyle_max-doc-length
+[tool.ruff.lint.pycodestyle]
+max-doc-length = 72
+
+[tool.ruff.lint.pylint]
+max-args = 8

u_toolkit-0.1.0/src/u_toolkit/__init__.py

@@ -0,0 +1,9 @@
+def get(obj: dict, key: str, fallback=None):
+    items = key.split(".", 1)
+    if len(items) > 1:
+        for i in items:
+            return get(obj, i, fallback)
+    elif items:
+        return obj.get(key, fallback)
+
+    return fallback

u_toolkit-0.1.0/src/u_toolkit/alias_generators.py

@@ -0,0 +1,49 @@
+from typing import TypeVarTuple, overload
+
+from pydantic import alias_generators
+from pydantic.fields import ComputedFieldInfo, FieldInfo
+
+
+Ts = TypeVarTuple("Ts")
+
+
+@overload
+def to_camel(string: str, _: ComputedFieldInfo | FieldInfo) -> str: ...
+
+
+@overload
+def to_camel(string: str) -> str: ...
+
+
+def to_camel(string: str, *_, **__):
+    if string.isupper():
+        return string
+    return alias_generators.to_camel(string)
+
+
+@overload
+def to_snake(string: str, _: ComputedFieldInfo | FieldInfo) -> str: ...
+
+
+@overload
+def to_snake(string: str) -> str: ...
+
+
+def to_snake(string: str, *_, **__):
+    if string.isupper():
+        return string
+    return alias_generators.to_snake(string)
+
+
+@overload
+def to_pascal(string: str, _: ComputedFieldInfo | FieldInfo) -> str: ...
+
+
+@overload
+def to_pascal(string: str) -> str: ...
+
+
+def to_pascal(string: str, *_, **__):
+    if string.isupper():
+        return string
+    return alias_generators.to_pascal(string)

u_toolkit-0.1.0/src/u_toolkit/datetime.py

@@ -0,0 +1,30 @@
+from datetime import UTC, datetime
+
+
+def to_utc(dt: datetime, /) -> datetime:
+    """转成 UTC 时间
+
+    :param dt: 时间
+    :return: UTC 时间
+    """
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=UTC)
+    return dt.astimezone(UTC)
+
+
+def to_naive(dt: datetime, /) -> datetime:
+    """去除时区标识
+
+    :param v: 时间
+    :return: 不带时区标识的时间
+    """
+    return dt.replace(tzinfo=None)
+
+
+def to_utc_naive(dt: datetime, /) -> datetime:
+    """将时间转换成不带时区标识的 UTC 时间
+
+    :param v: 时间
+    :return: 不带时区标识的 UTC 时间
+    """
+    return to_naive(to_utc(dt))

u_toolkit-0.1.0/src/u_toolkit/decorators.py

@@ -0,0 +1,46 @@
+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)
+
+_T = TypeVar("_T")
+
+
+class DefineMethodParams(NamedTuple, Generic[_T, _FnT]):
+    method_class: type[_T]
+    method_name: str
+    method: _FnT
+
+
+class DefineMethodDecorator(Generic[_T, _FnT]):
+    def __init__(self, fn: _FnT):
+        self.fn = fn
+        self.name = fn.__name__
+
+    def register_method(self, params: DefineMethodParams[_T, _FnT]): ...
+
+    def __set_name__(self, owner_class: type, name: str):
+        self.register_method(DefineMethodParams(owner_class, name, self.fn))
+
+    def __get__(self, instance: _T, owner_class: type[_T]):
+        update_parameters(self.fn, *list_parameters(self.fn)[1:])
+
+        @wraps(self.fn)
+        def wrapper(*args, **kwargs):
+            return self.fn(instance, *args, **kwargs)
+
+        return wrapper
+
+
+def define_method_handler(
+    handle: Callable[[DefineMethodParams[_T, _FnT]], None],
+):
+    class Decorator(DefineMethodDecorator):
+        def register_method(self, params: DefineMethodParams):
+            handle(params)
+
+    return Decorator

u_toolkit-0.1.0/src/u_toolkit/enum.py

@@ -0,0 +1,43 @@
+from enum import StrEnum, auto
+
+from .alias_generators import to_camel, to_pascal, to_snake
+
+
+__all__ = [
+    "CamelEnum",
+    "NameEnum",
+    "PascalEnum",
+    "SnakeEnum",
+    "TitleEnum",
+    "auto",
+]
+
+
+class NameEnum(StrEnum):
+    @staticmethod
+    def _generate_next_value_(name, *_, **__) -> str:
+        return name
+
+
+class PascalEnum(StrEnum):
+    @staticmethod
+    def _generate_next_value_(name, *_, **__) -> str:
+        return to_pascal(name)
+
+
+class CamelEnum(StrEnum):
+    @staticmethod
+    def _generate_next_value_(name, *_, **__) -> str:
+        return to_camel(name)
+
+
+class SnakeEnum(StrEnum):
+    @staticmethod
+    def _generate_next_value_(name, *_, **__) -> str:
+        return to_snake(name)
+
+
+class TitleEnum(StrEnum):
+    @staticmethod
+    def _generate_next_value_(name, *_, **__) -> str:
+        return name.replace("_", " ").title()

u_toolkit-0.1.0/src/u_toolkit/fastapi/cbv.py

@@ -0,0 +1,342 @@
+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 Any, Literal, NamedTuple, Protocol, Self, TypeVar, cast
+
+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 update_parameters, with_parameter
+
+
+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: ...
+
+
+_T = TypeVar("_T")
+EndpointsClassInterfaceT = TypeVar(
+    "EndpointsClassInterfaceT",
+    bound=EndpointsClassInterface,
+)
+
+
+LiteralUpperMethods = Literal[
+    "GET",
+    "POST",
+    "PATCH",
+    "PUT",
+    "DELETE",
+    "OPTIONS",
+    "HEAD",
+    "TRACE",
+]
+LiteralLowerMethods = 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()
+
+
+METHOD_PATTERNS = {
+    method: re.compile(f"^{method}", re.IGNORECASE) for method in Methods
+}
+
+_FnName = str
+
+
+class EndpointInfo(NamedTuple):
+    fn: Callable
+    original_name: str
+    method: Methods
+    method_pattern: re.Pattern
+    path: str
+
+
+def get_method(name: str):
+    for method, method_pattern in METHOD_PATTERNS.items():
+        if method_pattern.search(name):
+            return method, method_pattern
+    return None
+
+
+def valid_endpoint(name: str):
+    if get_method(name) is None:
+        raise ValueError("Invalid endpoint function.")
+
+
+def iter_endpoints(cls: type[_T]):
+    prefix = "/"
+
+    if not cls.__name__.startswith("_"):
+        prefix += f"{to_snake(cls.__name__)}"
+
+    for name, fn in inspect.getmembers(
+        cls,
+        lambda arg: inspect.ismethoddescriptor(arg) or inspect.isfunction(arg),
+    ):
+        paths = [prefix]
+
+        if method := get_method(name):
+            path = method[1].sub(name, "").replace("__", "/")
+            if path:
+                paths.append(path)
+
+            yield EndpointInfo(
+                fn=fn,
+                original_name=name,
+                path="/".join(paths),
+                method=method[0],
+                method_pattern=method[1],
+            )
+
+
+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
+
+
+_CBVEndpointParamName = Literal[
+    "tags",
+    "dependencies",
+    "responses",
+    "response_model",
+    "status",
+    "deprecated",
+    "methods",
+]
+
+
+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
+        ] = {}
+
+    def create_route(
+        self,
+        *,
+        cls: type[EndpointsClassInterfaceT],
+        path: str,
+        method: Methods | LiteralUpperMethods | LiteralLowerMethods,
+        method_name: str,
+    ):
+        class_tags = list(cls.tags) if cls.tags else []
+        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 []
+        endpoint_dependencies = (
+            self._state[cls][method_name].get("dependencies") or []
+        )
+        dependencies = class_dependencies + endpoint_dependencies
+
+        class_responses = cls.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", cls.deprecated
+        )
+
+        response_model = self._state[cls][method_name].get("response_model")
+
+        endpoint_methods = self._state[cls][method_name].get("methods") or [
+            method
+        ]
+
+        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,
+        )
+
+    def info(
+        self,
+        *,
+        methods: list[Methods | LiteralUpperMethods | LiteralLowerMethods]
+        | None = None,
+        tags: list[str | Enum] | None = None,
+        dependencies: list | None = None,
+        responses: list[Response] | None = None,
+        response_model: Any | None = None,
+        status: int | None = None,
+        deprecated: bool | None = None,
+    ):
+        state = self._state
+        initial_state = self._initial_state
+        data: dict[_CBVEndpointParamName, Any] = {
+            "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)
+            deep_merge_dict(
+                state,
+                {params.method_class: {params.method_name: data}},
+            )
+
+        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)
+
+        default_data = {}
+        for endpoint in iter_endpoints(n_cls):
+            default_data[endpoint.original_name] = {}
+
+        self._state.setdefault(n_cls, default_data)
+        result = self._build_cls(n_cls)
+        self._initialed_state[n_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
+        return cls()
+
+    def __create_class_dependencies_injector(
+        self, cls: type[EndpointsClassInterfaceT]
+    ):
+        """将类的依赖添加到函数实例上
+
+        ```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)
+        ]
+        update_parameters(collect_cls_dependencies, *parameters)
+
+        def decorator(method: Callable):
+            sign_fn = partial(method)
+            update_wrapper(sign_fn, method)
+
+            parameters, *_ = with_parameter(
+                method,
+                name=collect_cls_dependencies.__name__,
+                default=Depends(collect_cls_dependencies),
+            )
+            update_parameters(sign_fn, *parameters)
+
+            @wraps(sign_fn)
+            def wrapper(*args, **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)
+                fn = getattr(instance, method.__name__)
+                return fn(*args, **kwargs)
+
+            return wrapper
+
+        return decorator
+
+    def __call__(self, cls: type[_T]) -> type[_T]:
+        instance = self._initial_state(cls)
+        cls_ = cast(type[EndpointsClassInterface], cls)
+
+        decorator = self.__create_class_dependencies_injector(cls_)
+
+        for endpoint_info in iter_endpoints(cls):
+            route = self.create_route(
+                cls=cast(type[EndpointsClassInterface], cls),
+                path=endpoint_info.path,
+                method=endpoint_info.method,
+                method_name=endpoint_info.original_name,
+            )
+            method = getattr(instance, endpoint_info.original_name)
+            endpoint = decorator(method)
+            route(endpoint)
+
+        return cls

u_toolkit-0.1.0/src/u_toolkit/fastapi/config.py

@@ -0,0 +1,9 @@
+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",
+    )