dycw-utilities 0.136.2__tar.gz → 0.136.4__tar.gz

{dycw_utilities-0.136.2 → dycw_utilities-0.136.4}/PKG-INFO

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

{dycw_utilities-0.136.2 → dycw_utilities-0.136.4}/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"]
@@ -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.2"
+version = "0.136.4"
 
 [project.optional-dependencies]
 logging = [
@@ -134,7 +133,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.136.2"
+current_version = "0.136.4"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.136.2 → dycw_utilities-0.136.4}/src/tests/test_asyncio.py

@@ -175,29 +175,6 @@ class TestEnhancedTaskGroup:
             await sleep_td(self.delta)
         assert looper._core_attempts >= 1
 
-    async def test_debug_true(self) -> None:
-        class CustomError(Exception): ...
-
-        async def func() -> None:
-            await sleep_td(self.delta)
-            raise CustomError
-
-        with raises(CustomError):
-            async with EnhancedTaskGroup(debug=True) as tg:
-                _ = await tg.run_or_create_task(func())
-
-    async def test_debug_false(self) -> None:
-        class CustomError(Exception): ...
-
-        async def func() -> None:
-            await sleep_td(self.delta)
-            raise CustomError
-
-        with raises(ExceptionGroup) as exc_info:
-            async with EnhancedTaskGroup(debug=False) as tg:
-                _ = await tg.run_or_create_task(func())
-        assert isinstance(one(exc_info.value.exceptions), CustomError)
-
     async def test_max_tasks_disabled(self) -> None:
         with Timer() as timer:
             async with EnhancedTaskGroup() as tg:
@@ -210,7 +187,39 @@ class TestEnhancedTaskGroup:
             async with EnhancedTaskGroup(max_tasks=2) as tg:
                 for _ in range(10):
                     _ = tg.create_task(sleep_td(self.delta))
-        assert timer >= self.delta
+        assert timer >= 5 * self.delta
+
+    async def test_run_or_create_task_parallel_with_max_tasks_none(self) -> None:
+        with Timer() as timer:
+            async with EnhancedTaskGroup() as tg:
+                assert not tg._is_debug()
+                for _ in range(10):
+                    _ = await tg.run_or_create_task(sleep_td(self.delta))
+        assert timer <= 2 * self.delta
+
+    async def test_run_or_create_task_parallel_with_max_tasks_two(self) -> None:
+        with Timer() as timer:
+            async with EnhancedTaskGroup(max_tasks=2) as tg:
+                assert not tg._is_debug()
+                for _ in range(10):
+                    _ = await tg.run_or_create_task(sleep_td(self.delta))
+        assert timer >= 5 * self.delta
+
+    async def test_run_or_create_task_serial_with_max_tasks_negative(self) -> None:
+        with Timer() as timer:
+            async with EnhancedTaskGroup(max_tasks=-1) as tg:
+                assert tg._is_debug()
+                for _ in range(10):
+                    _ = await tg.run_or_create_task(sleep_td(self.delta))
+        assert timer >= 10 * self.delta
+
+    async def test_run_or_create_task_serial_with_debug(self) -> None:
+        with Timer() as timer:
+            async with EnhancedTaskGroup(debug=True) as tg:
+                assert tg._is_debug()
+                for _ in range(10):
+                    _ = await tg.run_or_create_task(sleep_td(self.delta))
+        assert timer >= 10 * self.delta
 
     async def test_timeout_pass(self) -> None:
         async with EnhancedTaskGroup(timeout=2 * self.delta) as tg:

{dycw_utilities-0.136.2 → dycw_utilities-0.136.4}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.136.2"
+__version__ = "0.136.4"

{dycw_utilities-0.136.2 → dycw_utilities-0.136.4}/src/utilities/asyncio.py

@@ -220,6 +220,7 @@ class EnhancedQueue[T](Queue[T]):
 class EnhancedTaskGroup(TaskGroup):
     """Task group with enhanced features."""
 
+    _max_tasks: int | None
     _semaphore: Semaphore | None
     _timeout: TimeDelta | None
     _error: MaybeType[BaseException]
@@ -237,7 +238,11 @@ class EnhancedTaskGroup(TaskGroup):
         debug: MaybeCallableBool = False,
     ) -> None:
         super().__init__()
-        self._semaphore = None if max_tasks is None else Semaphore(max_tasks)
+        self._max_tasks = max_tasks
+        if (max_tasks is None) or (max_tasks <= 0):
+            self._semaphore = None
+        else:
+            self._semaphore = Semaphore(max_tasks)
         self._timeout = timeout
         self._error = error
         self._debug = debug
@@ -257,7 +262,7 @@ class EnhancedTaskGroup(TaskGroup):
         tb: TracebackType | None,
     ) -> None:
         _ = await self._stack.__aexit__(et, exc, tb)
-        match to_bool(bool_=self._debug):
+        match self._is_debug():
             case True:
                 with suppress(Exception):
                     _ = await super().__aexit__(et, exc, tb)
@@ -293,7 +298,7 @@ class EnhancedTaskGroup(TaskGroup):
         name: str | None = None,
         context: Context | None = None,
     ) -> T | Task[T]:
-        match to_bool(bool_=self._debug):
+        match self._is_debug():
             case True:
                 return await coro
             case False:
@@ -301,6 +306,11 @@ class EnhancedTaskGroup(TaskGroup):
             case _ as never:
                 assert_never(never)
 
+    def _is_debug(self) -> bool:
+        return to_bool(bool_=self._debug) or (
+            (self._max_tasks is not None) and (self._max_tasks <= 0)
+        )
+
     async def _wrap_with_semaphore[T](
         self, semaphore: Semaphore, coroutine: _CoroutineLike[T], /
     ) -> T:

dycw_utilities-0.136.2/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.2/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"]