pythonwrench 0.6.4__py3-none-any.whl

pythonwrench/typing/classes.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Protocol,
+    Tuple,
+    Type,
+    Union,
+    runtime_checkable,
+)
+
+try:
+    from types import UnionType  # type: ignore
+except ImportError:
+    # support older python versions
+    UnionType = type(Union)
+
+from typing_extensions import TypeAlias, TypeVar
+
+NoneType: TypeAlias = type(None)  # type: ignore
+EllipsisType: TypeAlias = type(...)  # type: ignore
+
+BuiltinCollection: TypeAlias = Union[list, tuple, dict, set, frozenset]
+BuiltinNumber: TypeAlias = Union[bool, int, float, complex]
+BuiltinScalar: TypeAlias = Union[bool, int, float, complex, NoneType, str, bytes]
+
+_T_Item = TypeVar("_T_Item", covariant=True)
+_T_Index = TypeVar("_T_Index", contravariant=True, default=Any)
+_T_Other = TypeVar("_T_Other", contravariant=True, default=Any)
+_T_Index2 = TypeVar("_T_Index2", contravariant=True)
+
+T_BuiltinNumber = TypeVar(
+    "T_BuiltinNumber",
+    bound=BuiltinNumber,
+    default=BuiltinNumber,
+    covariant=True,
+)
+T_BuiltinScalar = TypeVar(
+    "T_BuiltinScalar",
+    bound=BuiltinScalar,
+    default=BuiltinScalar,
+    covariant=True,
+)
+
+ListOrTuple = Union[List[_T_Item], Tuple[_T_Item, ...]]
+SupportsIter = Iterable
+
+
+@runtime_checkable
+class DataclassInstance(Protocol):
+    # Class meant for typing purpose only
+    __dataclass_fields__: ClassVar[Dict[str, Any]]
+
+
+Dataclass = Type[DataclassInstance]
+
+
+@runtime_checkable
+class NamedTupleInstance(Protocol):
+    # Class meant for typing purpose only
+    _fields: Tuple[str, ...]
+    _field_defaults: Dict[str, Any]
+
+    def _asdict(self) -> Dict[str, Any]:
+        """Perform the asdict operation."""
+        raise NotImplementedError
+
+    def __getitem__(self, idx, /):
+        """Return the item at the requested index or key."""
+        raise NotImplementedError
+
+    def __len__(self) -> int:
+        """Return the number of items in the instance."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsAdd(Protocol[_T_Other]):
+    """Protocol that support `__add__` (+) method."""
+
+    def __add__(self, other: _T_Other, /):
+        """Return the result of adding another object."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsAnd(Protocol[_T_Other]):
+    """Protocol that support `__and__` (&) method."""
+
+    def __and__(self, other: _T_Other, /):
+        """Return the result of applying the and operator."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsBool(Protocol):
+    """Protocol that support `__bool__` method."""
+
+    def __bool__(self) -> bool:
+        """Return the truth value of the instance."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsDiv(Protocol[_T_Other]):
+    """Protocol that support `__div__` (/) method."""
+
+    def __div__(self, other: _T_Other, /):
+        """Return the result of dividing by another object."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsGetitem(Protocol[_T_Item, _T_Index]):
+    """Protocol that support `__getitem__` method."""
+
+    def __getitem__(self, idx: _T_Index, /) -> _T_Item:
+        """Return the item at the requested index or key."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsGetitem2(Protocol[_T_Index2, _T_Item]):
+    """Protocol that support `__getitem__` method.
+
+    Same than `SupportsGetitem` except that generic parameters are in reversed order: [T_Index, T_Item].
+    """
+
+    def __getitem__(self, idx: _T_Index2, /) -> _T_Item:
+        """Return the item at the requested index or key."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsGetitemLen(Protocol[_T_Item, _T_Index]):
+    """Protocol that support `__getitem__` and `__len__` methods."""
+
+    def __getitem__(self, idx: _T_Index, /) -> _T_Item:
+        """Return the item at the requested index or key."""
+        raise NotImplementedError
+
+    def __len__(self) -> int:
+        """Return the number of items in the instance."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsGetitemLen2(Protocol[_T_Index2, _T_Item]):
+    """Protocol that support `__getitem__` and `__len__` methods.
+
+    Same than `SupportsGetitemLen` except that generic parameters are in reversed order: [T_Index, T_Item]."""
+
+    def __getitem__(self, idx: _T_Index2, /) -> _T_Item:
+        """Return the item at the requested index or key."""
+        raise NotImplementedError
+
+    def __len__(self) -> int:
+        """Return the number of items in the instance."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsGetitemIterLen(Protocol[_T_Item, _T_Index]):
+    """Protocol that support `__getitem__`, `__iter__` and `__len__` methods."""
+
+    def __getitem__(self, idx: _T_Index, /) -> _T_Item:
+        """Return the item at the requested index or key."""
+        raise NotImplementedError
+
+    def __iter__(self) -> Iterator[_T_Item]:
+        """Return an iterator over the instance."""
+        raise NotImplementedError
+
+    def __len__(self) -> int:
+        """Return the number of items in the instance."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsGetitemIterLen2(Protocol[_T_Index2, _T_Item]):
+    """Protocol that support `__getitem__`, `__iter__` and `__len__` methods.
+
+    Same than `SupportsGetitemIterLen` except that generic parameters are in reversed order: [T_Index, T_Item].
+    """
+
+    def __getitem__(self, idx: _T_Index2, /) -> _T_Item:
+        """Return the item at the requested index or key."""
+        raise NotImplementedError
+
+    def __iter__(self) -> Iterator[_T_Item]:
+        """Return an iterator over the instance."""
+        raise NotImplementedError
+
+    def __len__(self) -> int:
+        """Return the number of items in the instance."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsIterLen(Protocol[_T_Item]):
+    """Protocol that support `__iter__` and `__len__` methods."""
+
+    def __iter__(self) -> Iterator[_T_Item]:
+        """Return an iterator over the instance."""
+        raise NotImplementedError
+
+    def __len__(self) -> int:
+        """Return the number of items in the instance."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsLen(Protocol):
+    """Protocol that support `__len__` method."""
+
+    def __len__(self) -> int:
+        """Return the number of items in the instance."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsMul(Protocol[_T_Other]):
+    """Protocol that support `__mul__` (*) method."""
+
+    def __mul__(self, other: _T_Other, /):
+        """Return the result of multiplying by another object."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsOr(Protocol[_T_Other]):
+    """Protocol that support `__or__` (|) method."""
+
+    def __or__(self, other: _T_Other, /):
+        """Return the result of applying the or operator."""
+        raise NotImplementedError
+
+
+@runtime_checkable
+class SupportsMatmul(Protocol[_T_Other]):
+    """Protocol that support `__matmul__` (@) method."""
+
+    def __matmul__(self, other: _T_Other, /):
+        """Return the result of matrix multiplication."""
+        raise NotImplementedError

pythonwrench/warnings.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import warnings
+from functools import lru_cache, partial
+from typing import Any, Callable, Optional, Type, TypeVar, Union, overload
+
+from typing_extensions import ParamSpec
+
+from pythonwrench._core import T_Function, _decorator_factory, return_none
+
+P = ParamSpec("P")
+U = TypeVar("U")
+
+
+@overload
+def warn_once(
+    message: str,
+    category: Optional[Type[Warning]] = None,
+    stacklevel: int = 1,
+    source: Any = None,
+) -> None:
+    """Perform the warn once operation."""
+    ...
+
+
+@overload
+def warn_once(
+    message: Warning,
+    category: Any = None,
+    stacklevel: int = 1,
+    source: Any = None,
+) -> None:
+    """Perform the warn once operation."""
+    ...
+
+
+@lru_cache(maxsize=None)
+def warn_once(
+    message: Union[str, Warning],
+    category: Optional[Type[Warning]] = None,
+    stacklevel: int = 1,
+    source: Any = None,
+) -> None:
+    """Warn message once using warnings module."""
+    warnings.warn(message, category, stacklevel, source)
+
+
+def deprecated_alias(
+    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[..., T_Function]:
+    """Decorator to wrap deprecated function aliases."""
+    alternative_name = alternative.__name__ if alternative is not None else "None"
+    if pre_fn is None:
+        pre_fn = return_none
+
+    def inner_pre_fn(fn, *args, **kwargs) -> None:
+        """Perform the inner pre fn operation."""
+        msg = msg_fmt.format(fn_name=fn.__name__, alternative_name=alternative_name)
+        warn_fn(msg)
+        pre_fn(fn, *args, **kwargs)
+
+    return _decorator_factory(alternative, pre_fn=inner_pre_fn, post_fn=post_fn)
+
+
+@overload
+def deprecated_function(
+    fn: None = None,
+    /,
+    *,
+    msg_fmt: str = "Deprecated call to '{fn_name}'.",
+    warn_fn: Callable[[str], Any] = partial(warn_once, category=DeprecationWarning),
+) -> Callable[[T_Function], T_Function]:
+    """Perform the deprecated function operation."""
+    ...
+
+
+@overload
+def deprecated_function(
+    fn: T_Function,
+    /,
+    *,
+    msg_fmt: str = "Deprecated call to '{fn_name}'.",
+    warn_fn: Callable[[str], Any] = partial(warn_once, category=DeprecationWarning),
+) -> T_Function:
+    """Perform the deprecated function operation."""
+    ...
+
+
+def deprecated_function(
+    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,
+) -> Union[Callable[[T_Function], T_Function], T_Function]:
+    """Decorator to wrap deprecated functions."""
+    if pre_fn is None:
+        pre_fn = return_none
+
+    def inner_pre_fn(fn, *args, **kwargs):
+        """Perform the inner pre fn operation."""
+        msg = msg_fmt.format(fn_name=fn.__qualname__)
+        warn_fn(msg)
+        pre_fn(fn, *args, **kwargs)
+
+    decorator = _decorator_factory(None, pre_fn=inner_pre_fn, post_fn=post_fn)
+    if fn is None:
+        return decorator
+    else:
+        return decorator(fn)

pythonwrench-0.6.4.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.5
+Name: pythonwrench
+Version: 0.6.4
+Summary: Python library with tools for typing, manipulating collections, and more!
+Project-URL: Homepage, https://pypi.org/project/pythonwrench/
+Project-URL: Documentation, https://pythonwrench.readthedocs.io/
+Project-URL: Repository, https://github.com/Labbeti/pythonwrench.git
+Project-URL: Changelog, https://github.com/Labbeti/pythonwrench/blob/main/CHANGELOG.md
+Project-URL: Tracker, https://github.com/Labbeti/pythonwrench/issues
+Author-email: "Étienne Labbé (Labbeti)" <labbeti.pub@gmail.com>
+Maintainer-email: "Étienne Labbé (Labbeti)" <labbeti.pub@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Labbeti
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: python,tools,utilities
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: <3.15,>=3.8
+Requires-Dist: typing-extensions>=4.10.0
+Provides-Extra: dev
+Requires-Dist: coverage[toml]>=7.6.1; extra == 'dev'
+Requires-Dist: ipykernel>=6.29.5; extra == 'dev'
+Requires-Dist: ipython>=8.12.3; extra == 'dev'
+Requires-Dist: pandas>=2.0.3; extra == 'dev'
+Requires-Dist: pre-commit>=3.5.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.5; extra == 'dev'
+Requires-Dist: ruff~=0.14.9; extra == 'dev'
+Requires-Dist: sphinx-immaterial>=0.11.14; extra == 'dev'
+Requires-Dist: sphinx<9.0.0,>=7.1.2; extra == 'dev'
+Requires-Dist: twine>=6.1.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: sphinx-immaterial>=0.11.14; extra == 'docs'
+Requires-Dist: sphinx<9.0.0,>=7.1.2; extra == 'docs'
+Provides-Extra: lazy
+Requires-Dist: lazy-loader<1,>=0.4; extra == 'lazy'
+Provides-Extra: tests
+Requires-Dist: coverage[toml]>=7.6.1; extra == 'tests'
+Requires-Dist: pytest>=8.3.5; extra == 'tests'
+Requires-Dist: ruff~=0.14.9; extra == 'tests'
+Description-Content-Type: text/markdown
+
+# pythonwrench
+
+<center>
+
+<a href="https://www.python.org/">
+    <img alt="Python" src="https://img.shields.io/badge/-Python 3.8+-blue?style=for-the-badge&logo=python&logoColor=white">
+</a>
+<a href="https://github.com/Labbeti/pythonwrench/actions">
+    <img alt="Build" src="https://img.shields.io/github/actions/workflow/status/Labbeti/pythonwrench/test.yaml?branch=main&style=for-the-badge&logo=github">
+</a>
+<a href='https://pythonwrench.readthedocs.io/en/stable/?badge=stable'>
+    <img src='https://readthedocs.org/projects/pythonwrench/badge/?version=stable&style=for-the-badge' alt='Documentation Status' />
+</a>
+
+Python library with tools for typing, manipulating collections, and more!
+
+</center>
+
+
+## Installation
+
+With uv:
+```bash
+uv add pythonwrench
+```
+
+With pip:
+```bash
+pip install pythonwrench
+```
+
+This library has been tested on all Python versions **3.8 - 3.14**, requires only `typing_extensions>=4.10.0`, and runs on **Linux, Mac and Windows** systems.
+
+## Examples
+
+### Typing
+
+Check generic types with `isinstance_generic` :
+
+```python
+>>> import pythonwrench as pw
+>>>
+>>> # Behaves like builtin isinstance() :
+>>> pw.isinstance_generic({"a": 1, "b": 2}, dict)
+... True
+>>> # But works with generic types !
+>>> pw.isinstance_generic({"a": 1, "b": 2}, dict[str, int])
+... True
+>>> pw.isinstance_generic({"a": 1, "b": 2}, dict[str, str])
+... False
+```
+
+... or check specific methods with protocols classes beginning with `Supports`
+```python
+>>> import pythonwrench as pw
+>>>
+>>> isinstance({"a": 1, "b": 2}, pw.SupportsIterLen)
+... True
+>>> isinstance({"a": 1, "b": 2}, pw.SupportsGetitemLen)
+... True
+```
+
+Finally, you can also force argument type checking with `check_args_types` function :
+
+```python
+>>> import pythonwrench as pw
+
+>>> @pw.check_args_types
+>>> def f(a: int, b: str) -> str:
+>>>     return a * b
+
+>>> f(1, "a")  # pass check
+>>> f(1, 2)  # raises TypeError from decorator
+```
+
+### Collections
+
+Provides functions to facilitate iterables processing, like `unzip` :
+
+```python
+>>> import pythonwrench as pw
+>>>
+>>> list_of_tuples = [(1, "a"), (2, "b"), (3, "c"), (4, "d")]
+>>> pw.unzip(list_of_tuples)
+... [1, 2, 3, 4], ["a", "b", "c", "d"]
+>>> pw.flatten(list_of_tuples)
+... [1, "a", 2, "b", 3, "c", 4, "d"]
+```
+
+... or mathematical functions like `prod` or `argmax` :
+
+```python
+>>> import pythonwrench as pw
+>>>
+>>> values = [3, 1, 6, 4]
+>>> pw.prod(values)
+... 72
+>>> pw.argmax(values)
+... 2
+>>> pw.is_sorted(values)
+... False
+```
+
+Easely converts common python structures like list of dicts to dict of lists :
+
+```python
+>>> import pythonwrench as pw
+>>>
+>>> list_of_dicts = [{"a": 1, "b": 2}, {"a": 3, "b": 4}]
+>>> pw.list_dict_to_dict_list(list_of_dicts)
+... {"a": [1, 3], "b": [2, 4]}
+```
+
+... or dict of dicts :
+```python
+>>> import pythonwrench as pw
+>>>
+>>> dict_of_dicts = {"a": {"x": 1, "y": 2}, "b": {"x": 3, "y": 4}}
+>>> pw.flat_dict_of_dict(dict_of_dicts)
+... {"a.x": 1, "a.y": 2, "b.x": 3, "b.y": 4}
+```
+
+### Disk caching (memoize)
+
+```python
+>>> import pythonwrench as pw
+>>>
+>>> @pw.disk_cache_decorator
+>>> def heavy_processing():
+>>>     # Lot of stuff here
+>>>     ...
+>>>
+>>> data1 = heavy_processing()  # first call function is called and the result is stored on disk
+>>> data2 = heavy_processing()  # second call result is loaded from disk directly
+```
+
+### Semantic versionning parsing
+
+```python
+>>> import pythonwrench as pw
+>>> version = pw.Version("1.12.2")
+>>> version.to_tuple()
+... (1, 12, 2)
+>>> version = pw.Version("0.5.1-beta+linux")
+>>> version.to_tuple()
+... (0, 5, 1, "beta", "linux")
+
+>>> Version("1.3.1") < Version("1.4.0")
+... True
+```
+
+### Serialization
+
+```python
+>>> import pythonwrench as pw
+>>>
+>>> list_of_dicts = [{"a": 1, "b": 2}, {"a": 3, "b": 4}]
+>>> pw.dump_csv(list_of_dicts, "data.csv")
+>>> pw.dump_json(list_of_dicts, "data.json")
+>>> pw.load_json("data.json") == list_of_dicts
+... True
+```
+
+## Lazy loading
+To speed up this package loading, you can install it with `uv add pythonwrench[lazy]`, so `import pythonwrench as pw` will be faster.
+
+## Contact
+Maintainer:
+- [Étienne Labbé](https://labbeti.github.io/) "Labbeti": labbeti.pub@gmail.com

pythonwrench-0.6.4.dist-info/RECORD

@@ -0,0 +1,52 @@
+pythonwrench/__init__.py,sha256=x-hc6RsMcMvsfZmWSOOPqD1pO7uWDL_tXHtexZn_QZo,14412
+pythonwrench/__main__.py,sha256=-J-4fr1bVi_nkS7UDg41YdzPPKOdFml7lF71OI2cxEM,131
+pythonwrench/_core.py,sha256=W4LcZit_Df1ZHjbHWQtBka2x5EvFun7YSrwgFq4neFU,5690
+pythonwrench/abc.py,sha256=x4VhA3iTqYp2DBt0_eW-regwkYTIAM2aOqOBnEuOymc,751
+pythonwrench/cast.py,sha256=sZUPg90oITHuOZhM2hp4KUVjlMETMheI_uCsUsv_-8s,6187
+pythonwrench/checksum.py,sha256=G6z6L5kYb1aUHe2_iUBo5i5zcvsaj8-ry7RaA4grcrA,12472
+pythonwrench/concurrent.py,sha256=mZQFiy1GBipqB3R-DedQCbPtS8Zt_Re3FYJrxfkRfSM,2281
+pythonwrench/csv.py,sha256=ky7oEtWBosUnJ8yhVz-FaEBcBvgzzRmedrRHNmrWdyM,223
+pythonwrench/dataclasses.py,sha256=-b8F-Xtf_pkNkE7jLYE57WqBUuA8mec_lA_JKFYqd1w,3836
+pythonwrench/datetime.py,sha256=V1TqFrOcmIFTL9E9ZHEBRuD2rwl4x-c4abbNk6VvmbY,490
+pythonwrench/difflib.py,sha256=nSfNpMQQPgHmceA9-IRm8m_MxlK5dmVhOxJooVeie88,1051
+pythonwrench/disk_cache.py,sha256=Uu--EZhBlw5g1c6pLCwdj-zzinOZjtoDx2D7bf3irus,22540
+pythonwrench/enum.py,sha256=DMR7W_6xIyJl3deKJ7C8x_y8nXYd5BE8EtnW4IAMRbE,1758
+pythonwrench/functools.py,sha256=mU-Jc6yliqNGqMRVKWqXHlTYJISUe8ma16A7Py6jlHQ,6060
+pythonwrench/hashlib.py,sha256=1-pt0qv42MUxXoqjiLVhNV9xobznbK0YzYzSZeXl-NQ,2500
+pythonwrench/importlib.py,sha256=8fjjSO6GicWAodJJX0GaSDJGA4au8s8LzsQox1227I4,7163
+pythonwrench/inspect.py,sha256=1T_vIXOgw7QPs6BaoSeIozKfNbut37mO5UNHarb86SY,2033
+pythonwrench/json.py,sha256=lYHXwtuyoAt0gTaURGDX3bOHcrX2GrFh3-JkiG3qNLo,230
+pythonwrench/jsonl.py,sha256=0QFzFyO3rch0RaKAycC1jesO112fZTZSaUMDK-sedEw,237
+pythonwrench/logging.py,sha256=dbD7RxBF6MVhWlsP8wt03Scd2ujQbN3CbZR0fandjo0,7097
+pythonwrench/math.py,sha256=iuZNklFdNXo7Wjh4-KWJvN3kgZQu6Ws3oeygh7AAITE,2580
+pythonwrench/os.py,sha256=vHUcYNzR8LX3mQksfLgxOBPyqvZveb4L7VbmSObhEN4,6690
+pythonwrench/pickle.py,sha256=wXnekklbdyEEkRlMvDuZmZDLCIQaekE359qlup7voUE,244
+pythonwrench/random.py,sha256=604dz2ueMTJDKAoXEM4S-hvp9ypQARBDEgbaRmb_EU0,1252
+pythonwrench/re.py,sha256=34aQ0drOwB65OGpuj1aHz9EF0eMdgvOFxV27HcHGJvc,4046
+pythonwrench/semver.py,sha256=rD4Kz6asC9ZEqhBglCH__EVIckvA1TbDtS_UTYPKu0g,13501
+pythonwrench/time.py,sha256=muyTqTs3_hRdmAE4jErxL_Fio9LrLkEBYHvoTM_BfmA,951
+pythonwrench/warnings.py,sha256=Ue-TlfvywSnbm5MBIu0m6fVYOACHKwYlN3rXdV7OrJg,3340
+pythonwrench/argparse/__init__.py,sha256=CBkoXsq3MbtQt29PkioT4I-_iV4ZkWiIvzpaz7jG4Ys,2153
+pythonwrench/argparse/dataclass_.py,sha256=aFRvOX1gVxly--s9PzcXN59-lRH_xI2OBNom3xGY02I,8663
+pythonwrench/argparse/parsers.py,sha256=we7xoHVCIg5fRf7Ev6M0v3eKn3aoXzwELjZNgTizFJw,17092
+pythonwrench/collections/__init__.py,sha256=mXPH4G2sQwbqeuY2XfdbFrxD7pRXuBWcRSSWM-8YG8E,2421
+pythonwrench/collections/collections.py,sha256=_VrqNRAAN6pVaIt6nrq429p9HkRisVD32iwsDdOOKxo,23331
+pythonwrench/collections/prop.py,sha256=Sg_Av4QCWcLyI1Cu5taG2l2sDS5NE4AfQ_Fz97rINWw,2446
+pythonwrench/collections/reducers.py,sha256=T7al9jmDo7tZUTKX02eSt6CXmb1in34-3ImnfYUst14,6777
+pythonwrench/entrypoints/info.py,sha256=c1WlYYTBrWtqM1zyT55iTmQtujBkFPJRzZeB0TgB9GE,1254
+pythonwrench/entrypoints/safe_rmdir.py,sha256=u1ZrbYToDUuKH_AvYeSkgZWeJPD7qb5BWzdpLL753Y4,2773
+pythonwrench/entrypoints/tree.py,sha256=IKOkiBXtGKc4hoVKAz608oqlNpIWMO25iextJDJ1f-w,2666
+pythonwrench/serialization/__init__.py,sha256=6FwkizzN5dlc9beF6EcsXk83lLXUW59slO8sICRiohQ,1724
+pythonwrench/serialization/_core.py,sha256=I5imPIAmRRNBoVsvqdelZS4QCLjF4wnimVmSOc2g5eQ,1531
+pythonwrench/serialization/csv.py,sha256=eyFuWKnho3Va29uuqSksV5DJIpZLP8v9uH_qpxO6UZ0,15051
+pythonwrench/serialization/json.py,sha256=0wddq-kBluJF_PtIXW5eIVE9-6nu0DoPCEmKm19n7dg,4617
+pythonwrench/serialization/jsonl.py,sha256=R5reMSCgSUkngIm3ENe7KQUEnI06tg5kAVlUs2-bFIE,5506
+pythonwrench/serialization/pickle.py,sha256=MJntjLPwYUJ7PfnhYh_ns15SYEuH0GygXEttWYWvsoU,5051
+pythonwrench/typing/__init__.py,sha256=NO4bVE3AdNQTIr6t4Zkfb219wWsC7nLX8M_LPoATIPc,3406
+pythonwrench/typing/checks.py,sha256=-8Jos3HvzkmH9zfNyfp9k3pAn0x-PD0Kyx5ErTrVw98,16352
+pythonwrench/typing/classes.py,sha256=BWjVjWrFZBKfU7m8dve2EU00KhEnE95_iQfOpGSp0Aw,7234
+pythonwrench-0.6.4.dist-info/METADATA,sha256=g9ez7VaCEDQGVsZDhddckCVam3y1vuXdytHi5XLEoOw,7780
+pythonwrench-0.6.4.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+pythonwrench-0.6.4.dist-info/entry_points.txt,sha256=cbkAbcRN_B8X6GXLk-fPBXkhpbbEVcnrDGj7GGBEnH4,555
+pythonwrench-0.6.4.dist-info/licenses/LICENSE,sha256=Y0sRu8pOKAbX47H6HaYKhvj1NbuOyzSidGhjhVCzrlg,1064
+pythonwrench-0.6.4.dist-info/RECORD,,

pythonwrench-0.6.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pythonwrench-0.6.4.dist-info/entry_points.txt

@@ -0,0 +1,10 @@
+[console_scripts]
+pw-info = pythonwrench.entrypoints.info:main_info
+pw-safe-rmdir = pythonwrench.entrypoints.safe_rmdir:main_safe_rmdir
+pw-tree = pythonwrench.entrypoints.tree:main_tree
+pythonwrench-info = pythonwrench.entrypoints.info:main_info
+pythonwrench-safe-rmdir = pythonwrench.entrypoints.safe_rmdir:main_safe_rmdir
+pythonwrench-tree = pythonwrench.entrypoints.tree:main_tree
+pyw-info = pythonwrench.entrypoints.info:main_info
+pyw-safe-rmdir = pythonwrench.entrypoints.safe_rmdir:main_safe_rmdir
+pyw-tree = pythonwrench.entrypoints.tree:main_tree