pythonwrench 0.5.0__tar.gz → 0.5.1__tar.gz

{pythonwrench-0.5.0/src/pythonwrench.egg-info → pythonwrench-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: pythonwrench
-Version: 0.5.0
+Version: 0.5.1
 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>
@@ -53,7 +53,8 @@ License-File: LICENSE
 Requires-Dist: lazy-loader>=0.4
 Requires-Dist: typing-extensions>=4.10.0
 Provides-Extra: dev
-Dynamic: license-file
+Provides-Extra: lazy
+Requires-Dist: lazy-loader>=0.4; extra == "lazy"
 
 # pythonwrench
 

pythonwrench-0.5.1/docs/requirements.txt

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+sphinx-immaterial>=0.11.14
+sphinx<9.0.0

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/pyproject.toml

@@ -52,6 +52,9 @@ pyw-safe-rmdir = "pythonwrench.entries:main_safe_rmdir"
 
 [project.optional-dependencies]
 dev = []
+lazy = [
+    "lazy-loader>=0.4",
+]
 
 [build-system]
 requires = ["setuptools >= 61.0"]

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/src/pythonwrench/__init__.py

@@ -9,7 +9,7 @@ __author_email__ = "labbeti.pub@gmail.com"
 __license__ = "MIT"
 __maintainer__ = "Étienne Labbé (Labbeti)"
 __status__ = "Development"
-__version__ = "0.5.0"
+__version__ = "0.5.1"
 
 
 from typing import TYPE_CHECKING
@@ -187,6 +187,7 @@ if TYPE_CHECKING or lazy is None:
         SupportsGetitemIterLen2,
         SupportsGetitemLen,
         SupportsGetitemLen2,
+        SupportsIter,
         SupportsIterLen,
         SupportsLen,
         SupportsMatmul,
@@ -199,6 +200,7 @@ if TYPE_CHECKING or lazy is None:
         is_builtin_number,
         is_builtin_obj,
         is_builtin_scalar,
+        is_collection_alias,
         is_dataclass_instance,
         is_iterable_bool,
         is_iterable_bytes_or_list,
@@ -207,7 +209,9 @@ if TYPE_CHECKING or lazy is None:
         is_iterable_integral,
         is_iterable_str,
         is_namedtuple_instance,
+        is_parameterized,
         is_sequence_str,
+        is_special_form,
         is_typed_dict,
         isinstance_generic,
     )
@@ -397,6 +401,7 @@ else:
                 "SupportsGetitemIterLen2",
                 "SupportsGetitemLen",
                 "SupportsGetitemLen2",
+                "SupportsIter",
                 "SupportsIterLen",
                 "SupportsLen",
                 "SupportsMatmul",
@@ -409,6 +414,7 @@ else:
                 "is_builtin_number",
                 "is_builtin_obj",
                 "is_builtin_scalar",
+                "is_collection_alias",
                 "is_dataclass_instance",
                 "is_iterable_bool",
                 "is_iterable_bytes_or_list",
@@ -417,7 +423,9 @@ else:
                 "is_iterable_integral",
                 "is_iterable_str",
                 "is_namedtuple_instance",
+                "is_parameterized",
                 "is_sequence_str",
+                "is_special_form",
                 "is_typed_dict",
                 "isinstance_generic",
             ],

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/src/pythonwrench/_core.py

@@ -32,7 +32,7 @@ ClassOrTuple = Union[type, Tuple[type, ...]]
 
 
 class Predicate(Protocol[T_Any]):
-    def __call__(self, x: T_Any) -> bool: ...
+    def __call__(self, /, x: T_Any) -> bool: ...
 
 
 def return_none(*args, **kwargs) -> None:

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/src/pythonwrench/checksum.py

@@ -6,6 +6,7 @@ import re
 import struct
 import zlib
 from dataclasses import asdict
+from datetime import date, datetime
 from enum import Enum
 from functools import lru_cache
 from pathlib import Path
@@ -13,12 +14,15 @@ from types import FunctionType, MethodType
 from typing import (
     Any,
     Callable,
+    Dict,
     Generator,
     Iterable,
     Mapping,
     Optional,
     TypeVar,
     Union,
+    get_args,
+    get_origin,
     overload,
 )
 
@@ -27,14 +31,19 @@ from pythonwrench.functools import function_alias
 from pythonwrench.inspect import get_fullname
 from pythonwrench.typing import (
     DataclassInstance,
+    EllipsisType,
     NamedTupleInstance,
     NoneType,
+    is_collection_alias,
+    is_parameterized,
+    is_special_form,
 )
 
 T = TypeVar("T")
 
 
 _CHECKSUM_REGISTRY = _FunctionRegistry[int]()
+_CHECKSUM_PROTOCOLS = False
 
 
 @overload
@@ -130,9 +139,7 @@ def checksum_int(x: int, **kwargs) -> int:
 # Intermediate functions
 @register_checksum_fn(bytearray)
 def checksum_bytearray(x: bytearray, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
     return _checksum_bytes_bytearray(x, **kwargs)
 
 
@@ -151,25 +158,25 @@ def checksum_complex(x: complex, **kwargs) -> int:
 
 @register_checksum_fn(FunctionType)
 def checksum_function(x: FunctionType, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
     return checksum_str(x.__qualname__, **kwargs)
 
 
 @register_checksum_fn(NoneType)
 def checksum_none(x: None, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
-    return checksum_type(x.__class__, **kwargs) + kwargs.get("accumulator", 0)
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
+    return checksum_type(x.__class__, **kwargs)
+
+
+@register_checksum_fn(EllipsisType)
+def checksum_ellipsis(x: None, **kwargs) -> int:
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
+    return checksum_type(x.__class__, **kwargs)
 
 
 @register_checksum_fn(str)
 def checksum_str(x: str, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
     return checksum_bytes(x.encode(), **kwargs)
 
 
@@ -181,12 +188,34 @@ def checksum_type(x: type, **kwargs) -> int:
 # Recursive functions
 @register_checksum_fn(DataclassInstance)
 def checksum_dataclass(x: DataclassInstance, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
     return checksum_dict(asdict(x), **kwargs)
 
 
+@register_checksum_fn(datetime)
+def checksum_datetime(x: datetime, **kwargs) -> int:
+    return _checksum_iterable(
+        [
+            x.__class__,
+            x.year,
+            x.month,
+            x.day,
+            x.hour,
+            x.minute,
+            x.second,
+            x.microsecond,
+            x.tzinfo,
+            x.fold,
+        ],
+        **kwargs,
+    )
+
+
+@register_checksum_fn(date)
+def checksum_date(x: date, **kwargs) -> int:
+    return _checksum_iterable([x.__class__, x.year, x.month, x.day], **kwargs)
+
+
 @register_checksum_fn(dict)
 def checksum_dict(x: dict, **kwargs) -> int:
     return _checksum_mapping(x, **kwargs)
@@ -214,9 +243,7 @@ def checksum_set(x: Union[set, frozenset], **kwargs) -> int:
 
 @register_checksum_fn(range)
 def checksum_range(x: range, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
     return _checksum_iterable([x.start, x.stop, x.step], **kwargs)
 
 
@@ -238,48 +265,76 @@ def checksum_method(x: MethodType, **kwargs) -> int:
 
 @register_checksum_fn(NamedTupleInstance)
 def checksum_namedtuple(x: NamedTupleInstance, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
     return checksum_dict(x._asdict(), **kwargs)
 
 
 @register_checksum_fn(functools.partial)
 def checksum_partial(x: functools.partial, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
     return checksum_list_tuple((x.func, x.args, x.keywords), **kwargs)
 
 
 @register_checksum_fn(re.Pattern)
 def checksum_pattern(x: re.Pattern, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
     return checksum_str(str(x), **kwargs)
 
 
 @register_checksum_fn(Path)
 def checksum_path(x: Path, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
+
     resolve_path = kwargs.get("resolve_path", False)
     if isinstance(resolve_path, bool) and resolve_path:
         x = x.expanduser().resolve()
-
     return checksum_str(str(x), **kwargs)
 
 
 @register_checksum_fn(slice)
 def checksum_slice(x: slice, **kwargs) -> int:
-    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
-        get_fullname(x)
-    )
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
     return checksum_list_tuple((x.start, x.stop, x.step), **kwargs)
 
 
+@register_checksum_fn(custom_predicate=is_parameterized)
+def checksum_parametrized(x: Any, **kwargs) -> int:
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
+    return checksum_list_tuple((get_origin(x),) + get_args(x), **kwargs)
+
+
+@register_checksum_fn(custom_predicate=is_collection_alias)
+def checksum_collection_alias(x: Any, **kwargs) -> int:
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
+    return checksum_str(x._name, **kwargs)
+
+
+@register_checksum_fn(custom_predicate=is_special_form)
+def checksum_special_form(x: Any, **kwargs) -> int:
+    kwargs = _add_type_checksum_to_accumulator(x, kwargs)
+
+    if hasattr(x, "_name"):
+        name = x._name
+    elif hasattr(x, "__name__"):
+        name = x.__name__
+    else:
+        msg = f"Unsupported argument {x=} in checksum_special_form."
+        raise ValueError(msg)
+
+    return checksum_str(name, **kwargs)
+
+
+if _CHECKSUM_PROTOCOLS:
+
+    @register_checksum_fn(Mapping, priority=-100)
+    def checksum_mapping(x: Mapping, **kwargs) -> int:
+        return _checksum_mapping(x, **kwargs)
+
+    @register_checksum_fn(Iterable, priority=-200)
+    def checksum_iterable(x: Iterable, **kwargs) -> int:
+        return _checksum_iterable(x, **kwargs)
+
+
 # Private functions
 def _checksum_bytes_bytearray(x: Union[bytes, bytearray], **kwargs) -> int:
     xint = zlib.crc32(x) % (1 << 32)
@@ -307,9 +362,17 @@ def _checksum_mapping(x: Mapping, **kwargs) -> int:
 
 
 def _terminate_checksum(x: int, fullname: str, **kwargs) -> int:
+    """Returns checksum for final value + name + accumulator."""
     return x + _cached_checksum_str(fullname) + kwargs.get("accumulator", 0)
 
 
+def _add_type_checksum_to_accumulator(x: Any, kwargs: Dict[str, Any]) -> Dict[str, Any]:
+    kwargs["accumulator"] = kwargs.get("accumulator", 0) + _cached_checksum_str(
+        get_fullname(x)
+    )
+    return kwargs
+
+
 @lru_cache(maxsize=None)
 def _cached_checksum_str(x: str) -> int:
     return zlib.crc32(x.encode()) % (1 << 32)

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/src/pythonwrench/collections/collections.py

@@ -597,14 +597,70 @@ def recursive_generator(x: Any) -> Generator[Tuple[Any, int, int], None, None]:
     return recursive_generator_impl(x, 0, 0)
 
 
+@overload
 def sorted_dict(
     x: Mapping[K, V],
     /,
     *,
+    by: Literal["key"] = "key",
     key: Optional[Callable[[K], Any]] = None,
     reverse: bool = False,
+) -> Dict[K, V]: ...
+
+
+@overload
+def sorted_dict(
+    x: Mapping[K, V],
+    /,
+    *,
+    by: Literal["value"],
+    key: Optional[Callable[[V], Any]] = None,
+    reverse: bool = False,
+) -> Dict[K, V]: ...
+
+
+@overload
+def sorted_dict(
+    x: Mapping[K, V],
+    /,
+    *,
+    by: Literal["item"],
+    key: Optional[Callable[[Tuple[K, V]], Any]] = None,
+    reverse: bool = False,
+) -> Dict[K, V]: ...
+
+
+def sorted_dict(
+    x: Mapping[K, V],
+    /,
+    *,
+    by: Literal["key", "value", "item"] = "key",
+    key: Optional[Callable[[Any], Any]] = None,
+    reverse: bool = False,
 ) -> Dict[K, V]:
-    return {k: x[k] for k in sorted(x.keys(), key=key, reverse=reverse)}  # type: ignore
+    """Sort a dictionnary by key, value or item."""
+    if key is None or by == "item":
+        impl_key = key
+
+    elif by == "key":
+
+        def by_key_fn(x: Tuple[K, V]) -> Any:
+            return key(x[0])
+
+        impl_key = by_key_fn
+
+    elif by == "value":
+
+        def by_value_fn(x: Tuple[K, V]) -> Any:
+            return key(x[1])
+
+        impl_key = by_value_fn
+
+    else:
+        msg = f"Invalid argument {by=}. (expected one of {('key', 'value', 'item')})"
+        raise ValueError(msg)
+
+    return {k: v for k, v in sorted(x.items(), key=impl_key, reverse=reverse)}  # type: ignore
 
 
 def shuffled(

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/src/pythonwrench/disk_cache.py

@@ -362,19 +362,15 @@ def _disk_cache_impl(
 ) -> Callable[[Callable[P, T]], Callable[P, T]]:
     # for backward compatibility
     if cache_fname_fmt is None:
-        expected = "{fn_name}_{checksum_hex}{suffix}"
-        warnings.warn(
-            f"Deprecated argument value {cache_fname_fmt=}. (use {expected} instead)",
-            DeprecationWarning,
-        )
+        expected = "{fn_name}_{csum}{suffix}"
+        msg = f"Deprecated argument value {cache_fname_fmt=}. (use {expected} instead)"
+        warnings.warn(msg, DeprecationWarning)
         cache_fname_fmt = expected
 
     if cache_saving_backend is None:
         expected = "auto"
-        warnings.warn(
-            f"Deprecated argument value {cache_saving_backend=}. (use {expected} instead)",
-            DeprecationWarning,
-        )
+        msg = f"Deprecated argument value {cache_saving_backend=}. (use {expected} instead)"
+        warnings.warn(msg, DeprecationWarning)
         cache_saving_backend = expected
 
     if cache_saving_backend == "auto":

pythonwrench-0.5.1/src/pythonwrench/time.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import time
+from typing import Callable, Optional
+
+
+class Ticker:
+    def __init__(
+        self,
+        *,
+        get_time_fn: Callable[[], float] = time.perf_counter,
+        prev_tick: Optional[float] = None,
+    ) -> None:
+        if prev_tick is None:
+            prev_tick = get_time_fn()
+
+        super().__init__()
+        self._get_time_fn = get_time_fn
+        self._prev_tick = prev_tick
+
+    def tick(self) -> float:
+        now = self._get_time_fn()
+        duration = now - self._prev_tick
+        self._prev_tick = now
+        return duration
+
+    def set_prev_tick(self, prev_tick: Optional[float] = None) -> None:
+        if prev_tick is None:
+            prev_tick = self._get_time_fn()
+        self._prev_tick = prev_tick

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/src/pythonwrench/typing/__init__.py

@@ -16,6 +16,7 @@ if TYPE_CHECKING or lazy is None:
         is_builtin_number,
         is_builtin_obj,
         is_builtin_scalar,
+        is_collection_alias,
         is_dataclass_instance,
         is_iterable_bool,
         is_iterable_bytes_or_list,
@@ -24,7 +25,9 @@ if TYPE_CHECKING or lazy is None:
         is_iterable_integral,
         is_iterable_str,
         is_namedtuple_instance,
+        is_parameterized,
         is_sequence_str,
+        is_special_form,
         is_typed_dict,
         isinstance_generic,
     )
@@ -47,6 +50,7 @@ if TYPE_CHECKING or lazy is None:
         SupportsGetitemIterLen2,
         SupportsGetitemLen,
         SupportsGetitemLen2,
+        SupportsIter,
         SupportsIterLen,
         SupportsLen,
         SupportsMatmul,
@@ -70,6 +74,7 @@ else:
                 "is_builtin_number",
                 "is_builtin_obj",
                 "is_builtin_scalar",
+                "is_collection_alias",
                 "is_dataclass_instance",
                 "is_iterable_bool",
                 "is_iterable_bytes_or_list",
@@ -78,7 +83,9 @@ else:
                 "is_iterable_integral",
                 "is_iterable_str",
                 "is_namedtuple_instance",
+                "is_parameterized",
                 "is_sequence_str",
+                "is_special_form",
                 "is_typed_dict",
                 "isinstance_generic",
             ],
@@ -101,6 +108,7 @@ else:
                 "SupportsGetitemIterLen2",
                 "SupportsGetitemLen",
                 "SupportsGetitemLen2",
+                "SupportsIter",
                 "SupportsIterLen",
                 "SupportsLen",
                 "SupportsMatmul",

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/src/pythonwrench/typing/checks.py

@@ -4,6 +4,7 @@
 import inspect
 import logging
 import sys
+import typing
 from numbers import Integral
 from types import FunctionType, MethodType
 from typing import (
@@ -395,3 +396,99 @@ def is_typed_dict(x: Any) -> TypeGuard[type]:
         return x.__class__.__name__ == "_TypedDictMeta"
     else:
         return hasattr(x, "__orig_bases__") and TypedDict in x.__orig_bases__
+
+
+def is_parameterized(x: Any) -> bool:
+    """Returns True if object is a parametrized object like `Iterable[int]`, `Mapping[str, float]`, etc."""
+    return get_origin(x) is not None and len(get_args(x)) > 0
+
+
+_COLLECTION_ALIASES = [
+    typing.Iterable,
+    typing.Iterator,
+    typing.Reversible,
+    typing.Generator,
+    typing.AsyncIterable,
+    typing.AsyncIterator,
+    typing.AsyncGenerator,
+    typing.Collection,
+    typing.Container,
+    typing.Sized,
+    typing.Sequence,
+    typing.MutableSequence,
+    typing.Set,
+    typing.MutableSet,
+    typing.Mapping,
+    typing.MutableMapping,
+    typing.MappingView,
+    typing.KeysView,
+    typing.ItemsView,
+    typing.ValuesView,
+    typing.Awaitable,
+    typing.Coroutine,
+    typing.Callable,
+    typing.Hashable,
+    typing_extensions.Iterable,
+    typing_extensions.Iterator,
+    typing_extensions.Reversible,
+    typing_extensions.Generator,
+    typing_extensions.AsyncIterable,
+    typing_extensions.AsyncIterator,
+    typing_extensions.AsyncGenerator,
+    typing_extensions.Collection,
+    typing_extensions.Container,
+    typing_extensions.Sized,
+    typing_extensions.Sequence,
+    typing_extensions.MutableSequence,
+    typing_extensions.Set,
+    typing_extensions.MutableSet,
+    typing_extensions.Mapping,
+    typing_extensions.MutableMapping,
+    typing_extensions.MappingView,
+    typing_extensions.KeysView,
+    typing_extensions.ItemsView,
+    typing_extensions.ValuesView,
+    typing_extensions.Awaitable,
+    typing_extensions.Coroutine,
+    typing_extensions.Callable,
+    typing_extensions.Hashable,
+]
+
+_SPECIAL_FORMS = [] + [
+    getattr(module, candidate_name, None)
+    for module in (typing, typing_extensions)
+    for candidate_name in [
+        "Any",
+        "NoReturn",
+        "Union",
+        "Optional",
+        "Literal",
+        "Final",
+        "ClassVar",
+        "TypeVar",
+        "Annotated",
+        "Never",
+        "Self",
+        "Required",
+        "NotRequired",
+        "TypeGuard",
+        "TypeIs",
+        "Concatenate",
+        "ParamSpec",
+        "ParamSpecArgs",
+        "ParamSpecKwargs",
+        "TypeVarTuple",
+        "Unpack",
+    ]
+    if getattr(module, candidate_name, None) is not None
+]
+
+
+def is_collection_alias(x: Any) -> bool:
+    """Returns True if object is a non-parameterized collection alias type."""
+    return x in _COLLECTION_ALIASES
+
+
+def is_special_form(x: Any) -> bool:
+    """Returns True if object is a typing special form like `Any`."""
+    return x in _SPECIAL_FORMS

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/src/pythonwrench/typing/classes.py

@@ -5,6 +5,7 @@ from typing import (
     Any,
     ClassVar,
     Dict,
+    Iterable,
     Iterator,
     List,
     Protocol,
@@ -41,6 +42,7 @@ T_BuiltinScalar = TypeVar(
 )
 
 ListOrTuple = Union[List[_T_Item], Tuple[_T_Item, ...]]
+SupportsIter = Iterable
 
 
 @runtime_checkable

{pythonwrench-0.5.0 → pythonwrench-0.5.1/src/pythonwrench.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: pythonwrench
-Version: 0.5.0
+Version: 0.5.1
 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>
@@ -53,7 +53,8 @@ License-File: LICENSE
 Requires-Dist: lazy-loader>=0.4
 Requires-Dist: typing-extensions>=4.10.0
 Provides-Extra: dev
-Dynamic: license-file
+Provides-Extra: lazy
+Requires-Dist: lazy-loader>=0.4; extra == "lazy"
 
 # pythonwrench
 

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/src/pythonwrench.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 setup.py
+docs/requirements.txt
 src/pythonwrench/__init__.py
 src/pythonwrench/__main__.py
 src/pythonwrench/_core.py
@@ -30,6 +31,7 @@ src/pythonwrench/pickle.py
 src/pythonwrench/random.py
 src/pythonwrench/re.py
 src/pythonwrench/semver.py
+src/pythonwrench/time.py
 src/pythonwrench/warnings.py
 src/pythonwrench.egg-info/PKG-INFO
 src/pythonwrench.egg-info/SOURCES.txt

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/src/pythonwrench.egg-info/requires.txt

@@ -2,3 +2,6 @@ lazy-loader>=0.4
 typing-extensions>=4.10.0
 
 [dev]
+
+[lazy]
+lazy-loader>=0.4

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/tests/test_checksum.py

@@ -4,8 +4,11 @@
 import math
 import random
 import unittest
+from typing import Any, Iterable, Mapping, Tuple
 from unittest import TestCase
 
+from typing_extensions import Annotated
+
 from pythonwrench.checksum import checksum_any
 from pythonwrench.collections import all_ne
 from pythonwrench.math import nextafter
@@ -74,6 +77,23 @@ class TestChecksum(TestCase):
         assert Color.RED == Color.ROUGE
         assert checksum_any(Color.RED) == checksum_any(Color.ROUGE)
 
+    def test_typing_classes(self) -> None:
+        x = [
+            Any,
+            Iterable,
+            Iterable[int],
+            Annotated,
+            Annotated[int, "annotation"],
+            Tuple[int, ...],
+            Tuple[int],
+            Tuple[int, int],
+            tuple,
+            Mapping,
+            Mapping[int, int],
+        ]
+        csums = [checksum_any(xi) for xi in x]
+        assert all_ne(csums), f"{csums=}"
+
 
 if __name__ == "__main__":
     unittest.main()

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/tests/test_collections.py

@@ -25,6 +25,7 @@ from pythonwrench.collections import (
     recursive_generator,
     reduce_add,
     shuffled,
+    sorted_dict,
     unflat_dict_of_dict,
     unflat_list_of_list,
     union_dicts,
@@ -325,5 +326,18 @@ class TestReduce(TestCase):
             assert reduce_add(args, args, start=1)
 
 
+class TestSortedDict(TestCase):
+    def test_example_1(self) -> None:
+        x = {"b": 2, "a": 3, "c": 1}
+        result = sorted_dict(x)
+        assert result == {"a": 3, "b": 2, "c": 1}
+
+        result = sorted_dict(x, by="value")
+        assert result == {"c": 1, "b": 2, "a": 3}
+
+        result = sorted_dict(x, reverse=True, key=lambda x: x % 3, by="value")
+        assert result == {"a": 3, "c": 1, "b": 2}
+
+
 if __name__ == "__main__":
     unittest.main()

{pythonwrench-0.5.0 → pythonwrench-0.5.1}/tests/test_typing.py

@@ -22,14 +22,18 @@ from typing import (
 )
 from unittest import TestCase
 
+import typing_extensions
 from typing_extensions import NotRequired
 
 from pythonwrench.typing import (
     NoneType,
     check_args_types,
+    is_collection_alias,
     is_dataclass_instance,
     is_iterable_str,
     is_namedtuple_instance,
+    is_parameterized,
+    is_special_form,
     is_typed_dict,
     isinstance_generic,
 )
@@ -101,6 +105,25 @@ class TestChecks(TestCase):
         assert not is_dataclass_instance(nt1)
         assert not is_dataclass_instance(nt2)
 
+    def test_is_parameterized(self) -> None:
+        assert is_parameterized(Iterable[int])
+        assert is_parameterized(Tuple[int, ...])
+        assert not is_parameterized(Iterable)
+        assert not is_parameterized(Tuple)
+
+    def test_is_collection_alias(self) -> None:
+        assert not is_collection_alias(Iterable[int])
+        assert not is_collection_alias(Tuple[int, ...])
+        assert is_collection_alias(Iterable)
+        assert not is_collection_alias(Tuple)
+        assert not is_collection_alias(list)
+
+    def test_is_special_form(self) -> None:
+        assert not is_special_form(Iterable[int])
+        assert not is_special_form(Tuple[int, ...])
+        assert is_special_form(Any)
+        assert is_special_form(typing_extensions.Any)
+
 
 class TestIsInstanceGuard(TestCase):
     def test_docstring_examples(self) -> None: