pythonwrench 0.6.4__py3-none-any.whl

pythonwrench/collections/prop.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Literal,
+    Optional,
+    TypeVar,
+)
+
+from pythonwrench.functools import function_alias
+
+K = TypeVar("K", covariant=True)
+T = TypeVar("T", covariant=True)
+U = TypeVar("U", covariant=True)
+V = TypeVar("V", covariant=True)
+W = TypeVar("W", covariant=True)
+X = TypeVar("X", covariant=True)
+Y = TypeVar("Y", covariant=True)
+
+KeyMode = Literal["intersect", "same", "union"]
+Order = Literal["left", "right"]
+
+
+def all_eq(it: Iterable[T], eq_fn: Optional[Callable[[T, T], bool]] = None) -> bool:
+    """Returns true if all elements in iterable are equal.
+
+    Note: This function returns True for iterable that contains 0 or 1 element.
+    """
+    it = list(it)
+    try:
+        first = next(iter(it))
+    except StopIteration:
+        return True
+
+    if eq_fn is None:
+        return all(first == elt for elt in it)
+    else:
+        return all(eq_fn(first, elt) for elt in it)
+
+
+def all_ne(
+    it: Iterable[T],
+    ne_fn: Optional[Callable[[T, T], bool]] = None,
+    use_set: bool = False,
+) -> bool:
+    """Returns true if all elements in iterable are differents.
+
+    Note: This function returns True for iterable that contains 0 or 1 element.
+    """
+    if isinstance(it, (set, frozenset, dict)):
+        return True
+    if use_set and ne_fn is not None:
+        raise ValueError(f"Cannot use arguments {use_set=} with {ne_fn=}.")
+
+    it = list(it)
+    if use_set:
+        return len(it) == len(set(it))
+    elif ne_fn is None:
+        return all(
+            it[i] != it[j] for i in range(len(it)) for j in range(i + 1, len(it))
+        )
+    else:
+        return all(
+            ne_fn(it[i], it[j]) for i in range(len(it)) for j in range(i + 1, len(it))
+        )
+
+
+@function_alias(all_eq)
+def is_full(*args, **kwargs):
+    """Return whether full."""
+    ...
+
+
+def is_sorted(
+    x: Iterable[Any],
+    *,
+    reverse: bool = False,
+    strict: bool = False,
+) -> bool:
+    """Return whether sorted."""
+    it = iter(x)
+    try:
+        prev = next(it)
+    except StopIteration:
+        return True
+
+    for xi in it:
+        if not reverse and prev > xi:
+            return False
+        if reverse and prev < xi:
+            return False
+        if strict and prev == xi:
+            return False
+        prev = xi
+    return True
+
+
+@function_alias(all_ne)
+def is_unique(*args, **kwargs):
+    """Return whether unique."""
+    ...

pythonwrench/collections/reducers.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import operator
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    overload,
+)
+
+from pythonwrench.functools import function_alias
+from pythonwrench.typing.checks import isinstance_generic
+from pythonwrench.typing.classes import (
+    SupportsAdd,
+    SupportsAnd,
+    SupportsMatmul,
+    SupportsMul,
+    SupportsOr,
+)
+
+T = TypeVar("T")
+T_SupportsAdd = TypeVar("T_SupportsAdd", bound=SupportsAdd)
+T_SupportsAnd = TypeVar("T_SupportsAnd", bound=SupportsAnd)
+T_SupportsMul = TypeVar("T_SupportsMul", bound=SupportsMul)
+T_SupportsOr = TypeVar("T_SupportsOr", bound=SupportsOr)
+T_SupportsMatmul = TypeVar("T_SupportsMatmul", bound=SupportsMatmul)
+
+
+@overload
+def reduce_add(
+    args: Iterable[T_SupportsAdd],
+    /,
+    *,
+    start: T_SupportsAdd,
+) -> T_SupportsAdd:
+    """Perform the reduce add operation."""
+    ...
+
+
+@overload
+def reduce_add(
+    *args: T_SupportsAdd,
+    start: T_SupportsAdd,
+) -> T_SupportsAdd:
+    """Perform the reduce add operation."""
+    ...
+
+
+@overload
+def reduce_add(
+    arg0: T_SupportsAdd,
+    /,
+    *args: T_SupportsAdd,
+    start: Optional[T_SupportsAdd] = None,
+) -> T_SupportsAdd:
+    """Perform the reduce add operation."""
+    ...
+
+
+def reduce_add(*args, start=None):
+    """Reduce elements using "add" operator (+)."""
+    return _reduce(*args, start=start, op_fn=operator.add, type_=SupportsAdd)
+
+
+@overload
+def reduce_and(
+    args: Iterable[T_SupportsAnd],
+    /,
+    *,
+    start: T_SupportsAnd,
+) -> T_SupportsAnd:
+    """Perform the reduce and operation."""
+    ...
+
+
+@overload
+def reduce_and(
+    *args: T_SupportsAnd,
+    start: T_SupportsAnd,
+) -> T_SupportsAnd:
+    """Perform the reduce and operation."""
+    ...
+
+
+@overload
+def reduce_and(
+    arg0: T_SupportsAnd,
+    /,
+    *args: T_SupportsAnd,
+    start: Optional[T_SupportsAnd] = None,
+) -> T_SupportsAnd:
+    """Perform the reduce and operation."""
+    ...
+
+
+def reduce_and(*args, start=None):
+    """Reduce elements using "and" operator (&)."""
+    return _reduce(*args, start=start, op_fn=operator.and_, type_=SupportsAnd)
+
+
+@overload
+def reduce_matmul(
+    args: Iterable[T_SupportsMatmul],
+    /,
+    *,
+    start: T_SupportsMatmul,
+) -> T_SupportsMatmul:
+    """Perform the reduce matmul operation."""
+    ...
+
+
+@overload
+def reduce_matmul(
+    *args: T_SupportsMatmul,
+    start: T_SupportsMatmul,
+) -> T_SupportsMatmul:
+    """Perform the reduce matmul operation."""
+    ...
+
+
+@overload
+def reduce_matmul(
+    arg0: T_SupportsMatmul,
+    /,
+    *args: T_SupportsMatmul,
+    start: Optional[T_SupportsMatmul] = None,
+) -> T_SupportsMatmul:
+    """Perform the reduce matmul operation."""
+    ...
+
+
+def reduce_matmul(*args, start=None):
+    """Reduce elements using "mul" operator (*)."""
+    return _reduce(*args, start=start, op_fn=operator.matmul, type_=SupportsMatmul)
+
+
+@overload
+def reduce_mul(
+    args: Iterable[T_SupportsMul],
+    /,
+    *,
+    start: T_SupportsMul,
+) -> T_SupportsMul:
+    """Perform the reduce mul operation."""
+    ...
+
+
+@overload
+def reduce_mul(
+    *args: T_SupportsMul,
+    start: T_SupportsMul,
+) -> T_SupportsMul:
+    """Perform the reduce mul operation."""
+    ...
+
+
+@overload
+def reduce_mul(
+    arg0: T_SupportsMul,
+    /,
+    *args: T_SupportsMul,
+    start: Optional[T_SupportsMul] = None,
+) -> T_SupportsMul:
+    """Perform the reduce mul operation."""
+    ...
+
+
+def reduce_mul(*args, start=None):
+    """Reduce elements using "mul" operator (*)."""
+    return _reduce(*args, start=start, op_fn=operator.mul, type_=SupportsMul)
+
+
+@overload
+def reduce_or(
+    args: Iterable[T_SupportsOr],
+    /,
+    *,
+    start: T_SupportsOr,
+) -> T_SupportsOr:
+    """Perform the reduce or operation."""
+    ...
+
+
+@overload
+def reduce_or(
+    *args: T_SupportsOr,
+    start: T_SupportsOr,
+) -> T_SupportsOr:
+    """Perform the reduce or operation."""
+    ...
+
+
+@overload
+def reduce_or(
+    arg0: T_SupportsOr,
+    /,
+    *args: T_SupportsOr,
+    start: Optional[T_SupportsOr] = None,
+) -> T_SupportsOr:
+    """Perform the reduce or operation."""
+    ...
+
+
+def reduce_or(*args, start=None):
+    """Reduce elements using "or" operator (|)."""
+    return _reduce(*args, start=start, op_fn=operator.or_, type_=SupportsOr)
+
+
+def _reduce(
+    *args,
+    start: Optional[T] = None,
+    op_fn: Callable[[T, T], T],
+    type_: Type[T],
+) -> T:
+    """Perform the reduce operation."""
+    if isinstance_generic(args, Tuple[Iterable[type_]]):
+        it_or_args = args[0]
+    elif isinstance_generic(args, Tuple[type_, ...]):
+        it_or_args = args
+    else:
+        msg = f"Invalid positional arguments {args}. (expected {Tuple[type_, ...]} or {Tuple[Iterable[type_]]})"
+        raise TypeError(msg)
+
+    it: Iterator[T] = iter(it_or_args)
+
+    if isinstance(start, type_):
+        accumulator = start
+    elif start is None or start is ...:
+        try:
+            accumulator = next(it)
+        except StopIteration:
+            msg = f"Invalid combinaison of arguments {args=} and {start=}. (expected at least 1 non-empty argument or start object that supports operator.)"
+            raise ValueError(msg)
+    else:
+        msg = f"Invalid argument type {type(start)}."
+        raise TypeError(msg)
+
+    for arg in it:
+        accumulator = op_fn(accumulator, arg)
+    return accumulator
+
+
+@overload
+def sum(
+    args: Iterable[T_SupportsAdd],
+    /,
+    *,
+    start: T_SupportsAdd = 0,
+) -> T_SupportsAdd:
+    """Perform the sum operation."""
+    ...
+
+
+@overload
+def sum(
+    *args: T_SupportsAdd,
+    start: T_SupportsAdd = 0,
+) -> T_SupportsAdd:
+    """Perform the sum operation."""
+    ...
+
+
+@overload
+def sum(
+    arg0: T_SupportsAdd,
+    /,
+    *args: T_SupportsAdd,
+    start: Optional[T_SupportsAdd] = 0,
+) -> T_SupportsAdd:
+    """Perform the sum operation."""
+    ...
+
+
+def sum(*args, start: Any = 0):
+    """Compute sum of elements."""
+    return reduce_add(*args, start=start)
+
+
+@overload
+def prod(
+    args: Iterable[T_SupportsMul],
+    /,
+    *,
+    start: T_SupportsMul = 1,
+) -> T_SupportsMul:
+    """Perform the prod operation."""
+    ...
+
+
+@overload
+def prod(
+    *args: T_SupportsMul,
+    start: T_SupportsMul = 1,
+) -> T_SupportsMul:
+    """Perform the prod operation."""
+    ...
+
+
+@overload
+def prod(
+    arg0: T_SupportsMul,
+    /,
+    *args: T_SupportsMul,
+    start: Optional[T_SupportsMul] = 1,
+) -> T_SupportsMul:
+    """Perform the prod operation."""
+    ...
+
+
+def prod(*args, start: Any = 1):
+    """Compute product of elements."""
+    return reduce_mul(*args, start=start)
+
+
+@function_alias(reduce_and)
+def intersect(*args, **kwargs):
+    """Perform the intersect operation."""
+    ...
+
+
+@function_alias(reduce_or)
+def union(*args, **kwargs):
+    """Perform the union operation."""
+    ...

pythonwrench/concurrent.py

@@ -0,0 +1,73 @@
+#!/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
+
+from typing_extensions import ParamSpec
+
+logger = logging.getLogger(__name__)
+
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+class ThreadPoolExecutorHelper(Generic[P, T]):
+    # Note: use commas for typing because Future is not generic in older python versions
+
+    def __init__(
+        self,
+        fn: Callable[P, T],
+        *,
+        executor_kwds: Optional[Dict[str, Any]] = None,
+        executor: Optional[ThreadPoolExecutor] = None,
+        futures: "Iterable[Future[T]]" = (),
+        **default_fn_kwds,
+    ) -> None:
+        """Initialize the instance."""
+        futures = list(futures)
+
+        super().__init__()
+        self.fn = fn
+        self.executor_kwds = executor_kwds
+        self.executor = executor
+        self.futures = futures
+        self.default_kwargs = default_fn_kwds
+
+    def submit(self, *args: P.args, **kwargs: P.kwargs) -> "Future[T]":
+        """Perform the submit operation."""
+        if self.executor is None:
+            executor_kwds = self.executor_kwds
+            if executor_kwds is None:
+                executor_kwds = {}
+            self.executor = ThreadPoolExecutor(**executor_kwds)
+
+        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
+
+    def wait_all(self, shutdown: bool = True, verbose: bool = True) -> List[T]:
+        """Perform the wait all operation."""
+        futures = self.futures
+        if verbose:
+            try:
+                import tqdm  # type: ignore
+
+                futures = tqdm.tqdm(futures, disable=not verbose)
+            except ImportError:
+                msg = "Cannot display verbose bar because tqdm is not installed."
+                logger.warning(msg)
+
+        results = [future.result() for future in futures]
+        self.futures.clear()
+        if shutdown and self.executor is not None:
+            self.executor.shutdown()
+            self.executor = None
+        return results

pythonwrench/csv.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# for backward compatibility
+from pythonwrench.serialization.csv import (  # noqa: F401
+    dump_csv,
+    dumps_csv,
+    load_csv,
+    loads_csv,
+    read_csv,
+    save_csv,
+)

pythonwrench/dataclasses.py

@@ -0,0 +1,117 @@
+#!/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:
+        """Perform the setattr operation."""
+        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:
+        """Perform the setitem operation."""
+        dict.__setitem__(self, key, value)
+        if key in self.__dataclass_fields__:
+            object.__setattr__(self, key, value)
+
+    def delitem(self: Any, key: Any) -> None:
+        """Perform the delitem operation."""
+        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:
+        """Perform the update operation."""
+        for key, value in dict(*args, **kwargs).items():
+            setitem(self, key, value)
+
+    def setdefault(self: Any, key: Any, default: Any = None) -> Any:
+        """Perform the setdefault operation."""
+        if key not in self:
+            setitem(self, key, default)
+        return self[key]
+
+    def pop(self: Any, key: Any, *default: Any) -> Any:
+        """Perform the pop operation."""
+        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:
+        """Perform the clear operation."""
+        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]:
+    """Return defaults values."""
+    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/datetime.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import datetime
+
+ISO8601_DAY_FORMAT = r"%Y-%m-%d"
+ISO8601_HOUR_FORMAT_DOUBLE_DOT = r"%Y-%m-%dT%H:%M:%S"
+
+
+def get_now_iso8601() -> str:
+    """Returns current datetime as string with the ISO8601 format."""
+    return get_now(ISO8601_HOUR_FORMAT_DOUBLE_DOT)
+
+
+def get_now(fmt: str = ISO8601_HOUR_FORMAT_DOUBLE_DOT) -> str:
+    """Returns current datetime as string with the specified format."""
+    return datetime.datetime.now().strftime(fmt)

pythonwrench/difflib.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import math
+from difflib import SequenceMatcher
+from typing import Callable, Iterable, Optional
+
+
+def find_closest_in_list(
+    x: str,
+    lst: Iterable[str],
+    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
+
+    for elt in lst:
+        sim = sim_fn(x, elt)
+        if (higher_is_closer and best_sim < sim) or (
+            not higher_is_closer and best_sim > sim
+        ):
+            best_sim = sim
+            closest = elt
+
+    if math.isinf(best_sim):
+        msg = f"Invalid argument {lst=}. (expected non-empty iterable of strings)"
+        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()