dycw-utilities 0.136.3__tar.gz → 0.136.5__tar.gz

{dycw_utilities-0.136.3 → dycw_utilities-0.136.5}/PKG-INFO

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

{dycw_utilities-0.136.3 → dycw_utilities-0.136.5}/pyproject.toml

@@ -14,7 +14,6 @@ altair-test = [
   "img2pdf",
   "vl-convert-python",
 ]
-arq = ["arq >= 0.26.3, < 0.27"]
 atools = ["atools >= 0.14.2, < 0.15"]
 cachetools = ["cachetools >= 6.1.0, < 6.2"]
 click = ["click >= 8.2.1, < 8.3"]
@@ -42,7 +41,7 @@ fpdf2 = ["fpdf2 >= 2.8.3, < 2.9"]
 hashlib-test = ["orjson"]
 http-test = ["orjson"]
 hypothesis = ["hypothesis >= 6.135.2, < 6.136"]
-hypothesis-test = ["luigi", "pathvalidate", "numpy", "pytest-rerunfailures"]
+hypothesis-test = ["libcst", "luigi", "pathvalidate", "numpy", "pytest-rerunfailures"]
 inflect = ["inflect >= 7.5.0, < 7.6"]
 jupyter-test = ["pandas", "polars"]
 libcst = ["libcst >= 1.8.0, < 1.9"]
@@ -78,7 +77,7 @@ pytest-regressions = ["pytest-regressions >= 2.8.0, < 2.9"]
 pytest-regressions-test = ["orjson", "polars-lts-cpu"]
 pytest-test = ["orjson", "pytest-rng", "pytest-rerunfailures"]
 python-dotenv = ["python-dotenv >= 1.1.0, < 1.2"]
-redis = ["redis >= 5.3.0, < 6.0", "orjson"]
+redis = ["redis >= 6.2.0, < 6.3", "orjson"]
 redis-test = ["pytest-rerunfailures"]
 reprlib-test = ["rich"]
 scipy = ["scipy >= 1.15.3, < 1.16"]
@@ -106,7 +105,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.136.3"
+version = "0.136.5"
 
 [project.optional-dependencies]
 logging = [
@@ -134,7 +133,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.136.3"
+current_version = "0.136.5"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.136.3 → dycw_utilities-0.136.5}/src/tests/test_hypothesis.py

@@ -21,6 +21,7 @@ from hypothesis.strategies import (
     sets,
     timezones,
 )
+from libcst import Import, ImportFrom
 from luigi import Task
 from numpy import inf, int64, isfinite, isinf, isnan, ravel, rint
 from pathvalidate import validate_filepath
@@ -55,6 +56,8 @@ from utilities.hypothesis import (
     freqs,
     git_repos,
     hashables,
+    import_froms,
+    imports,
     int32s,
     int64s,
     int_arrays,
@@ -88,6 +91,8 @@ from utilities.hypothesis import (
     versions,
     zoned_datetimes,
 )
+from utilities.iterables import one
+from utilities.libcst import parse_import
 from utilities.math import (
     MAX_FLOAT32,
     MAX_FLOAT64,
@@ -514,6 +519,36 @@ class TestHashables:
         _ = hash(x)
 
 
+class TestImports:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_depth = data.draw(integers(0, 10) | none())
+        max_depth = data.draw(integers(0, 10) | none())
+        with assume_does_not_raise(InvalidArgument):
+            imp = data.draw(imports(min_depth=min_depth, max_depth=max_depth))
+        assert isinstance(imp, Import)
+        parsed = one(parse_import(imp))
+        if min_depth is not None:
+            assert len(parsed.module.split(".")) >= min_depth
+        if max_depth is not None:
+            assert len(parsed.module.split(".")) <= max_depth
+
+
+class TestImportFroms:
+    @given(data=data())
+    def test_main(self, *, data: DataObject) -> None:
+        min_depth = data.draw(integers(0, 10) | none())
+        max_depth = data.draw(integers(0, 10) | none())
+        with assume_does_not_raise(InvalidArgument):
+            imp = data.draw(import_froms(min_depth=min_depth, max_depth=max_depth))
+        assert isinstance(imp, ImportFrom)
+        parsed = one(parse_import(imp))
+        if min_depth is not None:
+            assert len(parsed.module.split(".")) >= min_depth
+        if max_depth is not None:
+            assert len(parsed.module.split(".")) <= max_depth
+
+
 class TestIntArrays:
     @given(
         data=data(),
@@ -648,10 +683,17 @@ class TestPairs:
 class TestPaths:
     @given(data=data())
     def test_main(self, *, data: DataObject) -> None:
-        path = data.draw(paths())
+        min_depth = data.draw(integers(0, 10) | none())
+        max_depth = data.draw(integers(0, 10) | none())
+        with assume_does_not_raise(InvalidArgument):
+            path = data.draw(paths(min_depth=min_depth, max_depth=max_depth))
         assert isinstance(path, Path)
         assert not path.is_absolute()
         validate_filepath(str(path))
+        if min_depth is not None:
+            assert len(path.parts) >= min_depth
+        if max_depth is not None:
+            assert len(path.parts) <= max_depth
 
 
 class TestPlainDateTimes:

{dycw_utilities-0.136.3 → dycw_utilities-0.136.5}/src/tests/test_libcst.py

@@ -25,8 +25,8 @@ from utilities.libcst import (
     _ParseImportAliasError,
     _ParseImportEmptyModuleError,
     generate_f_string,
-    generate_from_import,
     generate_import,
+    generate_import_from,
     join_dotted_str,
     parse_import,
     render_module,
@@ -42,22 +42,6 @@ class TestGenerateFString:
         assert result == expected
 
 
-class TestGenerateFromImport:
-    @given(
-        case=sampled_from([
-            ("foo", "bar", None, "from foo import bar"),
-            ("foo", "bar", "bar2", "from foo import bar as bar2"),
-            ("foo.bar", "baz", None, "from foo.bar import baz"),
-            ("foo.bar", "baz", "baz2", "from foo.bar import baz as baz2"),
-        ])
-    )
-    def test_main(self, *, case: tuple[str, str, str | None, str]) -> None:
-        module, name, asname, expected = case
-        imp = generate_from_import(module, name, asname=asname)
-        result = Module([SimpleStatementLine([imp])]).code.strip("\n")
-        assert result == expected
-
-
 class TestGenerateImport:
     @given(
         case=sampled_from([
@@ -74,6 +58,22 @@ class TestGenerateImport:
         assert result == expected
 
 
+class TestGenerateImportFrom:
+    @given(
+        case=sampled_from([
+            ("foo", "bar", None, "from foo import bar"),
+            ("foo", "bar", "bar2", "from foo import bar as bar2"),
+            ("foo.bar", "baz", None, "from foo.bar import baz"),
+            ("foo.bar", "baz", "baz2", "from foo.bar import baz as baz2"),
+        ])
+    )
+    def test_main(self, *, case: tuple[str, str, str | None, str]) -> None:
+        module, name, asname, expected = case
+        imp = generate_import_from(module, name, asname=asname)
+        result = Module([SimpleStatementLine([imp])]).code.strip("\n")
+        assert result == expected
+
+
 class TestParseImport:
     def test_import_one_name(self) -> None:
         imp = Import(names=[ImportAlias(Name("foo"))])

{dycw_utilities-0.136.3 → dycw_utilities-0.136.5}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.136.3"
+__version__ = "0.136.5"

{dycw_utilities-0.136.3 → dycw_utilities-0.136.5}/src/utilities/hypothesis.py

@@ -106,6 +106,7 @@ if TYPE_CHECKING:
     from collections.abc import Collection, Hashable, Iterable, Iterator
 
     from hypothesis.database import ExampleDatabase
+    from libcst import Import, ImportFrom
     from numpy.random import RandomState
 
     from utilities.numpy import NDArrayB, NDArrayF, NDArrayI, NDArrayO
@@ -555,6 +556,59 @@ def hashables() -> SearchStrategy[Hashable]:
 ##
 
 
+@composite
+def import_froms(
+    draw: DrawFn,
+    /,
+    *,
+    min_depth: MaybeSearchStrategy[int | None] = None,
+    max_depth: MaybeSearchStrategy[int | None] = None,
+) -> ImportFrom:
+    """Strategy for generating import-froms."""
+    from utilities.libcst import generate_import_from
+
+    min_depth_, max_depth_ = [draw2(draw, d) for d in [min_depth, max_depth]]
+    path = draw(
+        paths(
+            min_depth=1 if min_depth_ is None else max(min_depth_, 1),
+            max_depth=max_depth_,
+        )
+    )
+    module = ".".join(path.parts)
+    name = draw(text_ascii(min_size=1))
+    asname = draw(text_ascii(min_size=1) | none())
+    return generate_import_from(module, name, asname=asname)
+
+
+##
+
+
+@composite
+def imports(
+    draw: DrawFn,
+    /,
+    *,
+    min_depth: MaybeSearchStrategy[int | None] = None,
+    max_depth: MaybeSearchStrategy[int | None] = None,
+) -> Import:
+    """Strategy for generating imports."""
+    from utilities.libcst import generate_import
+
+    min_depth_, max_depth_ = [draw2(draw, d) for d in [min_depth, max_depth]]
+    path = draw(
+        paths(
+            min_depth=1 if min_depth_ is None else max(min_depth_, 1),
+            max_depth=max_depth_,
+        )
+    )
+    module = ".".join(path.parts)
+    asname = draw(text_ascii(min_size=1) | none())
+    return generate_import(module, asname=asname)
+
+
+##
+
+
 @composite
 def int_arrays(
     draw: DrawFn,
@@ -746,11 +800,32 @@ def _pairs_map[T](elements: list[T], /) -> tuple[T, T]:
 ##
 
 
-def paths() -> SearchStrategy[Path]:
+@composite
+def paths(
+    draw: DrawFn,
+    /,
+    *,
+    min_depth: MaybeSearchStrategy[int | None] = None,
+    max_depth: MaybeSearchStrategy[int | None] = None,
+) -> Path:
     """Strategy for generating `Path`s."""
+    min_depth_, max_depth_ = [draw2(draw, d) for d in [min_depth, max_depth]]
+    parts = draw(
+        lists(
+            _path_parts(),
+            min_size=0 if min_depth_ is None else min_depth_,
+            max_size=max_depth_,
+        )
+    )
+    return Path(*parts)
+
+
+@composite
+def _path_parts(draw: DrawFn, /) -> str:
+    part = draw(text_ascii(min_size=1, max_size=10))
     reserved = {"AUX", "NUL"}
-    strategy = text_ascii(min_size=1, max_size=10).filter(lambda x: x not in reserved)
-    return lists(strategy, max_size=10).map(lambda parts: Path(*parts))
+    _ = assume(part not in reserved)
+    return part
 
 
 ##
@@ -1292,6 +1367,8 @@ __all__ = [
     "freqs",
     "git_repos",
     "hashables",
+    "import_froms",
+    "imports",
     "int32s",
     "int64s",
     "int_arrays",

{dycw_utilities-0.136.3 → dycw_utilities-0.136.5}/src/utilities/libcst.py

@@ -23,16 +23,6 @@ from libcst import (
 from utilities.errors import ImpossibleCaseError
 
 
-def generate_from_import(
-    module: str, name: str, /, *, asname: str | None = None
-) -> ImportFrom:
-    """Generate an `ImportFrom` object."""
-    alias = ImportAlias(
-        name=Name(name), asname=AsName(Name(asname)) if asname else None
-    )
-    return ImportFrom(module=split_dotted_str(module), names=[alias])
-
-
 def generate_f_string(var: str, suffix: str, /) -> FormattedString:
     """Generate an f-string."""
     return FormattedString([
@@ -49,6 +39,16 @@ def generate_import(module: str, /, *, asname: str | None = None) -> Import:
     return Import(names=[alias])
 
 
+def generate_import_from(
+    module: str, name: str, /, *, asname: str | None = None
+) -> ImportFrom:
+    """Generate an `ImportFrom` object."""
+    alias = ImportAlias(
+        name=Name(name), asname=AsName(Name(asname)) if asname else None
+    )
+    return ImportFrom(module=split_dotted_str(module), names=[alias])
+
+
 ##
 
 
@@ -170,8 +170,8 @@ def render_module(source: str | Module, /) -> str:
 __all__ = [
     "ParseImportError",
     "generate_f_string",
-    "generate_from_import",
     "generate_import",
+    "generate_import_from",
     "join_dotted_str",
     "parse_import",
     "render_module",

dycw_utilities-0.136.3/src/tests/test_arq.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-from asyncio import sleep
-from typing import TYPE_CHECKING, Any, cast
-
-from arq.connections import ArqRedis
-from hypothesis import given
-from hypothesis.strategies import integers
-
-from tests.conftest import SKIPIF_CI_AND_NOT_LINUX
-from utilities.arq import Worker, cron_raw, job_enqueuer
-from utilities.iterables import one
-
-if TYPE_CHECKING:
-    from collections.abc import Callable, Sequence
-
-    from arq.typing import WorkerCoroutine
-
-    from utilities.types import Coro
-
-
-class TestCronRaw:
-    @given(x=integers(), y=integers())
-    async def test_main(self, *, x: int, y: int) -> None:
-        async def func(x: int, y: int, /) -> int:
-            await sleep(0.01)
-            return x + y
-
-        job = cron_raw(func, args=(x, y))
-        result = await job.coroutine({})
-        assert result == (x + y)
-
-
-class TestJobEnqueuer:
-    @given(x=integers(), y=integers())
-    @SKIPIF_CI_AND_NOT_LINUX
-    async def test_main(self, *, x: int, y: int) -> None:
-        async def func(x: int, y: int, /) -> int:
-            await sleep(0.01)
-            return x + y
-
-        redis = ArqRedis(db=15)
-        _ = await job_enqueuer.settings(queue_name="test")(redis, func, x, y)
-
-
-class TestWorker:
-    @given(x=integers(), y=integers())
-    async def test_main(self, *, x: int, y: int) -> None:
-        async def func(x: int, y: int, /) -> int:
-            await sleep(0.01)
-            return x + y
-
-        class Example(Worker):
-            functions_raw: Sequence[Callable[..., Coro[Any]]] = [func]
-
-        func_use = cast("WorkerCoroutine", one(Example.functions))
-        result = await func_use({}, x, y)
-        assert result == (x + y)

dycw_utilities-0.136.3/src/utilities/arq.py

@@ -1,216 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from functools import wraps
-from itertools import chain
-from typing import TYPE_CHECKING, Any, Self, cast, override
-
-from arq.constants import default_queue_name, expires_extra_ms
-from arq.cron import cron
-
-from utilities.dataclasses import replace_non_sentinel
-from utilities.sentinel import Sentinel, sentinel
-
-if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Sequence
-    from datetime import datetime, timedelta, timezone
-
-    from arq.connections import ArqRedis, RedisSettings
-    from arq.cron import CronJob
-    from arq.jobs import Deserializer, Job, Serializer
-    from arq.typing import (
-        OptionType,
-        SecondsTimedelta,
-        StartupShutdown,
-        WeekdayOptionType,
-        WorkerCoroutine,
-    )
-    from arq.worker import Function
-
-    from utilities.types import Coro, StrMapping
-
-
-def cron_raw(
-    coroutine: Callable[..., Coro[Any]],
-    /,
-    *,
-    name: str | None = None,
-    month: OptionType = None,
-    day: OptionType = None,
-    weekday: WeekdayOptionType = None,
-    hour: OptionType = None,
-    minute: OptionType = None,
-    second: OptionType = 0,
-    microsecond: int = 123_456,
-    run_at_startup: bool = False,
-    unique: bool = True,
-    job_id: str | None = None,
-    timeout: SecondsTimedelta | None = None,
-    keep_result: float | None = 0,
-    keep_result_forever: bool | None = False,
-    max_tries: int | None = 1,
-    args: Iterable[Any] | None = None,
-    kwargs: StrMapping | None = None,
-) -> CronJob:
-    """Create a cron job with a raw coroutine function."""
-    lifted = _lift_cron(
-        coroutine, *(() if args is None else args), **({} if kwargs is None else kwargs)
-    )
-    return cron(
-        lifted,
-        name=name,
-        month=month,
-        day=day,
-        weekday=weekday,
-        hour=hour,
-        minute=minute,
-        second=second,
-        microsecond=microsecond,
-        run_at_startup=run_at_startup,
-        unique=unique,
-        job_id=job_id,
-        timeout=timeout,
-        keep_result=keep_result,
-        keep_result_forever=keep_result_forever,
-        max_tries=max_tries,
-    )
-
-
-def _lift_cron[**P, T](
-    func: Callable[P, Coro[T]], *args: P.args, **kwargs: P.kwargs
-) -> WorkerCoroutine:
-    """Lift a coroutine function & call arg/kwargs for `cron`."""
-
-    @wraps(func)
-    async def wrapped(ctx: StrMapping, /) -> T:
-        _ = ctx
-        return await func(*args, **kwargs)
-
-    return cast("Any", wrapped)
-
-
-##
-
-
-@dataclass(kw_only=True, slots=True)
-class _JobEnqueuer:
-    """Enqueuer of jobs."""
-
-    job_id: str | None = None
-    queue_name: str | None = None
-    defer_until: datetime | None = None
-    defer_by: int | float | timedelta | None = None
-    expires: int | float | timedelta | None = None
-    job_try: int | None = None
-
-    async def __call__[**P, T](
-        self,
-        redis: ArqRedis,
-        function: Callable[P, Coro[T]],
-        *args: P.args,
-        **kwargs: P.kwargs,
-    ) -> Job | None:
-        return await redis.enqueue_job(  # skipif-ci-and-not-linux
-            function.__name__,
-            *args,
-            _job_id=self.job_id,
-            _queue_name=self.queue_name,
-            _defer_until=self.defer_until,
-            _defer_by=self.defer_by,
-            _expires=self.expires,
-            _job_try=self.job_try,
-            **kwargs,
-        )
-
-    def settings(
-        self,
-        *,
-        job_id: str | None | Sentinel = sentinel,
-        queue_name: str | None | Sentinel = sentinel,
-        defer_until: datetime | None | Sentinel = sentinel,
-        defer_by: float | timedelta | None | Sentinel = sentinel,
-        expires: float | timedelta | None | Sentinel = sentinel,
-        job_try: int | None | Sentinel = sentinel,
-    ) -> Self:
-        """Replace elements of the enqueuer."""
-        return replace_non_sentinel(  # skipif-ci-and-not-linux
-            self,
-            job_id=job_id,
-            queue_name=queue_name,
-            defer_until=defer_until,
-            defer_by=defer_by,
-            expires=expires,
-            job_try=job_try,
-        )
-
-
-job_enqueuer = _JobEnqueuer()
-
-
-##
-
-
-class _WorkerMeta(type):
-    @override
-    def __new__(
-        mcs: type[_WorkerMeta],
-        name: str,
-        bases: tuple[type, ...],
-        namespace: dict[str, Any],
-        /,
-    ) -> type[Worker]:
-        cls = cast("type[Worker]", super().__new__(mcs, name, bases, namespace))
-        cls.functions = tuple(chain(cls.functions, map(cls._lift, cls.functions_raw)))
-        return cls
-
-    @classmethod
-    def _lift[**P, T](cls, func: Callable[P, Coro[T]]) -> WorkerCoroutine:
-        """Lift a coroutine function to accept the required `ctx` argument."""
-
-        @wraps(func)
-        async def wrapped(ctx: StrMapping, *args: P.args, **kwargs: P.kwargs) -> T:
-            _ = ctx
-            return await func(*args, **kwargs)
-
-        return cast("Any", wrapped)
-
-
-@dataclass(kw_only=True)
-class Worker(metaclass=_WorkerMeta):
-    """Base class for all workers."""
-
-    functions: Sequence[Function | WorkerCoroutine] = ()
-    functions_raw: Sequence[Callable[..., Coro[Any]]] = ()
-    queue_name: str | None = default_queue_name
-    cron_jobs: Sequence[CronJob] | None = None
-    redis_settings: RedisSettings | None = None
-    redis_pool: ArqRedis | None = None
-    burst: bool = False
-    on_startup: StartupShutdown | None = None
-    on_shutdown: StartupShutdown | None = None
-    on_job_start: StartupShutdown | None = None
-    on_job_end: StartupShutdown | None = None
-    after_job_end: StartupShutdown | None = None
-    handle_signals: bool = True
-    job_completion_wait: int = 0
-    max_jobs: int = 10
-    job_timeout: SecondsTimedelta = 300
-    keep_result: SecondsTimedelta = 3600
-    keep_result_forever: bool = False
-    poll_delay: SecondsTimedelta = 0.5
-    queue_read_limit: int | None = None
-    max_tries: int = 5
-    health_check_interval: SecondsTimedelta = 3600
-    health_check_key: str | None = None
-    ctx: dict[Any, Any] | None = None
-    retry_jobs: bool = True
-    allow_abort_jobs: bool = False
-    max_burst_jobs: int = -1
-    job_serializer: Serializer | None = None
-    job_deserializer: Deserializer | None = None
-    expires_extra_ms: int = expires_extra_ms
-    timezone: timezone | None = None
-    log_results: bool = True
-
-
-__all__ = ["Worker", "cron", "job_enqueuer"]