dycw-utilities 0.133.6__tar.gz → 0.134.0__tar.gz

{dycw_utilities-0.133.6 → dycw_utilities-0.134.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.133.6
+Version: 0.134.0
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12

{dycw_utilities-0.133.6 → dycw_utilities-0.134.0}/pyproject.toml

@@ -104,7 +104,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.133.6"
+version = "0.134.0"
 
 [project.optional-dependencies]
 logging = [
@@ -131,7 +131,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.133.6"
+current_version = "0.134.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"
@@ -292,6 +292,7 @@ ignore = [
   "E501",  # line-too-long
   "PD",  # pandas-vet
   "PERF203",  # try-except-in-loop
+  "PLC0415",  # import-outside-top-level
   "PLR0911",  # too-many-return-statements
   "PLR0912",  # too-many-branches
   "PLR0913",  # too-many-arguments

{dycw_utilities-0.133.6 → dycw_utilities-0.134.0}/src/tests/test_arq.py

@@ -12,11 +12,11 @@ from utilities.arq import Worker, cron_raw, job_enqueuer
 from utilities.iterables import one
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    from collections.abc import Callable, Sequence
 
     from arq.typing import WorkerCoroutine
 
-    from utilities.types import CallableCoroutine1
+    from utilities.types import Coro
 
 
 class TestCronRaw:
@@ -51,7 +51,7 @@ class TestWorker:
             return x + y
 
         class Example(Worker):
-            functions_raw: Sequence[CallableCoroutine1[Any]] = [func]
+            functions_raw: Sequence[Callable[..., Coro[Any]]] = [func]
 
         func_use = cast("WorkerCoroutine", one(Example.functions))
         result = await func_use({}, x, y)

{dycw_utilities-0.133.6 → dycw_utilities-0.134.0}/src/tests/test_click.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 import enum
+from dataclasses import dataclass
 from enum import auto
 from operator import attrgetter
 from re import search
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar
 
 import whenever
 from click import ParamType, argument, command, echo, option
@@ -13,7 +14,6 @@ from hypothesis import given
 from hypothesis.strategies import (
     DataObject,
     SearchStrategy,
-    booleans,
     data,
     frozensets,
     ip_addresses,
@@ -40,6 +40,7 @@ from utilities.click import (
     FrozenSetStrs,
     IPv4Address,
     IPv6Address,
+    ListChoices,
     ListEnums,
     ListStrs,
     Month,
@@ -54,7 +55,6 @@ from utilities.hypothesis import (
     dates,
     freqs,
     months,
-    pairs,
     plain_datetimes,
     text_ascii,
     time_deltas,
@@ -68,9 +68,6 @@ if TYPE_CHECKING:
     from pathlib import Path
 
 
-_T = TypeVar("_T")
-
-
 class TestContextSettingsHelpOptionNames:
     @given(help_=sampled_from(["-h", "--help"]))
     def test_main(self, *, help_: str) -> None:
@@ -175,133 +172,226 @@ class _ExampleEnum(enum.Enum):
     c = auto()
 
 
-def _lift_serializer(
-    serializer: Callable[[_T], str], /, *, sort: bool = False
-) -> Callable[[Iterable[_T]], str]:
-    def wrapped(values: Iterable[_T], /) -> str:
+def _lift_serializer[T](
+    serializer: Callable[[T], str], /, *, sort: bool = False
+) -> Callable[[Iterable[T]], str]:
+    def wrapped(values: Iterable[T], /) -> str:
         return join_strs(map(serializer, values), sort=sort)
 
     return wrapped
 
 
+@dataclass(kw_only=True, slots=True)
+class _Case[T]:
+    param: ParamType
+    name: str
+    repr: str | None = None
+    strategy: SearchStrategy[T]
+    serialize: Callable[[T], str]
+    failable: bool = False
+
+
 class TestParameters:
-    @given(data=data(), use_value=booleans())
+    cases: ClassVar[list[_Case]] = [
+        _Case(
+            param=Date(),
+            name="date",
+            strategy=dates(),
+            serialize=whenever.Date.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=DateDelta(),
+            name="date delta",
+            strategy=date_deltas(parsable=True),
+            serialize=whenever.DateDelta.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=DateTimeDelta(),
+            name="date-time delta",
+            strategy=date_time_deltas(parsable=True),
+            serialize=whenever.DateTimeDelta.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=Enum(_ExampleEnum),
+            name="enum[_ExampleEnum]",
+            repr="ENUM[_ExampleEnum]",
+            strategy=sampled_from(_ExampleEnum),
+            serialize=attrgetter("name"),
+            failable=True,
+        ),
+        _Case(
+            param=Freq(),
+            name="freq",
+            strategy=freqs(),
+            serialize=utilities.whenever.Freq.serialize,
+            failable=True,
+        ),
+        _Case(
+            param=FrozenSetChoices(["a", "b", "c"]),
+            name="frozenset[choice]",
+            repr="FROZENSET[Choice(['a', 'b', 'c'])]",
+            strategy=frozensets(sampled_from(["a", "b", "c"])),
+            serialize=_lift_serializer(str, sort=True),
+            failable=True,
+        ),
+        _Case(
+            param=FrozenSetEnums(_ExampleEnum),
+            name="frozenset[enum[_ExampleEnum]]",
+            repr="FROZENSET[ENUM[_ExampleEnum]]",
+            strategy=frozensets(sampled_from(_ExampleEnum)),
+            serialize=_lift_serializer(attrgetter("name"), sort=True),
+            failable=True,
+        ),
+        _Case(
+            param=FrozenSetStrs(),
+            name="frozenset[text]",
+            repr="FROZENSET[STRING]",
+            strategy=frozensets(text_ascii()),
+            serialize=_lift_serializer(str, sort=True),
+        ),
+        _Case(
+            param=IPv4Address(),
+            name="ipv4 address",
+            strategy=ip_addresses(v=4),
+            serialize=str,
+            failable=True,
+        ),
+        _Case(
+            param=IPv6Address(),
+            name="ipv6 address",
+            strategy=ip_addresses(v=6),
+            serialize=str,
+            failable=True,
+        ),
+        _Case(
+            param=ListChoices(["a", "b", "c"]),
+            name="list[choice]",
+            repr="LIST[Choice(['a', 'b', 'c'])]",
+            strategy=frozensets(sampled_from(["a", "b", "c"])),
+            serialize=_lift_serializer(str, sort=True),
+            failable=True,
+        ),
+        _Case(
+            param=ListEnums(_ExampleEnum),
+            name="list[enum[_ExampleEnum]]",
+            repr="LIST[ENUM[_ExampleEnum]]",
+            strategy=lists(sampled_from(_ExampleEnum)),
+            serialize=_lift_serializer(attrgetter("name")),
+            failable=True,
+        ),
+        _Case(
+            param=Month(),
+            name="month",
+            strategy=months(),
+            serialize=utilities.whenever.Month.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=PlainDateTime(),
+            name="plain date-time",
+            strategy=plain_datetimes(),
+            serialize=whenever.PlainDateTime.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=Time(),
+            name="time",
+            strategy=times(),
+            serialize=whenever.Time.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=TimeDelta(),
+            name="time-delta",
+            strategy=time_deltas(),
+            serialize=whenever.TimeDelta.format_common_iso,
+            failable=True,
+        ),
+        _Case(
+            param=ZonedDateTime(),
+            name="zoned date-time",
+            strategy=zoned_datetimes(),
+            serialize=whenever.ZonedDateTime.format_common_iso,
+            failable=True,
+        ),
+    ]
+
+    @given(data=data())
     @mark.parametrize(
-        ("param", "exp_repr", "strategy", "serialize", "failable"),
-        [
-            param(Date(), "DATE", dates(), whenever.Date.format_common_iso, True),
-            param(
-                DateDelta(),
-                "DATE DELTA",
-                date_deltas(parsable=True),
-                whenever.DateDelta.format_common_iso,
-                True,
-            ),
-            param(
-                DateTimeDelta(),
-                "DATE-TIME DELTA",
-                date_time_deltas(parsable=True),
-                whenever.DateTimeDelta.format_common_iso,
-                True,
-            ),
-            param(
-                Enum(_ExampleEnum),
-                "ENUM[_ExampleEnum]",
-                sampled_from(_ExampleEnum),
-                attrgetter("name"),
-                True,
-            ),
-            param(Freq(), "FREQ", freqs(), utilities.whenever.Freq.serialize, True),
-            param(
-                FrozenSetChoices(["a", "b", "c"]),
-                "FROZENSET[Choice(['a', 'b', 'c'])]",
-                frozensets(sampled_from(["a", "b", "c"])),
-                _lift_serializer(str, sort=True),
-                True,
-            ),
-            param(
-                FrozenSetEnums(_ExampleEnum),
-                "FROZENSET[ENUM[_ExampleEnum]]",
-                frozensets(sampled_from(_ExampleEnum)),
-                _lift_serializer(attrgetter("name"), sort=True),
-                True,
-            ),
-            param(
-                FrozenSetStrs(),
-                "FROZENSET[STRING]",
-                frozensets(text_ascii()),
-                _lift_serializer(str, sort=True),
-                False,
-            ),
-            param(IPv4Address(), "IPV4 ADDRESS", ip_addresses(v=4), str, True),
-            param(IPv6Address(), "IPV6 ADDRESS", ip_addresses(v=6), str, True),
-            param(
-                ListEnums(_ExampleEnum),
-                "LIST[ENUM[_ExampleEnum]]",
-                lists(sampled_from(_ExampleEnum)),
-                _lift_serializer(attrgetter("name")),
-                True,
-            ),
-            param(
-                Month(),
-                "MONTH",
-                months(),
-                utilities.whenever.Month.format_common_iso,
-                True,
-            ),
-            param(
-                PlainDateTime(),
-                "PLAIN DATE-TIME",
-                plain_datetimes(),
-                whenever.PlainDateTime.format_common_iso,
-                True,
-            ),
-            param(Time(), "TIME", times(), whenever.Time.format_common_iso, True),
-            param(
-                TimeDelta(),
-                "TIME-DELTA",
-                time_deltas(),
-                whenever.TimeDelta.format_common_iso,
-                True,
-            ),
-            param(
-                ZonedDateTime(),
-                "ZONED DATE-TIME",
-                zoned_datetimes(),
-                whenever.ZonedDateTime.format_common_iso,
-                True,
-            ),
-        ],
+        ("param", "strategy", "serialize"),
+        [param(c.param, c.strategy, c.serialize) for c in cases],
     )
-    def test_main(
+    def test_default(
         self,
         *,
         data: DataObject,
         param: ParamType,
-        exp_repr: str,
         strategy: SearchStrategy[Any],
         serialize: Callable[[Any], str],
-        use_value: bool,
-        failable: bool,
     ) -> None:
-        assert repr(param) == exp_repr
-
-        default, value = data.draw(pairs(strategy))
+        default = data.draw(strategy)
 
         @command()
         @option("--value", type=param, default=default)
         def cli(*, value: Any) -> None:
             echo(f"value = {serialize(value)}")
 
-        args = [f"--value={serialize(value)}"] if use_value else None
-        result = CliRunner().invoke(cli, args=args)
+        result = CliRunner().invoke(cli, args=[])
         assert result.exit_code == 0
-        expected_str = serialize(value if use_value else default)
-        assert result.stdout == f"value = {expected_str}\n"
+        assert result.stdout == f"value = {serialize(default)}\n"
+
+    @given(data=data())
+    @mark.parametrize(
+        ("param", "strategy", "serialize"),
+        [param(c.param, c.strategy, c.serialize) for c in cases],
+    )
+    def test_cli_value(
+        self,
+        *,
+        data: DataObject,
+        param: ParamType,
+        strategy: SearchStrategy[Any],
+        serialize: Callable[[Any], str],
+    ) -> None:
+        @command()
+        @option("--value", type=param)
+        def cli(*, value: Any) -> None:
+            echo(f"value = {serialize(value)}")
 
-        result = CliRunner().invoke(cli, ["--value=error"])
-        expected = 2 if failable else 0
-        assert result.exit_code == expected
+        value = data.draw(strategy)
+        ser = serialize(value)
+        result = CliRunner().invoke(cli, args=[f"--value={ser}"])
+        assert result.exit_code == 0
+        assert result.stdout == f"value = {ser}\n"
+
+    @mark.parametrize(
+        ("param", "serialize"),
+        [param(c.param, c.serialize) for c in cases if c.failable],
+    )
+    def test_cli_fail(
+        self, *, param: ParamType, serialize: Callable[[Any], str]
+    ) -> None:
+        @command()
+        @option("--value", type=param)
+        def cli(*, value: Any) -> None:
+            echo(f"value = {serialize(value)}")
+
+        result = CliRunner().invoke(cli, args=["--value=invalid"])
+        assert result.exit_code == 2
+
+    @mark.parametrize(("param", "name"), [param(c.param, c.name) for c in cases])
+    def test_name(self, *, param: ParamType, name: str) -> None:
+        assert param.name == name
+
+    @mark.parametrize(
+        ("param", "repr_", "name"), [param(c.param, c.repr, c.name) for c in cases]
+    )
+    def test_repr(self, *, param: ParamType, repr_: str | None, name: str) -> None:
+        expected = name.upper() if repr_ is None else repr_
+        assert repr(param) == expected
 
     @mark.parametrize(
         "param",

{dycw_utilities-0.133.6 → dycw_utilities-0.134.0}/src/tests/test_eventkit.py

@@ -6,7 +6,7 @@ from functools import wraps
 from io import StringIO
 from logging import StreamHandler, getLogger
 from re import search
-from typing import TYPE_CHECKING, Literal, ParamSpec, TypeVar
+from typing import TYPE_CHECKING, Literal
 
 from eventkit import Event
 from hypothesis import given
@@ -26,10 +26,6 @@ if TYPE_CHECKING:
     from pathlib import Path
 
 
-_P = ParamSpec("_P")
-_R = TypeVar("_R")
-
-
 class TestAddListener:
     @given(sync_or_async=sampled_from(["sync", "async"]))
     async def test_main(self, *, sync_or_async: Literal["sync", "async"]) -> None:
@@ -210,9 +206,9 @@ class TestAddListener:
             nonlocal counter
             counter += 1
 
-        def increment(func: Callable[_P, _R], /) -> Callable[_P, _R]:
+        def increment[**P, R](func: Callable[P, R], /) -> Callable[P, R]:
             @wraps(func)
-            def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> _R:
+            def wrapped(*args: P.args, **kwargs: P.kwargs) -> R:
                 nonlocal counter
                 counter += 1
                 return func(*args, **kwargs)

{dycw_utilities-0.133.6 → dycw_utilities-0.134.0}/src/tests/test_functions.py

@@ -7,7 +7,7 @@ from itertools import chain
 from operator import neg
 from pathlib import Path
 from types import NoneType
-from typing import TYPE_CHECKING, Any, ClassVar, ParamSpec, TypeVar, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from hypothesis import given
 from hypothesis.strategies import (
@@ -106,11 +106,6 @@ if TYPE_CHECKING:
     from utilities.types import Number
 
 
-_P = ParamSpec("_P")
-_R = TypeVar("_R")
-_T = TypeVar("_T")
-
-
 class TestApplyDecorators:
     @given(n=integers())
     def test_main(self, *, n: int) -> None:
@@ -119,9 +114,9 @@ class TestApplyDecorators:
         def negate(x: int, /) -> int:
             return -x
 
-        def increment(func: Callable[_P, _R], /) -> Callable[_P, _R]:
+        def increment[**P, T](func: Callable[P, T], /) -> Callable[P, T]:
             @wraps(func)
-            def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> _R:
+            def wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
                 nonlocal counter
                 counter += 1
                 return func(*args, **kwargs)
@@ -538,7 +533,7 @@ class TestGetFuncNameAndGetFuncQualName:
 
     def test_decorated(self) -> None:
         @wraps(identity)
-        def wrapped(x: _T, /) -> _T:
+        def wrapped[T](x: T, /) -> T:
             return identity(x)
 
         assert get_func_name(wrapped) == "identity"
@@ -557,7 +552,7 @@ class TestGetFuncNameAndGetFuncQualName:
 
     def test_object(self) -> None:
         class Example:
-            def __call__(self, x: _T, /) -> _T:
+            def __call__[T](self, x: T, /) -> T:
                 return identity(x)
 
         obj = Example()
@@ -566,7 +561,7 @@ class TestGetFuncNameAndGetFuncQualName:
 
     def test_obj_method(self) -> None:
         class Example:
-            def obj_method(self, x: _T) -> _T:
+            def obj_method[T](self, x: T) -> T:
                 return identity(x)
 
         obj = Example()
@@ -579,7 +574,7 @@ class TestGetFuncNameAndGetFuncQualName:
     def test_obj_classmethod(self) -> None:
         class Example:
             @classmethod
-            def obj_classmethod(cls: _T) -> _T:
+            def obj_classmethod[T](cls: T) -> T:
                 return identity(cls)
 
         assert get_func_name(Example.obj_classmethod) == "Example.obj_classmethod"
@@ -591,7 +586,7 @@ class TestGetFuncNameAndGetFuncQualName:
     def test_obj_staticmethod(self) -> None:
         class Example:
             @staticmethod
-            def obj_staticmethod(x: _T) -> _T:
+            def obj_staticmethod[T](x: T) -> T:
                 return identity(x)
 
         assert get_func_name(Example.obj_staticmethod) == "Example.obj_staticmethod"

{dycw_utilities-0.133.6 → dycw_utilities-0.134.0}/src/tests/test_timer.py

@@ -101,6 +101,10 @@ class TestTimer:
             await sleep_td(2 * delta)
         assert timer >= delta
 
+    def test_hashable(self) -> None:
+        timer = Timer()
+        _ = hash(timer)
+
     @mark.parametrize("func", [param(repr), param(str)])
     async def test_repr_and_str(self, *, func: Callable[[Timer], str]) -> None:
         with Timer() as timer:

{dycw_utilities-0.133.6 → dycw_utilities-0.134.0}/src/tests/test_typed_settings.py

@@ -2,7 +2,6 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from ipaddress import IPv4Address, IPv6Address
 from pathlib import Path
-from typing import TypeVar
 
 import typed_settings
 from hypothesis import given
@@ -43,9 +42,6 @@ from utilities.whenever import Freq
 app_names = text_ascii(min_size=1).map(str.lower)
 
 
-_T = TypeVar("_T")
-
-
 class TestExtendedTSConverter:
     @given(data=data(), root=temp_paths(), app_name=app_names)
     @mark.parametrize(
@@ -67,15 +63,15 @@ class TestExtendedTSConverter:
             param(ZonedDateTime, zoned_datetimes(), ZonedDateTime.format_common_iso),
         ],
     )
-    def test_main(
+    def test_main[T](
         self,
         *,
         data: DataObject,
         root: Path,
         app_name: str,
-        test_cls: type[_T],
-        strategy: SearchStrategy[_T],
-        serialize: Callable[[_T], str],
+        test_cls: type[T],
+        strategy: SearchStrategy[T],
+        serialize: Callable[[T], str],
     ) -> None:
         default, value = data.draw(tuples(strategy, strategy))
 

{dycw_utilities-0.133.6 → dycw_utilities-0.134.0}/src/tests/test_types.py

@@ -9,13 +9,13 @@ from hypothesis.strategies import sampled_from
 from pytest import mark, param
 
 from utilities.platform import SYSTEM
-from utilities.types import Number, PathLike, TDataclass, TimeZone
+from utilities.types import Dataclass, Number, PathLike, TimeZone
 from utilities.typing import get_literal_elements
 
 
 class TestDataClassProtocol:
     def test_main(self) -> None:
-        def identity(x: TDataclass, /) -> TDataclass:
+        def identity[T: Dataclass](x: T, /) -> T:
             return x
 
         @dataclass(kw_only=True, slots=True)

{dycw_utilities-0.133.6 → dycw_utilities-0.134.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.133.6"
+__version__ = "0.134.0"