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

u_toolkit/__init__.py

@@ -1,9 +0,0 @@
-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/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/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/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/merge.py

@@ -1,7 +1,8 @@
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping
+from typing import overload
 
 
-def deep_merge_dict(
+def _merge_dict(
     target: dict,
     source: Mapping,
 ):
@@ -16,7 +17,9 @@ def deep_merge_dict(
         v = target.get(ok)
         # 如果两边都是映射类型, 就可以合并
         if isinstance(v, dict) and isinstance(ov, Mapping):
-            deep_merge_dict(v, ov)
+            _merge_dict(v, ov)
+        elif isinstance(v, list) and isinstance(ov, Iterable):
+            _merge_list(v, ov)
         # 如果当前值允许进行相加的操作
         # 并且不是字符串和数字
         # 并且旧字典与当前值类型相同
@@ -29,3 +32,58 @@ def deep_merge_dict(
         # 否则使用有效的值
         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/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/signature.py

@@ -1,6 +1,10 @@
 import inspect
 from collections.abc import Callable, Sequence
-from typing import Annotated, Any, overload
+from functools import partial, update_wrapper
+from typing import Annotated, Any, NamedTuple, overload
+
+
+class _Undefined: ...
 
 
 def list_parameters(fn: Callable, /) -> list[inspect.Parameter]:
@@ -8,31 +12,37 @@ def list_parameters(fn: Callable, /) -> list[inspect.Parameter]:
     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
-) -> tuple[list[inspect.Parameter], inspect.Parameter, int]: ...
+) -> WithParameterResult: ...
 @overload
 def with_parameter(
     fn: Callable, *, name: str, default: Any
-) -> tuple[list[inspect.Parameter], inspect.Parameter, int]: ...
+) -> WithParameterResult: ...
 @overload
 def with_parameter(
     fn: Callable, *, name: str, annotation: type | Annotated, default: Any
-) -> tuple[list[inspect.Parameter], inspect.Parameter, int]: ...
+) -> WithParameterResult: ...
 
 
 def with_parameter(
     fn: Callable,
     *,
     name: str,
-    annotation: type | Annotated | None = None,
-    default: Any = None,
-) -> tuple[list[inspect.Parameter], inspect.Parameter, int]:
+    annotation: type | Annotated | _Undefined = _Undefined,
+    default: Any = _Undefined,
+) -> WithParameterResult:
     kwargs = {}
-    if annotation is not None:
+    if annotation is not _Undefined:
         kwargs["annotation"] = annotation
-    if default is not None:
+    if default is not _Undefined:
         kwargs["default"] = default
 
     parameters = list_parameters(fn)
@@ -46,27 +56,55 @@ def with_parameter(
     else:
         parameters.append(parameter)
 
-    return parameters, parameter, index
+    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 = None,
-    return_annotation: type | None = None,
+    parameters: Sequence[inspect.Parameter] | None = _Undefined,  # type: ignore
+    return_annotation: type | None = _Undefined,
 ):
     signature = inspect.signature(fn)
-    if parameters is not None:
+    if parameters is not _Undefined:
         signature = signature.replace(parameters=parameters)
-    if return_annotation is not None:
+    if return_annotation is not _Undefined:
         signature = signature.replace(return_annotation=return_annotation)
 
     setattr(fn, "__signature__", signature)
 
 
-def update_parameters(fn: Callable, *parameters: inspect.Parameter):
+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, /):
+def update_return_annotation(
+    fn: Callable,
+    *,
+    return_annotation: type | None = _Undefined,
+):
     update_signature(fn, return_annotation=return_annotation)

u_toolkit-0.1.20.dist-info/METADATA

@@ -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.20.dist-info/RECORD

@@ -0,0 +1,14 @@
+u_toolkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+u_toolkit/datetime.py,sha256=GOG0xa6yKeqvFXJkImK5Pt7wsPXnHMlNKju8deniGJ4,644
+u_toolkit/decorators.py,sha256=rBZfXtWVfja6YMDqF9izjAiabRVyp4pAWOlwnN0HkUw,2396
+u_toolkit/enum.py,sha256=S0qsklSm7rc53W_gheTCpopej5eGOeCK-HKK_ryR2No,885
+u_toolkit/function.py,sha256=HgZcWd4IydNqUdUbS6A5pXVcAponGUZ2A8YKuiwHGjg,259
+u_toolkit/helpers.py,sha256=QSkDZH90FfuNB0hWI1GA2KHFk1ajZMzNBr7ysuBdFTg,161
+u_toolkit/merge.py,sha256=r_GhRIg5VHzXnqOVU9l0rpdT7XXV8FHWIp-nzP7-xnA,2550
+u_toolkit/naming.py,sha256=WLK-kYFJUFvUGYK7rJrL1uBVxwXNJPcDQqOidXEwkqU,2746
+u_toolkit/path.py,sha256=IkyIHcU9hKBCOZfF30FrKf4CfL-MH91fjeYF9EY7eos,128
+u_toolkit/signature.py,sha256=vyZgo4lXWD282Sq3Svn36peOrUlBHwl0QIGOBghczAc,2869
+u_toolkit-0.1.20.dist-info/METADATA,sha256=AHyOwnhZnOB1zNzOQNKZUQHvV6VB61YRq5E6J85_NkI,113
+u_toolkit-0.1.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+u_toolkit-0.1.20.dist-info/entry_points.txt,sha256=hTfAYCd5vvRiqgnJk2eBsoRIiIVB9pK8WZm3Q3jjKFU,45
+u_toolkit-0.1.20.dist-info/RECORD,,

u_toolkit/alias_generators.py

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