u-toolkit 0.1.18__tar.gz → 0.1.20__tar.gz

u_toolkit-0.1.20/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: u-toolkit
+Version: 0.1.20
+Summary: Add your description here
+Requires-Python: >=3.11

{u_toolkit-0.1.18 → u_toolkit-0.1.20}/pyproject.toml

@@ -1,25 +1,15 @@
 [project]
 name = "u-toolkit"
-version = "0.1.18"
+version = "0.1.20"
 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 = [
-    "fastapi>=0.115.12",
-    "pydantic-settings>=2.9.1",
-]
-
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
@@ -27,12 +17,9 @@ build-backend = "hatchling.build"
 [dependency-groups]
 dev = [
     "devtools>=0.12.2",
-    "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.18 → u_toolkit-0.1.20}/src/u_toolkit/enum.py

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

{u_toolkit-0.1.18 → u_toolkit-0.1.20}/src/u_toolkit/function.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 
 
-def get_name(fn: Callable, /):
+def get_name(fn: Callable, /) -> str:
     return fn.__name__
 
 

{u_toolkit-0.1.18 → u_toolkit-0.1.20}/src/u_toolkit/helpers.py

@@ -2,4 +2,6 @@ from typing import Annotated, get_origin
 
 
 def is_annotated(target):
+    """判断值是否是 `typing.Annotated`"""
+
     return get_origin(target) is Annotated

u_toolkit-0.1.20/src/u_toolkit/merge.py

@@ -0,0 +1,89 @@
+from collections.abc import Iterable, Mapping
+from typing import overload
+
+
+def _merge_dict(
+    target: dict,
+    source: Mapping,
+):
+    """深层合并两个字典
+
+    :param target: 存放合并内容的字典
+    :param source: 来源, 因为不会修改, 所以只读映射就可以
+    :param exclude_keys: 需要排除的 keys
+    """
+
+    for ok, ov in source.items():
+        v = target.get(ok)
+        # 如果两边都是映射类型, 就可以合并
+        if isinstance(v, dict) and isinstance(ov, Mapping):
+            _merge_dict(v, ov)
+        elif isinstance(v, list) and isinstance(ov, Iterable):
+            _merge_list(v, ov)
+        # 如果当前值允许进行相加的操作
+        # 并且不是字符串和数字
+        # 并且旧字典与当前值类型相同
+        elif (
+            hasattr(v, "__add__")
+            and not isinstance(v, str | int)
+            and type(v) is type(ov)
+        ):
+            target[ok] = v + ov
+        # 否则使用有效的值
+        else:
+            target[ok] = v or ov
+
+
+def _merge_list(target: list, source: Iterable):
+    for oi, ov in enumerate(source):
+        try:
+            v = target[oi]
+        except IndexError:
+            target[oi] = ov
+            break
+
+        if isinstance(v, dict) and isinstance(ov, Mapping):
+            merge(v, ov)
+
+        elif isinstance(v, list) and isinstance(ov, Iterable):
+            _merge_list(v, ov)
+        # 如果当前值允许进行相加的操作
+        # 并且不是字符串和数字
+        # 并且旧字典与当前值类型相同
+        elif (
+            hasattr(v, "__add__")
+            and not isinstance(v, str | int)
+            and type(v) is type(ov)
+        ):
+            target[oi] = v + ov
+        else:
+            target[oi] = v or ov
+
+
+@overload
+def merge(target: list, source: Iterable): ...
+@overload
+def merge(target: dict, source: Mapping): ...
+
+
+def merge(target, source):
+    for ok, ov in source.items():
+        v = target.get(ok)
+
+        # 如果两边都是映射类型, 就可以合并
+        if isinstance(v, dict) and isinstance(ov, Mapping):
+            _merge_dict(v, ov)
+
+        # 如果当前值允许进行相加的操作
+        # 并且不是字符串和数字
+        # 并且旧字典与当前值类型相同
+        elif (
+            hasattr(v, "__add__")
+            and not isinstance(v, str | int)
+            and type(v) is type(ov)
+        ):
+            target[ok] = v + ov
+
+        # 否则使用有效的值
+        else:
+            target[ok] = v or ov

u_toolkit-0.1.20/src/u_toolkit/naming.py

@@ -0,0 +1,94 @@
+import re
+from collections.abc import Callable
+from typing import TypeVar, TypeVarTuple, overload
+
+
+__all__ = ("to_camel", "to_pascal", "to_snake")
+
+Ts = TypeVarTuple("Ts")
+T = TypeVar("T")
+
+
+def _arguments_handle(transform: Callable, *args, kwd_name: str, **kwds):
+    if len(args) > 1:
+        return tuple(transform(a) for a in args)
+
+    if args:
+        return transform(args[0])
+
+    return transform(kwds[kwd_name])
+
+
+@overload
+def to_pascal(snake: str) -> str: ...
+@overload
+def to_pascal(*snake: str) -> tuple[str, ...]: ...
+
+
+def to_pascal(*args, **kwds):
+    pattern = re.compile("([0-9A-Za-z])_(?=[0-9A-Z])")
+
+    def transform(arg: str) -> str:
+        camel = arg.title()
+        return pattern.sub(lambda m: m.group(1), camel)
+
+    return _arguments_handle(transform, *args, kwd_name="snake", **kwds)
+
+
+@overload
+def to_camel(snake: str) -> str: ...
+@overload
+def to_camel(*snake: str) -> tuple[str, ...]: ...
+
+
+def to_camel(*args, **kwds):
+    # If the string is already in camelCase and does not contain
+    # a digit followed by a lowercase letter, return it as it is
+    match_pattern = re.compile("^[a-z]+[A-Za-z0-9]*$")
+    search_pattern = re.compile(r"\d[a-z]")
+
+    def transform(arg: str):
+        if match_pattern.match(arg) and not search_pattern.search(arg):
+            return arg
+
+        camel = to_pascal(arg)
+        return re.sub("(^_*[A-Z])", lambda m: m.group(1).lower(), camel)
+
+    return _arguments_handle(transform, *args, kwd_name="snake", **kwds)
+
+
+@overload
+def to_snake(camel: str) -> str: ...
+@overload
+def to_snake(*camel: str) -> tuple[str, ...]: ...
+
+
+def to_snake(*args, **kwds):
+    """Convert a PascalCase, camelCase, kebab-case string to snake_case."""  # noqa: W505
+
+    # Handle the sequence of uppercase letters followed by
+    # a lowercase letter
+    def transform(arg: str):
+        snake = re.sub(
+            r"([A-Z]+)([A-Z][a-z])",
+            lambda m: f"{m.group(1)}_{m.group(2)}",
+            arg,
+        )
+        # Insert an underscore between a lowercase letter and
+        # an uppercase letter
+        snake = re.sub(
+            r"([a-z])([A-Z])", lambda m: f"{m.group(1)}_{m.group(2)}", snake
+        )
+        # Insert an underscore between a digit and an uppercase letter
+        snake = re.sub(
+            r"([0-9])([A-Z])", lambda m: f"{m.group(1)}_{m.group(2)}", snake
+        )
+        # Insert an underscore between a lowercase letter and a digit
+        snake = re.sub(
+            r"([a-z])([0-9])", lambda m: f"{m.group(1)}_{m.group(2)}", snake
+        )
+        # Replace hyphens with underscores to handle kebab-case
+        snake = snake.replace("-", "_")
+        return snake.lower()
+
+    return _arguments_handle(transform, *args, kwd_name="camel", **kwds)

u_toolkit-0.1.20/src/u_toolkit/signature.py

@@ -0,0 +1,110 @@
+import inspect
+from collections.abc import Callable, Sequence
+from functools import partial, update_wrapper
+from typing import Annotated, Any, NamedTuple, overload
+
+
+class _Undefined: ...
+
+
+def list_parameters(fn: Callable, /) -> list[inspect.Parameter]:
+    signature = inspect.signature(fn)
+    return list(signature.parameters.values())
+
+
+class WithParameterResult(NamedTuple):
+    parameters: list[inspect.Parameter]
+    parameter: inspect.Parameter
+    parameter_index: int
+
+
+@overload
+def with_parameter(
+    fn: Callable, *, name: str, annotation: type | Annotated
+) -> WithParameterResult: ...
+@overload
+def with_parameter(
+    fn: Callable, *, name: str, default: Any
+) -> WithParameterResult: ...
+@overload
+def with_parameter(
+    fn: Callable, *, name: str, annotation: type | Annotated, default: Any
+) -> WithParameterResult: ...
+
+
+def with_parameter(
+    fn: Callable,
+    *,
+    name: str,
+    annotation: type | Annotated | _Undefined = _Undefined,
+    default: Any = _Undefined,
+) -> WithParameterResult:
+    kwargs = {}
+    if annotation is not _Undefined:
+        kwargs["annotation"] = annotation
+    if default is not _Undefined:
+        kwargs["default"] = default
+
+    parameters = list_parameters(fn)
+    parameter = inspect.Parameter(
+        name=name, kind=inspect.Parameter.KEYWORD_ONLY, **kwargs
+    )
+    index = -1
+    if parameters and parameters[index].kind == inspect.Parameter.VAR_KEYWORD:
+        parameters.insert(index, parameter)
+        index = -2
+    else:
+        parameters.append(parameter)
+
+    return WithParameterResult(parameters, parameter, index)
+
+
+def add_parameter(
+    fn: Callable,
+    *,
+    name: str,
+    annotation: type | Annotated = _Undefined,
+    default: Any = _Undefined,
+):
+    """添加参数, 会将添加参数后的新函数返回"""
+    p = with_parameter(
+        fn,
+        name=name,
+        annotation=annotation,
+        default=default,
+    )
+
+    new_fn = update_wrapper(partial(fn), fn)
+    update_parameters(fn, parameters=p.parameters)
+    return new_fn
+
+
+def update_signature(
+    fn: Callable,
+    *,
+    parameters: Sequence[inspect.Parameter] | None = _Undefined,  # type: ignore
+    return_annotation: type | None = _Undefined,
+):
+    signature = inspect.signature(fn)
+    if parameters is not _Undefined:
+        signature = signature.replace(parameters=parameters)
+    if return_annotation is not _Undefined:
+        signature = signature.replace(return_annotation=return_annotation)
+
+    setattr(fn, "__signature__", signature)
+
+
+def update_parameters(
+    fn: Callable,
+    *,
+    parameters: Sequence[inspect.Parameter] | None = _Undefined,  # type: ignore
+):
+    update_signature(fn, parameters=parameters)
+
+
+def update_return_annotation(
+    fn: Callable,
+    *,
+    return_annotation: type | None = _Undefined,
+):
+    update_signature(fn, return_annotation=return_annotation)

u_toolkit-0.1.20/tests/test_enum.py

@@ -0,0 +1,130 @@
+from u_toolkit import enum
+
+
+def test_name_enum():
+    class _Enum(enum.NameEnum):
+        A = enum.auto()
+        Ab = enum.auto()
+        AbC = enum.auto()
+        ABCD = enum.auto()
+        ABCD_E = enum.auto()
+        aa = enum.auto()
+        a_a = enum.auto()
+        a2 = enum.auto()
+        Bb = enum.auto()
+        c_ = enum.auto()
+
+    assert _Enum.A == "A"
+    assert _Enum.Ab == "Ab"
+    assert _Enum.AbC == "AbC"
+    assert _Enum.ABCD == "ABCD"
+    assert _Enum.ABCD_E == "ABCD_E"
+    assert _Enum.aa == "aa"
+    assert _Enum.a_a == "a_a"
+    assert _Enum.a2 == "a2"
+    assert _Enum.Bb == "Bb"
+    assert _Enum.c_ == "c_"
+
+
+def test_pascal_enum():
+    class _Enum(enum.PascalEnum):
+        A = enum.auto()
+        Ab = enum.auto()
+        AbC = enum.auto()
+        ABCD = enum.auto()
+        ABCD_E = enum.auto()
+        aa = enum.auto()
+        a_a = enum.auto()
+        a2 = enum.auto()
+        Bb = enum.auto()
+        c_ = enum.auto()
+
+    assert _Enum.A == "A"
+    assert _Enum.Ab == "Ab"
+    assert _Enum.AbC == "Abc"
+    assert _Enum.ABCD == "ABCD"
+    assert _Enum.ABCD_E == "ABCD_E"
+    assert _Enum.aa == "Aa"
+    assert _Enum.a_a == "AA"
+    assert _Enum.a2 == "A2"
+    assert _Enum.Bb == "Bb"
+    assert _Enum.c_ == "C_"
+
+
+def test_camel_enum():
+    class _Enum(enum.CamelEnum):
+        A = enum.auto()
+        Ab = enum.auto()
+        AbC = enum.auto()
+        ABCD = enum.auto()
+        ABCD_E = enum.auto()
+        aa = enum.auto()
+        a_a = enum.auto()
+        a2 = enum.auto()
+        Bb = enum.auto()
+        c_ = enum.auto()
+
+    assert _Enum.A == "A"
+    assert _Enum.Ab == "ab"
+    assert _Enum.AbC == "abc"
+    assert _Enum.ABCD == "ABCD"
+    assert _Enum.ABCD_E == "ABCD_E"
+    assert _Enum.aa == "aa"
+    assert _Enum.a_a == "aA"
+    assert _Enum.a2 == "a2"
+    assert _Enum.Bb == "bb"
+    assert _Enum.c_ == "c_"
+
+
+def test_snake_enum():
+    class _Enum(enum.SnakeEnum):
+        A = enum.auto()
+        Ab = enum.auto()
+        AbC = enum.auto()
+        ABCD = enum.auto()
+        ABCD_E = enum.auto()
+        aa = enum.auto()
+        a_a = enum.auto()
+        a2 = enum.auto()
+        aa3 = enum.auto()
+        Bb = enum.auto()
+        c_ = enum.auto()
+
+    assert _Enum.A == "A"
+    assert _Enum.Ab == "ab"
+    assert _Enum.AbC == "ab_c"
+    assert _Enum.ABCD == "ABCD"
+    assert _Enum.ABCD_E == "ABCD_E"
+    assert _Enum.aa == "aa"
+    assert _Enum.a_a == "a_a"
+    assert _Enum.a2 == "a_2"
+    assert _Enum.aa3 == "aa_3"
+    assert _Enum.Bb == "bb"
+    assert _Enum.c_ == "c_"
+
+
+def test_title_enum():
+    class _Enum(enum.TitleEnum):
+        A = enum.auto()
+        Ab = enum.auto()
+        AbC = enum.auto()
+        ABCD = enum.auto()
+        ABCD_E = enum.auto()
+        aa = enum.auto()
+        a_a = enum.auto()
+        a2 = enum.auto()
+        aa3 = enum.auto()
+        Bb = enum.auto()
+        c_ = enum.auto()
+
+    assert _Enum.A == "A"
+    assert _Enum.Ab == "Ab"
+    assert _Enum.AbC == "Abc"
+    assert _Enum.ABCD == "Abcd"
+    assert _Enum.ABCD_E == "Abcd E"
+    assert _Enum.aa == "Aa"
+    assert _Enum.a_a == "A A"
+    assert _Enum.a2 == "A2"
+    assert _Enum.aa3 == "Aa3"
+    assert _Enum.Bb == "Bb"
+    assert _Enum.c_ == "C"

u_toolkit-0.1.20/tests/test_function.py

@@ -0,0 +1,26 @@
+from u_toolkit import function
+
+
+def test_get_name():
+    def fn(): ...
+
+    assert function.get_name(fn) == "fn"
+    assert function.get_name(lambda: 1) == "<lambda>"
+
+
+def test_add_document():
+    def fn(): ...
+
+    assert fn.__doc__ is None
+
+    function.add_document(fn, "lalala")
+
+    assert fn.__doc__ == "lalala"
+
+    def fn2():
+        """2333"""
+
+    assert fn2.__doc__ == "2333"
+
+    function.add_document(fn2, "lalala")
+    assert fn2.__doc__ == "2333\n\nlalala"

u_toolkit-0.1.20/tests/test_helpers.py

@@ -0,0 +1,13 @@
+from typing import Annotated
+
+from u_toolkit import helpers
+
+
+def test_is_annotated():
+    assert helpers.is_annotated(type) is False
+    assert helpers.is_annotated(int) is False
+    assert helpers.is_annotated(object()) is False
+    assert helpers.is_annotated(Annotated) is False
+    assert helpers.is_annotated(Annotated[int, 1]) is True
+    assert helpers.is_annotated(Annotated[int, type]) is True
+    assert helpers.is_annotated(Annotated[int, object()]) is True