pythonwrench 0.6.1__tar.gz → 0.6.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonwrench
-Version: 0.6.1
+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.1 → 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.1"
+__version__ = "0.6.2"
 
 
 from typing import TYPE_CHECKING
@@ -101,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
@@ -219,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,
@@ -344,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"],
@@ -436,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.1 → 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,31 +38,31 @@ def return_none(*args, **kwargs) -> None:
 
 
 def _decorator_factory(
-    inner_fn: Optional[Callable[P, U]],
+    inner_fn: Optional[T_Function],
     *,
     pre_fn: Optional[Callable[..., Any]] = None,
     post_fn: Optional[Callable[..., Any]] = None,
-) -> Callable[[Callable[P, U]], Callable[P, U]]:
-    """Deprecated decorator for function aliases."""
+) -> 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: Callable[P, U]) -> Callable[P, U]:
+    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.1 → pythonwrench-0.6.2}/src/pythonwrench/argparse.py

@@ -3,6 +3,7 @@
 
 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 (
@@ -13,6 +14,7 @@ from typing import (
     List,
     Literal,
     Optional,
+    Tuple,
     Type,
     TypeVar,
     Union,
@@ -33,7 +35,9 @@ 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]", "Type[Optional]"]
+TargetType = Union[
+    Type[T], UnionType, "Type[Literal]", "Type[Optional]", Tuple[type, ...]
+]
 ListParsing = Literal["argparse", "brackets"]
 
 DEFAULT_TRUE_VALUES = ("True", "t", "yes", "y", "1")
@@ -49,6 +53,7 @@ def parse_args_using_dataclass(
     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.
 
@@ -59,6 +64,7 @@ def parse_args_using_dataclass(
         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:
@@ -80,6 +86,7 @@ def add_dataclass_fields_to_parser(
     *,
     parser: Optional[ArgumentParser],
     list_parsing: ListParsing = "argparse",
+    add_dashed_arg: bool = True,
 ) -> ArgumentParser:
     if parser is None:
         parser = ArgumentParser()
@@ -87,6 +94,9 @@ def add_dataclass_fields_to_parser(
     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
@@ -99,7 +109,12 @@ def add_dataclass_fields_to_parser(
             msg = f"Invalid field {field.name}: found values for default and default_factory."
             raise ValueError(msg)
 
-        inner_kwds = _get_kwds_for_type(field.type, list_parsing)
+        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)
 
@@ -124,10 +139,6 @@ def _get_kwds_for_type(
         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)
@@ -140,47 +151,27 @@ def _get_kwds_for_type(
                 Union,
             )
         )
-        or (type_origin in (list, Iterable) and list_parsing == "brackets")
+        or (_is_iterable_type_like(type_origin) and list_parsing == "brackets")
     ):
         inner_kwds = _get_kwds_for_scalar_type(field_type, field_type, list_parsing)
         kwds.update(inner_kwds)
 
-    elif type_origin in (list, Iterable):
+    elif _is_iterable_type_like(type_origin):
         item_type = type_args[0]
         inner_kwds = _get_kwds_for_scalar_type(item_type, field_type, list_parsing)
         inner_kwds["nargs"] = "*"
-
-        # TODO: rm
-        # if list_parsing == "argparse":
-        #     kwds["nargs"] = "*"
-        # elif list_parsing == "brackets":
-        #     parse_fn = inner_kwds.pop("type")
-
-        #     def brackets_parse(x: str) -> Any:
-        #         x = (
-        #             x.strip()
-        #             .removeprefix("[")
-        #             .removesuffix("]")
-        #             .removesuffix(",")
-        #             .strip()
-        #         )
-        #         return list(map(parse_fn, x.split(",")))
-
-        #     inner_kwds["type"] = brackets_parse
-        # else:
-        #     msg = f"Invalid argument {list_parsing=}. (expected one of {get_args(ListParsing)})"
-        #     raise ValueError(msg)
-
         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, list_parsing: ListParsing
+    type_: Any,
+    from_field_type: Any,
+    list_parsing: ListParsing,
 ) -> Dict[str, Any]:
     type_origin = get_origin(type_)
     kwds = {}
@@ -189,11 +180,12 @@ def _get_kwds_for_scalar_type(
         type_ in _SCALARS_TARGET_TYPES
         or type_origin in (UnionType, Union, Optional)
         or (
-            get_origin(from_field_type) in (list, Iterable)
+            _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
@@ -393,18 +385,22 @@ 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 origin in (list, Iterable):
+    if _is_iterable_type_like(origin):
         if list_parsing != "brackets":
             raise ValueError
 
@@ -417,18 +413,28 @@ def _str_to_type_impl(
         else:
             raise ValueError
 
-        x = re.sub(r"^\s*\[\s*(|.*[^,\s])(|\s*,)\s*\]\s*$", r"\1", x)
+        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(",")
 
-        y_list = []
+        output_list = []
         for xi in x_list:
-            yi = _str_to_type_impl(xi, target_item_type, **kwds)  # type: ignore
-            if isinstance(yi, Exception):
-                return yi
-            y_list.append(yi)
-        return y_list  # type: ignore
-
-    if getattr(target_type, "__name__", None) == "Optional":
+            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
         args = get_args(target_type)
@@ -453,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],

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.1 → pythonwrench-0.6.2}/src/pythonwrench/functools.py

@@ -16,13 +16,13 @@ from typing import (
 
 from typing_extensions import ParamSpec
 
-from pythonwrench._core import _decorator_factory, return_none  # noqa: F401
+from pythonwrench._core import T_Function, _decorator_factory, return_none  # noqa: F401
 from pythonwrench.inspect import get_argnames, get_fullname
 from pythonwrench.typing import isinstance_generic
 
 T = TypeVar("T")
-P = ParamSpec("P")
 U = TypeVar("U")
+P = ParamSpec("P")
 
 
 class Compose(Generic[T, U]):
@@ -162,13 +162,15 @@ def filter_and_call(
 
 
 def function_alias(
-    alternative: Callable[P, U],
+    alternative: T_Function,
     *,
     pre_fn: Optional[Callable[..., Any]] = None,
     post_fn: Optional[Callable[..., Any]] = None,
-) -> Callable[..., Callable[P, U]]:
+) -> Callable[..., T_Function]:
     """Decorator to wrap function aliases.
 
+    Unlike setting directly an alias, this preserve the nature of the alias for language server.
+
     Example
     -------
     >>> def f(a: int, b: str) -> str:

{pythonwrench-0.6.1 → pythonwrench-0.6.2}/src/pythonwrench/serialization/_core.py

@@ -13,8 +13,9 @@ from typing import (
 @overload
 def _setup_output_fpath(
     fpath: Union[str, Path, os.PathLike],
-    overwrite: bool,
-    make_parents: bool,
+    *,
+    overwrite: bool = True,
+    make_parents: bool = True,
     absolute: bool = True,
 ) -> Path: ...
 
@@ -22,8 +23,9 @@ def _setup_output_fpath(
 @overload
 def _setup_output_fpath(
     fpath: TextIOWrapper,
-    overwrite: bool,
-    make_parents: bool,
+    *,
+    overwrite: bool = True,
+    make_parents: bool = True,
     absolute: bool = True,
 ) -> TextIOWrapper: ...
 
@@ -31,16 +33,18 @@ def _setup_output_fpath(
 @overload
 def _setup_output_fpath(
     fpath: None,
-    overwrite: bool,
-    make_parents: bool,
+    *,
+    overwrite: bool = True,
+    make_parents: bool = True,
     absolute: bool = True,
 ) -> None: ...
 
 
 def _setup_output_fpath(
     fpath: Union[str, Path, os.PathLike, TextIOWrapper, None],
-    overwrite: bool,
-    make_parents: bool,
+    *,
+    overwrite: bool = True,
+    make_parents: bool = True,
     absolute: bool = True,
 ) -> Union[Path, None, TextIOWrapper]:
     """Resolve path, expand path and create intermediate parents."""

{pythonwrench-0.6.1 → pythonwrench-0.6.2}/src/pythonwrench/serialization/csv.py

@@ -74,7 +74,7 @@ def dump_csv(
     )
 
     if isinstance(file, (str, Path, PathLike)):
-        file = _setup_output_fpath(file, overwrite, make_parents)
+        file = _setup_output_fpath(file, overwrite=overwrite, make_parents=make_parents)
         with open(file, "w") as opened_file:
             opened_file.write(content)
     elif isinstance(file, TextIOBase):

{pythonwrench-0.6.1 → pythonwrench-0.6.2}/src/pythonwrench/serialization/json.py

@@ -51,7 +51,7 @@ def dump_json(
     )
 
     if isinstance(file, (str, Path, PathLike)):
-        file = _setup_output_fpath(file, overwrite, make_parents)
+        file = _setup_output_fpath(file, overwrite=overwrite, make_parents=make_parents)
         with open(file, "w") as opened_file:
             opened_file.write(content)
     elif isinstance(file, TextIOBase):

{pythonwrench-0.6.1 → pythonwrench-0.6.2}/src/pythonwrench/serialization/jsonl.py

@@ -64,7 +64,7 @@ def dump_jsonl(
     )
 
     if isinstance(file, (str, Path, PathLike)):
-        file = _setup_output_fpath(file, overwrite, make_parents)
+        file = _setup_output_fpath(file, overwrite=overwrite, make_parents=make_parents)
         with open(file, "w") as opened_file:
             opened_file.write(content)
     elif isinstance(file, TextIOBase):

{pythonwrench-0.6.1 → pythonwrench-0.6.2}/src/pythonwrench/serialization/pickle.py

@@ -45,7 +45,7 @@ def dump_pickle(
     )
 
     if isinstance(file, (str, Path, PathLike)):
-        file = _setup_output_fpath(file, overwrite, make_parents)
+        file = _setup_output_fpath(file, overwrite=overwrite, make_parents=make_parents)
         with open(file, "wb") as opened_file:
             opened_file.write(content)
     elif isinstance(file, BinaryIO):

{pythonwrench-0.6.1 → pythonwrench-0.6.2}/src/pythonwrench/typing/__init__.py

@@ -18,6 +18,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,
@@ -77,6 +78,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.1 → pythonwrench-0.6.2}/src/pythonwrench/typing/checks.py

@@ -5,6 +5,7 @@ import inspect
 import logging
 import sys
 import typing
+from dataclasses import is_dataclass
 from numbers import Integral
 from types import FunctionType, MethodType
 from typing import (
@@ -311,6 +312,10 @@ def is_dataclass_instance(x: Any) -> TypeIs[DataclassInstance]:
     return not isinstance(x, type) and isinstance_generic(x, DataclassInstance)
 
 
+def is_dataclass_type(x: Any) -> TypeIs[Type[DataclassInstance]]:
+    return isinstance(x, type) and is_dataclass(x)
+
+
 def is_iterable_bool(
     x: Any,
     *,

{pythonwrench-0.6.1 → pythonwrench-0.6.2}/src/pythonwrench/warnings.py

@@ -7,7 +7,7 @@ from typing import Any, Callable, Optional, Type, TypeVar, Union, overload
 
 from typing_extensions import ParamSpec
 
-from pythonwrench._core import _decorator_factory, return_none
+from pythonwrench._core import T_Function, _decorator_factory, return_none
 
 P = ParamSpec("P")
 U = TypeVar("U")
@@ -43,13 +43,13 @@ def warn_once(
 
 
 def deprecated_alias(
-    alternative: Callable[P, U],
+    alternative: T_Function,
     msg_fmt: str = "Deprecated call to '{fn_name}', use '{alternative_name}' instead.",
     warn_fn: Callable[[str], Any] = partial(warn_once, category=DeprecationWarning),
     *,
     pre_fn: Optional[Callable[..., Any]] = None,
     post_fn: Optional[Callable[..., Any]] = None,
-) -> Callable[..., Callable[P, U]]:
+) -> Callable[..., T_Function]:
     """Decorator to wrap deprecated function aliases."""
     alternative_name = alternative.__name__ if alternative is not None else "None"
     if pre_fn is None:
@@ -70,28 +70,28 @@ def deprecated_function(
     *,
     msg_fmt: str = "Deprecated call to '{fn_name}'.",
     warn_fn: Callable[[str], Any] = partial(warn_once, category=DeprecationWarning),
-) -> Callable[[Callable[P, U]], Callable[P, U]]: ...
+) -> Callable[[T_Function], T_Function]: ...
 
 
 @overload
 def deprecated_function(
-    fn: Callable[P, U],
+    fn: T_Function,
     /,
     *,
     msg_fmt: str = "Deprecated call to '{fn_name}'.",
     warn_fn: Callable[[str], Any] = partial(warn_once, category=DeprecationWarning),
-) -> Callable[P, U]: ...
+) -> T_Function: ...
 
 
 def deprecated_function(
-    fn: Optional[Callable[P, U]] = None,
+    fn: Optional[T_Function] = None,
     /,
     *,
     msg_fmt: str = "Deprecated call to '{fn_name}'.",
     warn_fn: Callable[[str], Any] = partial(warn_once, category=DeprecationWarning),
     pre_fn: Optional[Callable[..., Any]] = None,
     post_fn: Optional[Callable[..., Any]] = None,
-) -> Callable:
+) -> Union[Callable[[T_Function], T_Function], T_Function]:
     """Decorator to wrap deprecated functions."""
     if pre_fn is None:
         pre_fn = return_none

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonwrench
-Version: 0.6.1
+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.1 → pythonwrench-0.6.2}/tests/test_argparse.py

@@ -4,7 +4,7 @@
 import unittest
 from argparse import ArgumentParser
 from dataclasses import dataclass, field
-from typing import List, Literal, Optional, Tuple, Union
+from typing import Iterable, List, Literal, Optional, Tuple, Union
 from unittest import TestCase
 
 from pythonwrench.argparse import (
@@ -113,7 +113,7 @@ class TestArgparse(TestCase):
         class B:
             arg_b: Union[str, List[str]] = ""
 
-        with self.assertRaises(TypeError):
+        with self.assertRaises(SystemExit):
             _ = parse_args_using_dataclass(B, args=[])
 
         @dataclass
@@ -149,6 +149,93 @@ class TestArgparse(TestCase):
         )
         assert target == result
 
+    def test_parse_args_using_dataclass_example_5(self) -> None:
+        @dataclass
+        class A:
+            seed: int
+
+        @dataclass
+        class B(A):
+            constraint_names: Optional[Iterable[str]] = ("b",)
+
+        result = parse_args_using_dataclass(
+            B,
+            args=["--seed", "42"],
+            list_parsing="brackets",
+        )
+        assert result == B(42, ("b",))
+
+        result = parse_args_using_dataclass(
+            B,
+            args=["--constraint_names", "[a,b]", "--seed", "42"],
+            list_parsing="brackets",
+        )
+        assert result == B(42, ["a", "b"]), f"{result=}"
+
+        result = parse_args_using_dataclass(
+            B,
+            args=["--constraint_names", "[a]", "--seed", "42"],
+            list_parsing="brackets",
+        )
+        assert result == B(42, ["a"])
+
+        result = parse_args_using_dataclass(
+            B,
+            args=["--constraint_names", "[]", "--seed", "42"],
+            list_parsing="brackets",
+        )
+        assert result == B(42, [])
+
+        result = parse_args_using_dataclass(
+            B,
+            args=["--constraint_names", "none", "--seed", "42"],
+            list_parsing="brackets",
+        )
+        assert result == B(42, None)
+
+        with self.assertRaises(SystemExit):
+            result = parse_args_using_dataclass(
+                B,
+                args=["--constraint_names", "truc", "--seed", "42"],
+                list_parsing="brackets",
+            )
+            assert result == B(42, "truc")
+
+    def test_parse_args_using_dataclass_example_6(self) -> None:
+        @dataclass
+        class A:
+            seed: Optional[Iterable[Literal[0, "a"]]] = None
+
+        result = parse_args_using_dataclass(
+            A,
+            args=[],
+            list_parsing="brackets",
+        )
+        assert result == A()
+
+        result = parse_args_using_dataclass(
+            A,
+            args=["--seed", "[0,a]"],
+            list_parsing="brackets",
+        )
+        assert result == A([0, "a"])
+
+        with self.assertRaises(SystemExit):
+            result = parse_args_using_dataclass(
+                A,
+                args=["--seed", "[b]"],
+                list_parsing="brackets",
+            )
+            assert result == A(["b"])  # type: ignore
+
+        with self.assertRaises(SystemExit):
+            result = parse_args_using_dataclass(
+                A,
+                args=["--seed", "[1]"],
+                list_parsing="brackets",
+            )
+            assert result == A([1])  # type: ignore
+
 
 if __name__ == "__main__":
     unittest.main()

pythonwrench-0.6.2/tests/test_dataclasses.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import unittest
+from dataclasses import asdict, dataclass, field, is_dataclass
+from typing import List, Tuple
+from unittest import TestCase
+
+from pythonwrench.dataclasses import (
+    add_dict_methods,
+    dataclassdict,
+    get_defaults_values,
+    is_dataclass_instance,
+)
+
+
+@dataclass
+class Dummy:
+    a: int
+    b: str = "b"
+    c: Tuple[int, ...] = ()
+    d: List[str] = field(default_factory=list)
+
+
+class TestDataclass(TestCase):
+    def test_example_1(self) -> None:
+        dummy = Dummy(2)
+
+        assert is_dataclass(dummy)
+        assert is_dataclass(Dummy)
+        assert is_dataclass_instance(dummy)
+        assert not is_dataclass_instance(Dummy)
+
+        assert get_defaults_values(dummy) == {"b": "b", "c": (), "d": []}
+
+    def test_dataclassdict(self) -> None:
+        @dataclassdict
+        class Point:
+            x: int
+            y: int = 0
+
+        point = Point(1)
+        assert is_dataclass(point)
+        assert isinstance(point, dict)
+        assert dict(point) == {"x": 1, "y": 0}
+        assert len(point) == 2
+        assert asdict(point) == {"x": 1, "y": 0}
+
+        point.x = 2
+        assert point["x"] == 2
+
+        point["y"] = 3
+        assert point.y == 3
+
+        point.update(x=4, extra=True)
+        assert point.x == 4
+        assert point["extra"] is True
+
+    def test_dataclassdict_rejects_dict_attribute_as_field(self) -> None:
+        with self.assertRaisesRegex(RuntimeError, "'keys'"):
+
+            @dataclassdict
+            class Invalid:
+                keys: float = 0.0
+
+    def test_add_dict_methods(self) -> None:
+        @dataclass
+        class Existing:
+            a: int = 1
+            b: str = ""
+
+        ExistingDict = add_dict_methods(Existing)
+        value = ExistingDict()
+
+        assert isinstance(value, Existing)
+        assert isinstance(value, dict)
+        assert value["a"] == 1
+        assert value["b"] == ""
+
+    def test_add_dict_methods_rejects_non_dataclass(self) -> None:
+        class Regular:
+            pass
+
+        with self.assertRaisesRegex(TypeError, "expects a dataclass type"):
+            add_dict_methods(Regular)
+
+
+if __name__ == "__main__":
+    unittest.main()

{pythonwrench-0.6.1 → pythonwrench-0.6.2}/tests/test_disk_cache.py

@@ -48,7 +48,8 @@ class TestDiskCache(TestCase):
         )
         def disk_cache_example_3(num: int) -> List[Dict[str, str]]:
             return pw.dict_list_to_list_dict(
-                {"a": ["a"] * num, "b": ["b"] * num}, "same"
+                {"a": ["a"] * num, "b": ["b"] * num},
+                "same",
             )
 
         outputs = disk_cache_example_3(10)

pythonwrench-0.6.1/src/pythonwrench/dataclasses.py

@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from dataclasses import MISSING
-from typing import Any, Dict, TypeVar
-
-from pythonwrench.typing.checks import is_dataclass_instance  # noqa: F401
-from pythonwrench.typing.classes import Dataclass, DataclassInstance  # noqa: F401
-
-T = TypeVar("T")
-
-
-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.1/tests/test_dataclasses.py

@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import unittest
-from dataclasses import dataclass, field, is_dataclass
-from typing import List, Tuple
-from unittest import TestCase
-
-from pythonwrench.dataclasses import get_defaults_values, is_dataclass_instance
-
-
-@dataclass
-class Dummy:
-    a: int
-    b: str = "b"
-    c: Tuple[int, ...] = ()
-    d: List[str] = field(default_factory=list)
-
-
-class TestDataclass(TestCase):
-    def test_example_1(self) -> None:
-        dummy = Dummy(2)
-
-        assert is_dataclass(dummy)
-        assert is_dataclass(Dummy)
-        assert is_dataclass_instance(dummy)
-        assert not is_dataclass_instance(Dummy)
-
-        assert get_defaults_values(dummy) == {"b": "b", "c": (), "d": []}
-
-
-if __name__ == "__main__":
-    unittest.main()