pythonwrench 0.6.0__tar.gz → 0.6.2__tar.gz

{pythonwrench-0.6.0/src/pythonwrench.egg-info → pythonwrench-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonwrench
-Version: 0.6.0
+Version: 0.6.2
 Summary: Python library with tools for typing, manipulating collections, and more!
 Author-email: "Étienne Labbé (Labbeti)" <labbeti.pub@gmail.com>
 Maintainer-email: "Étienne Labbé (Labbeti)" <labbeti.pub@gmail.com>

{pythonwrench-0.6.0 → pythonwrench-0.6.2}/pyproject.toml

@@ -45,6 +45,9 @@ Tracker = "https://github.com/Labbeti/pythonwrench/issues"
 pythonwrench-info = "pythonwrench.entrypoints.info:main_info"
 pythonwrench-tree = "pythonwrench.entrypoints.tree:main_tree"
 pythonwrench-safe-rmdir = "pythonwrench.entrypoints.safe_rmdir:main_safe_rmdir"
+pw-info = "pythonwrench.entrypoints.info:main_info"
+pw-tree = "pythonwrench.entrypoints.tree:main_tree"
+pw-safe-rmdir = "pythonwrench.entrypoints.safe_rmdir:main_safe_rmdir"
 pyw-info = "pythonwrench.entrypoints.info:main_info"
 pyw-tree = "pythonwrench.entrypoints.tree:main_tree"
 pyw-safe-rmdir = "pythonwrench.entrypoints.safe_rmdir:main_safe_rmdir"

{pythonwrench-0.6.0 → pythonwrench-0.6.2}/src/pythonwrench/__init__.py

@@ -9,7 +9,7 @@ __author_email__ = "labbeti.pub@gmail.com"
 __license__ = "MIT"
 __maintainer__ = "Étienne Labbé (Labbeti)"
 __status__ = "Development"
-__version__ = "0.6.0"
+__version__ = "0.6.2"
 
 
 from typing import TYPE_CHECKING
@@ -51,6 +51,7 @@ if TYPE_CHECKING or lazy is None:
     # Global library imports
     from .abc import Singleton
     from .argparse import (
+        add_dataclass_fields_to_parser,
         new_parser_from_dataclass,
         parse_args_using_dataclass,
         parse_to,
@@ -100,7 +101,7 @@ if TYPE_CHECKING or lazy is None:
         union_lists,
         unzip,
     )
-    from .dataclasses import get_defaults_values
+    from .dataclasses import add_dict_methods, dataclassdict, get_defaults_values
     from .datetime import get_now, get_now_iso8601
     from .difflib import find_closest_in_list, sequence_matcher_ratio
     from .disk_cache import disk_cache_call, disk_cache_decorator
@@ -115,7 +116,9 @@ if TYPE_CHECKING or lazy is None:
     )
     from .hashlib import hash_file
     from .importlib import (
+        ModulePlaceholder,
         Placeholder,
+        import_if_available,
         is_available_package,
         is_editable_package,
         reload_editable_packages,
@@ -216,6 +219,7 @@ if TYPE_CHECKING or lazy is None:
         is_builtin_scalar,
         is_collection_alias,
         is_dataclass_instance,
+        is_dataclass_type,
         is_iterable_bool,
         is_iterable_bytes_or_list,
         is_iterable_float,
@@ -264,6 +268,7 @@ else:
         ],
         submod_attrs={
             "argparse": [
+                "add_dataclass_fields_to_parser",
                 "new_parser_from_dataclass",
                 "parse_args_using_dataclass",
                 "parse_to",
@@ -340,7 +345,7 @@ else:
                 "save_jsonl",
                 "save_pickle",
             ],
-            "dataclasses": ["get_defaults_values"],
+            "dataclasses": ["add_dict_methods", "dataclassdict", "get_defaults_values"],
             "datetime": ["get_now", "get_now_iso8601"],
             "difflib": ["find_closest_in_list", "sequence_matcher_ratio"],
             "disk_cache": ["disk_cache_call", "disk_cache_decorator"],
@@ -355,6 +360,8 @@ else:
             ],
             "hashlib": ["hash_file"],
             "importlib": [
+                "import_if_available",
+                "ModulePlaceholder",
                 "is_available_package",
                 "is_editable_package",
                 "reload_editable_packages",
@@ -430,6 +437,7 @@ else:
                 "is_builtin_scalar",
                 "is_collection_alias",
                 "is_dataclass_instance",
+                "is_dataclass_type",
                 "is_iterable_bool",
                 "is_iterable_bytes_or_list",
                 "is_iterable_float",

{pythonwrench-0.6.0 → pythonwrench-0.6.2}/src/pythonwrench/_core.py

@@ -22,6 +22,7 @@ T = TypeVar("T", covariant=True)
 U = TypeVar("U", covariant=True)
 T_Output = TypeVar("T_Output")
 T_Any = TypeVar("T_Any", contravariant=True, default=Any)
+T_Function = TypeVar("T_Function", bound=Callable[..., Any])
 
 UnkMode = Literal["identity", "error"]
 ClassOrTuple = Union[type, Tuple[type, ...]]
@@ -37,27 +38,31 @@ def return_none(*args, **kwargs) -> None:
 
 
 def _decorator_factory(
-    inner_fn: Optional[Callable[P, U]],
+    inner_fn: Optional[T_Function],
     *,
-    pre_fn: Callable[..., Any] = return_none,
-    post_fn: Callable[..., Any] = return_none,
-) -> Callable[[Callable[P, U]], Callable[P, U]]:
-    """Deprecated decorator for function aliases."""
-
-    def wrapper_factory(fn: Callable[P, U]) -> Callable[P, U]:
+    pre_fn: Optional[Callable[..., Any]] = None,
+    post_fn: Optional[Callable[..., Any]] = None,
+) -> Callable[[T_Function], T_Function]:
+    """Decorator for function aliases."""
+    if pre_fn is None:
+        pre_fn = return_none
+    if post_fn is None:
+        post_fn = return_none
+
+    def wrapper_factory(fn: T_Function) -> T_Function:
         if inner_fn is None:
             _inner_fn = fn
         else:
             _inner_fn = inner_fn
 
         @wraps(_inner_fn)
-        def wrapped(*args: P.args, **kwargs: P.kwargs) -> U:
+        def wrapped(*args, **kwargs):
             pre_fn(fn, *args, **kwargs)
             result = _inner_fn(*args, **kwargs)
             post_fn(fn, *args, **kwargs)
             return result
 
-        return wrapped
+        return wrapped  # type: ignore
 
     return wrapper_factory
 

{pythonwrench-0.6.0 → pythonwrench-0.6.2}/src/pythonwrench/argparse.py

@@ -1,7 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import re
 from argparse import ArgumentParser
+from collections.abc import Iterable as _Iterable
 from dataclasses import MISSING, fields
 from functools import partial
 from typing import (
@@ -12,6 +14,7 @@ from typing import (
     List,
     Literal,
     Optional,
+    Tuple,
     Type,
     TypeVar,
     Union,
@@ -25,13 +28,17 @@ except ImportError:
     # support older python versions
     UnionType = Any
 
+from pythonwrench.functools import filter_and_call
 from pythonwrench.typing.classes import Dataclass, DataclassInstance, NoneType
+from pythonwrench.warnings import deprecated_alias
 
 T = TypeVar("T")
 T_Dataclass = TypeVar("T_Dataclass", bound=Dataclass)
 T_DataclassInstance = TypeVar("T_DataclassInstance", bound=DataclassInstance)
-TargetType = Union[Type[T], UnionType, "Type[Literal]"]
-
+TargetType = Union[
+    Type[T], UnionType, "Type[Literal]", "Type[Optional]", Tuple[type, ...]
+]
+ListParsing = Literal["argparse", "brackets"]
 
 DEFAULT_TRUE_VALUES = ("True", "t", "yes", "y", "1")
 DEFAULT_FALSE_VALUES = ("False", "f", "no", "n", "0")
@@ -42,24 +49,44 @@ _SCALARS_TARGET_TYPES = (str, int, float, None, NoneType, bool)
 
 def parse_args_using_dataclass(
     dataclass_type: Type[T_DataclassInstance],
+    *,
     args: Optional[Iterable[str]] = None,
+    parser: Optional[ArgumentParser] = None,
+    list_parsing: ListParsing = "argparse",
+    add_dashed_arg: bool = True,
 ) -> T_DataclassInstance:
     """Converts prog args to a typed dataclass using argparse.
 
     Currently only supports dataclasses that contains only builtin scalars: str, int, float, None, bool OR list of builtin scalars.
     """
-    parser = ArgumentParser()
-    parser = new_parser_from_dataclass(dataclass_type, parser)
+    init_parser = parser
+    parser = add_dataclass_fields_to_parser(
+        dataclass_type,
+        parser=parser,
+        list_parsing=list_parsing,
+        add_dashed_arg=add_dashed_arg,
+    )
     parsed, argv = parser.parse_known_args(args)
     if len(argv) > 0:
         raise ValueError(f"Found {len(argv)} unknown arguments: {argv}.")
-    instance = dataclass_type(**parsed.__dict__)
+
+    if init_parser is None:
+        instance = dataclass_type(**parsed.__dict__)
+    else:
+        instance = filter_and_call(
+            dataclass_type,
+            _fill_all_arguments=True,
+            **parsed.__dict__,
+        )
     return instance
 
 
-def new_parser_from_dataclass(
+def add_dataclass_fields_to_parser(
     dataclass_type: Type[T_DataclassInstance],
+    *,
     parser: Optional[ArgumentParser],
+    list_parsing: ListParsing = "argparse",
+    add_dashed_arg: bool = True,
 ) -> ArgumentParser:
     if parser is None:
         parser = ArgumentParser()
@@ -67,6 +94,9 @@ def new_parser_from_dataclass(
     for field in fields(dataclass_type):
         kwds = {}
         posargs = [f"--{field.name}"]
+        if add_dashed_arg and "_" in field.name:
+            dashed_arg_name = field.name.replace("_", "-")
+            posargs.append(f"--{dashed_arg_name}")
 
         if field.default is MISSING and field.default_factory is MISSING:
             kwds["required"] = True
@@ -79,13 +109,26 @@ def new_parser_from_dataclass(
             msg = f"Invalid field {field.name}: found values for default and default_factory."
             raise ValueError(msg)
 
-        kwds.update(_get_kwds_for_type(field.type))
+        try:
+            inner_kwds = _get_kwds_for_type(field.type, list_parsing)
+        except (ValueError, TypeError, RuntimeError) as err:
+            msg = f"Invalid field {field.name}: field type '{field.type}' is not supported."
+            raise type(err)(msg) from err
+
+        kwds.update(inner_kwds)
         parser.add_argument(*posargs, **kwds)
 
     return parser
 
 
-def _get_kwds_for_type(field_type: Any) -> Dict[str, Any]:
+@deprecated_alias(add_dataclass_fields_to_parser)
+def new_parser_from_dataclass(*args, **kwargs): ...
+
+
+def _get_kwds_for_type(
+    field_type: Any,
+    list_parsing: ListParsing = "argparse",
+) -> Dict[str, Any]:
     kwds = {}
 
     type_origin = get_origin(field_type)
@@ -96,35 +139,53 @@ def _get_kwds_for_type(field_type: Any) -> Dict[str, Any]:
         if not all(type(arg) in _SCALARS_TARGET_TYPES for arg in type_args):
             msg = f"Invalid argument {field_type=}. (expected homogeneous types in {type_origin})"
             raise TypeError(msg)
-    elif type_origin in (UnionType, Union):
-        if not all(arg in _SCALARS_TARGET_TYPES for arg in type_args):
-            msg = f"Invalid argument {field_type=}. (expected homogeneous types in {type_origin})"
-            raise TypeError(msg)
 
-    if field_type in _SCALARS_TARGET_TYPES or type_origin in (
-        Literal,
-        Optional,
-        UnionType,
-        Union,
+    if (
+        (field_type in _SCALARS_TARGET_TYPES)
+        or (
+            type_origin
+            in (
+                Literal,
+                Optional,
+                UnionType,
+                Union,
+            )
+        )
+        or (_is_iterable_type_like(type_origin) and list_parsing == "brackets")
     ):
-        kwds.update(_get_kwds_for_scalar_type(field_type, field_type))
-    elif type_origin is list:
+        inner_kwds = _get_kwds_for_scalar_type(field_type, field_type, list_parsing)
+        kwds.update(inner_kwds)
+
+    elif _is_iterable_type_like(type_origin):
         item_type = type_args[0]
-        kwds.update(_get_kwds_for_scalar_type(item_type, field_type))
-        kwds["nargs"] = "*"
+        inner_kwds = _get_kwds_for_scalar_type(item_type, field_type, list_parsing)
+        inner_kwds["nargs"] = "*"
+        kwds.update(inner_kwds)
     else:
-        msg = f"Unsupported type {field_type}."
+        msg = f"Unsupported type {field_type}. (with {type_origin=})"
         raise TypeError(msg)
 
     return kwds
 
 
-def _get_kwds_for_scalar_type(type_: Any, from_field_type: Any) -> Dict[str, Any]:
+def _get_kwds_for_scalar_type(
+    type_: Any,
+    from_field_type: Any,
+    list_parsing: ListParsing,
+) -> Dict[str, Any]:
     type_origin = get_origin(type_)
     kwds = {}
 
-    if type_ in _SCALARS_TARGET_TYPES or type_origin in (UnionType, Union, Optional):
+    if (
+        type_ in _SCALARS_TARGET_TYPES
+        or type_origin in (UnionType, Union, Optional)
+        or (
+            _is_iterable_type_like(get_origin(from_field_type))
+            and list_parsing == "brackets"
+        )
+    ):
         pass
+
     elif type_origin is Literal:
         type_args = get_args(type_)
         kwds["choices"] = type_args
@@ -132,7 +193,7 @@ def _get_kwds_for_scalar_type(type_: Any, from_field_type: Any) -> Dict[str, Any
         msg = f"Unsupported dataclass member type {type_} from {from_field_type}."
         raise TypeError(msg)
 
-    kwds["type"] = parse_to(type_)  # type: ignore
+    kwds["type"] = parse_to(type_, list_parsing=list_parsing)  # type: ignore
     return kwds
 
 
@@ -143,6 +204,7 @@ def parse_to(
     true_values: Union[str, Iterable[str]] = DEFAULT_TRUE_VALUES,
     false_values: Union[str, Iterable[str]] = DEFAULT_FALSE_VALUES,
     none_values: Union[str, Iterable[str]] = DEFAULT_NONE_VALUES,
+    list_parsing: ListParsing = "argparse",
 ) -> Callable[[str], T]:
     """Returns a callable that convert string value to target type safely.
 
@@ -155,6 +217,7 @@ def parse_to(
         true_values=true_values,
         false_values=false_values,
         none_values=none_values,
+        list_parsing=list_parsing,
     )
 
 
@@ -166,6 +229,7 @@ def str_to_type(
     true_values: Union[str, Iterable[str]] = DEFAULT_TRUE_VALUES,
     false_values: Union[str, Iterable[str]] = DEFAULT_FALSE_VALUES,
     none_values: Union[str, Iterable[str]] = DEFAULT_NONE_VALUES,
+    list_parsing: ListParsing = "argparse",
 ) -> T:
     """Convert string values to target type safely. Intended for argparse arguments.
 
@@ -181,6 +245,7 @@ def str_to_type(
         true_values=true_values,
         false_values=false_values,
         none_values=none_values,
+        list_parsing=list_parsing,
     )
     if isinstance(result, Exception):
         raise result
@@ -303,12 +368,14 @@ def _str_to_type_impl(
     true_values: Union[str, Iterable[str]] = DEFAULT_TRUE_VALUES,
     false_values: Union[str, Iterable[str]] = DEFAULT_FALSE_VALUES,
     none_values: Union[str, Iterable[str]] = DEFAULT_NONE_VALUES,
+    list_parsing: ListParsing = "argparse",
 ) -> Union[T, Exception]:
     kwds: Dict[str, Any] = dict(
         case_sensitive=case_sensitive,
         true_values=true_values,
         false_values=false_values,
         none_values=none_values,
+        list_parsing=list_parsing,
     )
     if target_type in _SCALARS_TARGET_TYPES:
         return _str_to_scalar_impl(x, target_type, **kwds)
@@ -318,17 +385,55 @@ def _str_to_type_impl(
     if origin is Literal:
         args = get_args(target_type)
         literal_types = {type(value) for value in args}
-        if len(literal_types) != 1:
-            msg = f"Mixed Literal are not supported: {args}"
-            raise TypeError(msg)
 
-        literal_type = next(iter(literal_types))
-        scalar = _str_to_scalar_impl(x, literal_type, **kwds)
+        if len(literal_types) == 0:
+            msg = "Invalid number of arguments in Literal. (expected at least 1)"
+            raise ValueError(msg)
+        elif len(literal_types) == 1:
+            literal_type = next(iter(literal_types))
+            scalar = _str_to_scalar_impl(x, literal_type, **kwds)
+        else:
+            scalar = _str_to_type_impl(x, tuple(literal_types), **kwds)
+
         if scalar not in args:
             msg = f"Cannot convert {x} to Literal[{', '.join(args)}]"
             raise ValueError(msg)
         return scalar
 
+    if _is_iterable_type_like(origin):
+        if list_parsing != "brackets":
+            raise ValueError
+
+        args = get_args(target_type)
+
+        if len(args) == 0:
+            target_item_type = str
+        elif len(args) == 1:
+            target_item_type = args[0]
+        else:
+            raise ValueError
+
+        pattern = r"^\s*\[\s*(|.*[^,\s])(|\s*,)\s*\]\s*$"
+        if re.match(pattern, x) is None:
+            msg = f"Cannot convert value to list: '{x}'. (with {list_parsing=})"
+            return ValueError(msg)
+
+        x = re.sub(pattern, r"\1", x)
+        if x == "":
+            return []  # type: ignore
+
+        x_list = x.split(",")
+
+        output_list = []
+        for xi in x_list:
+            output_i = _str_to_type_impl(xi, target_item_type, **kwds)  # type: ignore
+            if isinstance(output_i, Exception):
+                return output_i
+            output_list.append(output_i)
+        return output_list  # type: ignore
+
+    if isinstance(target_type, tuple):
+        args = target_type
     elif getattr(target_type, "__name__", None) == "Optional":
         args = (None,) + get_args(target_type)
     elif origin == Union or origin.__name__ in ("Union", "UnionType"):  # type: ignore
@@ -354,6 +459,10 @@ def _str_to_type_impl(
     return ValueError(f"Invalid argument {x=} with {target_type=}.")
 
 
+def _is_iterable_type_like(x: Any) -> bool:
+    return x in (list, Iterable, _Iterable)
+
+
 def _str_to_scalar_impl(
     x: str,
     target_type: TargetType[T],
@@ -362,23 +471,31 @@ def _str_to_scalar_impl(
     true_values: Union[str, Iterable[str]] = DEFAULT_TRUE_VALUES,
     false_values: Union[str, Iterable[str]] = DEFAULT_FALSE_VALUES,
     none_values: Union[str, Iterable[str]] = DEFAULT_NONE_VALUES,
+    list_parsing: ListParsing = "argparse",
 ) -> Any:
+    del list_parsing
     if target_type is str:
         return x
+
     elif target_type is int:
         try:
             return int(x)
         except ValueError as err:
             return err
+
     elif target_type is float:
         try:
             return float(x)
         except ValueError as err:
             return err
+
     elif target_type in (None, NoneType):
         return _str_to_none_impl(
-            x, case_sensitive=case_sensitive, none_values=none_values
+            x,
+            case_sensitive=case_sensitive,
+            none_values=none_values,
         )
+
     elif target_type is bool:
         return _str_to_bool_impl(
             x,
@@ -387,7 +504,8 @@ def _str_to_scalar_impl(
             false_values=false_values,
         )
     else:
-        raise ValueError(f"Invalid argument {target_type=}. (unsupported type)")
+        msg = f"Invalid argument {target_type=}. (unsupported type)"
+        raise ValueError(msg)
 
 
 def _str_to_bool_impl(

{pythonwrench-0.6.0 → pythonwrench-0.6.2}/src/pythonwrench/concurrent.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import copy
 import logging
 from concurrent.futures import Future, ThreadPoolExecutor
 from typing import Any, Callable, Dict, Generic, Iterable, List, Optional, TypeVar
@@ -42,8 +43,11 @@ class ThreadPoolExecutorHelper(Generic[P, T]):
                 executor_kwds = {}
             self.executor = ThreadPoolExecutor(**executor_kwds)
 
-        kwargs = self.default_kwargs | kwargs  # type: ignore
-        future = self.executor.submit(self.fn, *args, **kwargs)
+        default_kwargs = copy.copy(self.default_kwargs)
+        default_kwargs.update(kwargs)
+        del kwargs
+
+        future = self.executor.submit(self.fn, *args, **default_kwargs)
         self.futures.append(future)
         return future
 

pythonwrench-0.6.2/src/pythonwrench/dataclasses.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from dataclasses import MISSING, dataclass, is_dataclass  # noqa: F401
+from typing import Any, Dict, Type, TypeVar, cast
+
+from typing_extensions import dataclass_transform
+
+from pythonwrench.typing.checks import (  # noqa: F401
+    is_dataclass_instance,
+    is_dataclass_type,
+)
+from pythonwrench.typing.classes import Dataclass, DataclassInstance  # noqa: F401
+
+T = TypeVar("T")
+
+
+@dataclass_transform()
+def dataclassdict(cls: Type[T]) -> Type[T]:
+    """Decorate a class so it becomes both a dataclass and a dictionary."""
+    return add_dict_methods(dataclass(cls))
+
+
+def add_dict_methods(cls: Type[T]) -> Type[T]:
+    """Return a dictionary subclass of an already-defined dataclass.
+
+    Field values are kept synchronized between attribute and mapping access.
+    """
+    if not is_dataclass_type(cls):
+        raise TypeError("add_dict_methods expects a dataclass type.")
+
+    dataclass_cls = cls
+    conflicting_fields = sorted(
+        set(dataclass_cls.__dataclass_fields__).intersection(dir(dict))  # type: ignore
+    )
+    if conflicting_fields:
+        names = ", ".join(repr(name) for name in conflicting_fields)
+        msg = f"Dataclass fields conflict with dict attributes: {names}."
+        raise RuntimeError(msg)
+
+    def setattr_(self: Any, name: str, value: Any) -> None:
+        object.__setattr__(self, name, value)
+        if name in self.__dataclass_fields__:
+            dict.__setitem__(self, name, value)
+
+    def setitem(self: Any, key: Any, value: Any) -> None:
+        dict.__setitem__(self, key, value)
+        if key in self.__dataclass_fields__:
+            object.__setattr__(self, key, value)
+
+    def delitem(self: Any, key: Any) -> None:
+        dict.__delitem__(self, key)
+        if key in self.__dataclass_fields__ and hasattr(self, key):
+            object.__delattr__(self, key)
+
+    def update(self: Any, *args: Any, **kwargs: Any) -> None:
+        for key, value in dict(*args, **kwargs).items():
+            setitem(self, key, value)
+
+    def setdefault(self: Any, key: Any, default: Any = None) -> Any:
+        if key not in self:
+            setitem(self, key, default)
+        return self[key]
+
+    def pop(self: Any, key: Any, *default: Any) -> Any:
+        if len(default) > 1:
+            raise TypeError("pop expected at most 2 arguments")
+        if key not in self:
+            if default:
+                return default[0]
+            raise KeyError(key)
+        value = self[key]
+        delitem(self, key)
+        return value
+
+    def clear(self: Any) -> None:
+        for key in list(self):
+            delitem(self, key)
+
+    namespace = {
+        "__module__": cls.__module__,
+        "__doc__": cls.__doc__,
+        "__setattr__": setattr_,
+        "__setitem__": setitem,
+        "__delitem__": delitem,
+        "update": update,
+        "setdefault": setdefault,
+        "pop": pop,
+        "clear": clear,
+    }
+    result = type(cls.__name__, (dataclass_cls, dict), namespace)  # type: ignore
+    result.__qualname__ = cls.__qualname__
+    result = dataclass(result)
+    return cast(Type[T], result)
+
+
+def get_defaults_values(obj: DataclassInstance) -> Dict[str, Any]:
+    defaults = {}
+
+    for field in obj.__dataclass_fields__.values():
+        if callable(field.default_factory):
+            default = field.default_factory()
+        else:
+            default = field.default
+
+        if default != MISSING:
+            defaults[field.name] = default
+
+    return defaults

{pythonwrench-0.6.0 → pythonwrench-0.6.2}/src/pythonwrench/difflib.py

@@ -6,18 +6,16 @@ from difflib import SequenceMatcher
 from typing import Callable, Iterable, Optional
 
 
-def sequence_matcher_ratio(a: str, b: str) -> float:
-    """Compute distance ratio of two strings."""
-    return SequenceMatcher(None, a, b).ratio()
-
-
 def find_closest_in_list(
     x: str,
     lst: Iterable[str],
-    sim_fn: Callable[[str, str], float] = sequence_matcher_ratio,
+    sim_fn: Optional[Callable[[str, str], float]] = None,
     higher_is_closer: bool = True,
 ) -> Optional[str]:
     """Find closest element in a list based on matches ratio."""
+    if sim_fn is None:
+        sim_fn = sequence_matcher_ratio
+
     best_sim = -int(higher_is_closer) * math.inf
     closest = None
 
@@ -34,3 +32,8 @@ def find_closest_in_list(
         raise ValueError(msg)
 
     return closest
+
+
+def sequence_matcher_ratio(a: str, b: str) -> float:
+    """Compute distance ratio of two strings."""
+    return SequenceMatcher(None, a, b).ratio()