dycw-utilities 0.128.0__py3-none-any.whl → 0.129.1__py3-none-any.whl

{dycw_utilities-0.128.0.dist-info → dycw_utilities-0.129.1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: dycw-utilities
-Version: 0.128.0
+Version: 0.129.1
 Author-email: Derek Wan <d.wan@icloud.com>
 License-File: LICENSE
 Requires-Python: >=3.12
-Requires-Dist: typing-extensions<4.14,>=4.13.1
+Requires-Dist: typing-extensions<4.15,>=4.14.0
 Provides-Extra: test
 Requires-Dist: dycw-pytest-only<2.2,>=2.1.1; extra == 'test'
-Requires-Dist: hypothesis<6.134,>=6.133.0; extra == 'test'
+Requires-Dist: hypothesis<6.136,>=6.135.0; extra == 'test'
 Requires-Dist: pytest-asyncio<1.1,>=1.0.0; extra == 'test'
 Requires-Dist: pytest-cov<6.2,>=6.1.1; extra == 'test'
 Requires-Dist: pytest-instafail<0.6,>=0.5.0; extra == 'test'
@@ -77,7 +77,7 @@ Provides-Extra: zzz-test-hypothesis
 Requires-Dist: aiosqlite<0.22,>=0.21.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: asyncpg<0.31,>=0.30.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: greenlet<3.3,>=3.2.0; extra == 'zzz-test-hypothesis'
-Requires-Dist: hypothesis<6.134,>=6.133.0; extra == 'zzz-test-hypothesis'
+Requires-Dist: hypothesis<6.136,>=6.135.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: luigi<3.7,>=3.6.0; extra == 'zzz-test-hypothesis'
 Requires-Dist: numpy<2.3,>=2.2.6; extra == 'zzz-test-hypothesis'
 Requires-Dist: pathvalidate<3.3,>=3.2.3; extra == 'zzz-test-hypothesis'

{dycw_utilities-0.128.0.dist-info → dycw_utilities-0.129.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
-utilities/__init__.py,sha256=eWwSSpaFIxxRG_Er2j_6n618a-HRkBuT-C-hli9i1bM,60
+utilities/__init__.py,sha256=SD3J-kHQFgs1qNwFwV6LhMTAXj4jsrYuL05YluwVtcE,60
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
-utilities/asyncio.py,sha256=wKxwNnxdWxsiy5U0b1F3UgpWRHlPKM0y_OcmURzqxR8,51396
+utilities/asyncio.py,sha256=OIQ4JddpQw8tSubzwDR0WyqQ-uE-L5DdbwuTqRQK5MQ,38202
 utilities/atomicwrites.py,sha256=geFjn9Pwn-tTrtoGjDDxWli9NqbYfy3gGL6ZBctiqSo,5393
 utilities/atools.py,sha256=IYMuFSFGSKyuQmqD6v5IUtDlz8PPw0Sr87Cub_gRU3M,1168
 utilities/cachetools.py,sha256=C1zqOg7BYz0IfQFK8e3qaDDgEZxDpo47F15RTfJM37Q,2910
@@ -15,7 +15,7 @@ utilities/datetime.py,sha256=aiPh2OZK2g9gn4yEeSO0lODOmvx8U_rGn6XeSzyk4VY,38738
 utilities/enum.py,sha256=HoRwVCWzsnH0vpO9ZEcAAIZLMv0Sn2vJxxA4sYMQgDs,5793
 utilities/errors.py,sha256=nC7ZYtxxDBMfrTHtT_MByBfup_wfGQFRo3eDt-0ZPe8,1045
 utilities/eventkit.py,sha256=6M5Xu1SzN-juk9PqBHwy5dS-ta7T0qA6SMpDsakOJ0E,13039
-utilities/fastapi.py,sha256=LG1-Q8RDi7wsyVN6v74qptPYX8WGXPkFOQFniMvtzjc,2439
+utilities/fastapi.py,sha256=gZrXYxKAc7ZEAL_tDmkcbqebkm-KfMCY0X8r-1HF5dI,2962
 utilities/fpdf2.py,sha256=y1NGXR5chWqLXWpewGV3hlRGMr_5yV1lVRkPBhPEgJI,1843
 utilities/functions.py,sha256=jgt592voaHNtX56qX0SRvFveVCRmSIxCZmqvpLZCnY8,27305
 utilities/functools.py,sha256=WrpHt7NLNWSUn9A1Q_ZIWlNaYZOEI4IFKyBG9HO3BC4,1643
@@ -60,14 +60,14 @@ utilities/pytest_regressions.py,sha256=YI55B7EtLjhz7zPJZ6NK9bWrxrKCKabWZJe1cwcbA
 utilities/python_dotenv.py,sha256=edXsvHZhZnYeqfMfrsRRpj7_9eJI6uizh3xLx8Q9B3w,3228
 utilities/random.py,sha256=lYdjgxB7GCfU_fwFVl5U-BIM_HV3q6_urL9byjrwDM8,4157
 utilities/re.py,sha256=5J4d8VwIPFVrX2Eb8zfoxImDv7IwiN_U7mJ07wR2Wvs,3958
-utilities/redis.py,sha256=EZgqWeoGpvN-BfCQL93F3rYlfB4U_zhzHCBuZpDmKpo,37157
+utilities/redis.py,sha256=7Sc-G43VXVzFQU7MHKyI1y3u7My3oT1UoWXPGcKM_-0,36008
 utilities/reprlib.py,sha256=ssYTcBW-TeRh3fhCJv57sopTZHF5FrPyyUg9yp5XBlo,3953
 utilities/scipy.py,sha256=X6ROnHwiUhAmPhM0jkfEh0-Fd9iRvwiqtCQMOLmOQF8,945
 utilities/sentinel.py,sha256=3jIwgpMekWgDAxPDA_hXMP2St43cPhciKN3LWiZ7kv0,1248
 utilities/shelve.py,sha256=HZsMwK4tcIfg3sh0gApx4-yjQnrY4o3V3ZRimvRhoW0,738
-utilities/slack_sdk.py,sha256=jqQyiYSKseZNdg2lCkvPzrAows9p7kVDDjvEnatioKo,5702
+utilities/slack_sdk.py,sha256=ltmzv68aa73CJGqTDvt8L9vDm22YU9iOCo3NCiNd3vA,4347
 utilities/socket.py,sha256=K77vfREvzoVTrpYKo6MZakol0EYu2q1sWJnnZqL0So0,118
-utilities/sqlalchemy.py,sha256=XTZmNKXD9SUbZ7V1xNNxok-0Ej0Cf4ya5pjuIeH-kdg,39388
+utilities/sqlalchemy.py,sha256=I81qR7JtS-q1sLnw42p7L0FC0imT98gJHGte_KOjpAA,37890
 utilities/sqlalchemy_polars.py,sha256=s7hQNep2O5DTgIRXyN_JRQma7a4DAtNd25tshaZW8iw,15490
 utilities/statsmodels.py,sha256=koyiBHvpMcSiBfh99wFUfSggLNx7cuAw3rwyfAhoKpQ,3410
 utilities/streamlit.py,sha256=U9PJBaKP1IdSykKhPZhIzSPTZsmLsnwbEPZWzNhJPKk,2955
@@ -89,7 +89,7 @@ utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
 utilities/whenever.py,sha256=jS31ZAY5OMxFxLja_Yo5Fidi87Pd-GoVZ7Vi_teqVDA,16743
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=-5j7IQ9nb7gR43rdgA7ms05im-XuqhAk9EJnQBXxCoQ,1874
-dycw_utilities-0.128.0.dist-info/METADATA,sha256=BUxspfSeFNdeLBrh89gZYdXyqBuAr4yzLZ_ylcVOBlI,12803
-dycw_utilities-0.128.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.128.0.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.128.0.dist-info/RECORD,,
+dycw_utilities-0.129.1.dist-info/METADATA,sha256=5y1_o16EDF5UAXj97fupC2XxHo_SqHwLxYDo22_4xe0,12803
+dycw_utilities-0.129.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.129.1.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.129.1.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.128.0"
+__version__ = "0.129.1"

utilities/asyncio.py

@@ -1,9 +1,6 @@
 from __future__ import annotations
 
-import datetime as dt
-from abc import ABC, abstractmethod
 from asyncio import (
-    CancelledError,
     Event,
     Lock,
     PriorityQueue,
@@ -19,7 +16,7 @@ from asyncio import (
     sleep,
     timeout,
 )
-from collections.abc import Callable, Hashable, Iterable, Iterator, Mapping
+from collections.abc import Callable, Iterable, Iterator
 from contextlib import (
     AbstractAsyncContextManager,
     AsyncExitStack,
@@ -37,7 +34,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
-    NoReturn,
     Self,
     TextIO,
     TypeVar,
@@ -50,27 +46,19 @@ from typing_extensions import deprecated
 
 from utilities.dataclasses import replace_non_sentinel
 from utilities.datetime import (
-    MINUTE,
     SECOND,
     datetime_duration_to_float,
-    datetime_duration_to_timedelta,
     get_now,
     round_datetime,
 )
-from utilities.errors import ImpossibleCaseError, repr_error
-from utilities.functions import ensure_int, ensure_not_none, get_class_name
+from utilities.errors import repr_error
+from utilities.functions import ensure_int, ensure_not_none
 from utilities.random import SYSTEM_RANDOM
 from utilities.sentinel import Sentinel, sentinel
-from utilities.types import (
-    Coroutine1,
-    DurationOrEveryDuration,
-    MaybeCallableEvent,
-    MaybeType,
-    THashable,
-    TSupportsRichComparison,
-)
+from utilities.types import MaybeCallableEvent, THashable, TSupportsRichComparison
 
 if TYPE_CHECKING:
+    import datetime as dt
     from asyncio import _CoroutineLike
     from asyncio.subprocess import Process
     from collections import deque
@@ -319,346 +307,6 @@ class EnhancedTaskGroup(TaskGroup):
 ##
 
 
-@dataclass(kw_only=True, unsafe_hash=True)
-class InfiniteLooper(ABC, Generic[THashable]):
-    """An infinite loop which can throw exceptions by setting events."""
-
-    sleep_core: DurationOrEveryDuration = field(default=SECOND, repr=False)
-    sleep_restart: DurationOrEveryDuration = field(default=MINUTE, repr=False)
-    duration: Duration | None = field(default=None, repr=False)
-    logger: str | None = field(default=None, repr=False)
-    _await_upon_aenter: bool = field(default=True, init=False, repr=False)
-    _depth: int = field(default=0, init=False, repr=False)
-    _events: Mapping[THashable | None, Event] = field(
-        default_factory=dict, init=False, repr=False, hash=False
-    )
-    _stack: AsyncExitStack = field(
-        default_factory=AsyncExitStack, init=False, repr=False
-    )
-    _task: Task[None] | None = field(default=None, init=False, repr=False)
-
-    def __post_init__(self) -> None:
-        self._events = {
-            event: Event() for event, _ in self._yield_events_and_exceptions()
-        }
-
-    async def __aenter__(self) -> Self:
-        """Context manager entry."""
-        if self._depth == 0:
-            self._task = create_task(self._run_looper())
-            if self._await_upon_aenter:
-                with suppress(CancelledError):
-                    await self._task
-            _ = await self._stack.__aenter__()
-        self._depth += 1
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None = None,
-        exc_value: BaseException | None = None,
-        traceback: TracebackType | None = None,
-    ) -> None:
-        """Context manager exit."""
-        _ = (exc_type, exc_value, traceback)
-        self._depth = max(self._depth - 1, 0)
-        if (self._depth == 0) and (self._task is not None):
-            with suppress(CancelledError):
-                await self._task
-            self._task = None
-            try:
-                await self._teardown()
-            except Exception as error:  # noqa: BLE001
-                self._error_upon_teardown(error)
-            _ = await self._stack.__aexit__(exc_type, exc_value, traceback)
-
-    async def stop(self) -> None:
-        """Stop the service."""
-        if self._task is None:
-            raise ImpossibleCaseError(case=[f"{self._task=}"])  # pragma: no cover
-        with suppress(CancelledError):
-            _ = self._task.cancel()
-
-    async def _run_looper(self) -> None:
-        """Run the looper."""
-        match self.duration:
-            case None:
-                await self._run_looper_without_timeout()
-            case int() | float() | dt.timedelta() as duration:
-                try:
-                    async with timeout_dur(duration=duration):
-                        return await self._run_looper_without_timeout()
-                except TimeoutError:
-                    await self.stop()
-            case _ as never:
-                assert_never(never)
-        return None
-
-    async def _run_looper_without_timeout(self) -> None:
-        """Run the looper without a timeout."""
-        coroutines = list(self._yield_coroutines())
-        loopers = list(self._yield_loopers())
-        if (len(coroutines) == 0) and (len(loopers) == 0):
-            return await self._run_looper_by_itself()
-        return await self._run_looper_with_others(coroutines, loopers)
-
-    async def _run_looper_by_itself(self) -> None:
-        """Run the looper by itself."""
-        whitelisted = tuple(self._yield_whitelisted_errors())
-        blacklisted = tuple(self._yield_blacklisted_errors())
-        while True:
-            try:
-                self._reset_events()
-                try:
-                    await self._initialize()
-                except Exception as error:  # noqa: BLE001
-                    self._error_upon_initialize(error)
-                    await self._run_sleep(self.sleep_restart)
-                else:
-                    while True:
-                        try:
-                            event = next(
-                                key
-                                for (key, value) in self._events.items()
-                                if value.is_set()
-                            )
-                        except StopIteration:
-                            await self._core()
-                            await self._run_sleep(self.sleep_core)
-                        else:
-                            self._raise_error(event)
-            except InfiniteLooperError:
-                raise
-            except BaseException as error1:
-                match error1:
-                    case Exception():
-                        if isinstance(error1, blacklisted):
-                            raise
-                    case BaseException():
-                        if not isinstance(error1, whitelisted):
-                            raise
-                    case _ as never:
-                        assert_never(never)
-                self._error_upon_core(error1)
-                try:
-                    await self._teardown()
-                except BaseException as error2:  # noqa: BLE001
-                    self._error_upon_teardown(error2)
-                finally:
-                    await self._run_sleep(self.sleep_restart)
-
-    async def _run_looper_with_others(
-        self,
-        coroutines: Iterable[Callable[[], Coroutine1[None]]],
-        loopers: Iterable[InfiniteLooper[Any]],
-        /,
-    ) -> None:
-        """Run multiple loopers."""
-        while True:
-            self._reset_events()
-            try:
-                async with TaskGroup() as tg, AsyncExitStack() as stack:
-                    _ = tg.create_task(self._run_looper_by_itself())
-                    _ = [tg.create_task(c()) for c in coroutines]
-                    _ = [
-                        tg.create_task(stack.enter_async_context(lo)) for lo in loopers
-                    ]
-            except ExceptionGroup as error:
-                self._error_group_upon_others(error)
-                await self._run_sleep(self.sleep_restart)
-
-    async def _initialize(self) -> None:
-        """Initialize the loop."""
-
-    async def _core(self) -> None:
-        """Run the core part of the loop."""
-
-    async def _teardown(self) -> None:
-        """Tear down the loop."""
-
-    def _error_upon_initialize(self, error: Exception, /) -> None:
-        """Handle any errors upon initializing the looper."""
-        if self.logger is not None:
-            getLogger(name=self.logger).error(
-                "%r encountered %r whilst initializing; sleeping %s...",
-                get_class_name(self),
-                repr_error(error),
-                self._sleep_restart_desc,
-            )
-
-    def _error_upon_core(self, error: BaseException, /) -> None:
-        """Handle any errors upon running the core function."""
-        if self.logger is not None:
-            getLogger(name=self.logger).error(
-                "%r encountered %r; sleeping %s...",
-                get_class_name(self),
-                repr_error(error),
-                self._sleep_restart_desc,
-            )
-
-    def _error_upon_teardown(self, error: BaseException, /) -> None:
-        """Handle any errors upon tearing down the looper."""
-        if self.logger is not None:
-            getLogger(name=self.logger).error(
-                "%r encountered %r whilst tearing down; sleeping %s...",
-                get_class_name(self),
-                repr_error(error),
-                self._sleep_restart_desc,
-            )
-
-    def _error_group_upon_others(self, group: ExceptionGroup, /) -> None:
-        """Handle any errors upon running the core function."""
-        if self.logger is not None:
-            errors = group.exceptions
-            n = len(errors)
-            msgs = [f"{get_class_name(self)!r} encountered {n} error(s):"]
-            msgs.extend(
-                f"- Error #{i}/{n}: {repr_error(e)}"
-                for i, e in enumerate(errors, start=1)
-            )
-            msgs.append(f"Sleeping {self._sleep_restart_desc}...")
-            getLogger(name=self.logger).error("\n".join(msgs))
-
-    def _raise_error(self, event: THashable | None, /) -> NoReturn:
-        """Raise the error corresponding to given event."""
-        mapping = dict(self._yield_events_and_exceptions())
-        error = mapping.get(event, InfiniteLooperError)
-        raise error
-
-    def _reset_events(self) -> None:
-        """Reset the events."""
-        self._events = {
-            event: Event() for event, _ in self._yield_events_and_exceptions()
-        }
-
-    async def _run_sleep(self, sleep: DurationOrEveryDuration, /) -> None:
-        """Sleep until the next part of the loop."""
-        match sleep:
-            case int() | float() | dt.timedelta() as duration:
-                await sleep_dur(duration=duration)
-            case "every", (int() | float() | dt.timedelta()) as duration:
-                await sleep_until_rounded(duration)
-            case _ as never:
-                assert_never(never)
-
-    @property
-    def _sleep_restart_desc(self) -> str:
-        """Get a description of the sleep until restart."""
-        match self.sleep_restart:
-            case int() | float() | dt.timedelta() as duration:
-                timedelta = datetime_duration_to_timedelta(duration)
-                return f"for {timedelta}"
-            case "every", (int() | float() | dt.timedelta()) as duration:
-                timedelta = datetime_duration_to_timedelta(duration)
-                return f"until next {timedelta}"
-            case _ as never:
-                assert_never(never)
-
-    def _set_event(self, *, event: THashable | None = None) -> None:
-        """Set the given event."""
-        try:
-            event_obj = self._events[event]
-        except KeyError:
-            raise _InfiniteLooperNoSuchEventError(looper=self, event=event) from None
-        event_obj.set()
-
-    def _yield_events_and_exceptions(
-        self,
-    ) -> Iterator[tuple[THashable | None, MaybeType[Exception]]]:
-        """Yield the events & exceptions."""
-        yield (None, _InfiniteLooperDefaultEventError(looper=self))
-
-    def _yield_coroutines(self) -> Iterator[Callable[[], Coroutine1[None]]]:
-        """Yield any other coroutines which must also be run."""
-        yield from []
-
-    def _yield_loopers(self) -> Iterator[InfiniteLooper[Any]]:
-        """Yield any other loopers which must also be run."""
-        yield from []
-
-    def _yield_blacklisted_errors(self) -> Iterator[type[Exception]]:
-        """Yield any exceptions which the looper ought to catch terminate upon."""
-        yield from []
-
-    def _yield_whitelisted_errors(self) -> Iterator[type[BaseException]]:
-        """Yield any exceptions which the looper ought to catch and allow running."""
-        yield from []
-
-
-@dataclass(kw_only=True, slots=True)
-class InfiniteLooperError(Exception):
-    looper: InfiniteLooper[Any]
-
-
-@dataclass(kw_only=True, slots=True)
-class _InfiniteLooperNoSuchEventError(InfiniteLooperError):
-    event: Hashable
-
-    @override
-    def __str__(self) -> str:
-        return f"{get_class_name(self.looper)!r} does not have an event {self.event!r}"
-
-
-@dataclass(kw_only=True, slots=True)
-class _InfiniteLooperDefaultEventError(InfiniteLooperError):
-    @override
-    def __str__(self) -> str:
-        return f"{get_class_name(self.looper)!r} default event error"
-
-
-##
-
-
-@dataclass(kw_only=True)
-class InfiniteQueueLooper(InfiniteLooper[THashable], Generic[THashable, _T]):
-    """An infinite loop which processes a queue."""
-
-    _await_upon_aenter: bool = field(default=False, init=False, repr=False)
-    _queue: EnhancedQueue[_T] = field(
-        default_factory=EnhancedQueue, init=False, repr=False
-    )
-
-    def __len__(self) -> int:
-        return self._queue.qsize()
-
-    @override
-    async def _core(self) -> None:
-        """Run the core part of the loop."""
-        if self.empty():
-            return
-        await self._process_queue()
-
-    @abstractmethod
-    async def _process_queue(self) -> None:
-        """Process the queue."""
-
-    def empty(self) -> bool:
-        """Check if the queue is empty."""
-        return self._queue.empty()
-
-    def put_left_nowait(self, *items: _T) -> None:
-        """Put items into the queue at the start without blocking."""
-        self._queue.put_left_nowait(*items)  # pragma: no cover
-
-    def put_right_nowait(self, *items: _T) -> None:
-        """Put items into the queue at the end without blocking."""
-        self._queue.put_right_nowait(*items)  # pragma: no cover
-
-    def qsize(self) -> int:
-        """Get the number of items in the queue."""
-        return self._queue.qsize()
-
-    async def run_until_empty(self, *, stop: bool = False) -> None:
-        """Run until the queue is empty."""
-        while not self.empty():
-            await self._process_queue()
-        if stop:
-            await self.stop()
-
-
-##
-
-
 @dataclass(kw_only=True, slots=True)
 class LooperError(Exception): ...
 
@@ -1415,9 +1063,6 @@ async def timeout_dur(
 __all__ = [
     "EnhancedQueue",
     "EnhancedTaskGroup",
-    "InfiniteLooper",
-    "InfiniteLooperError",
-    "InfiniteQueueLooper",
     "Looper",
     "LooperError",
     "StreamCommandOutput",

utilities/fastapi.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
+from asyncio import Task, create_task
 from dataclasses import InitVar, dataclass, field
-from typing import TYPE_CHECKING, Any, Literal, override
+from typing import TYPE_CHECKING, Any, Literal, Self, override
 
 from fastapi import FastAPI
 from uvicorn import Config, Server
 
-from utilities.asyncio import InfiniteLooper
+from utilities.asyncio import Looper
 from utilities.datetime import SECOND, datetime_duration_to_float
 
 if TYPE_CHECKING:
+    from types import TracebackType
+
     from utilities.types import Duration
 
 
@@ -36,7 +39,7 @@ class _PingerReceiverApp(FastAPI):
 
 
 @dataclass(kw_only=True)
-class PingReceiver(InfiniteLooper):
+class PingReceiver(Looper[None]):
     """A ping receiver."""
 
     host: InitVar[str] = _LOCALHOST
@@ -44,12 +47,31 @@ class PingReceiver(InfiniteLooper):
     _app: _PingerReceiverApp = field(
         default_factory=_PingerReceiverApp, init=False, repr=False
     )
-    _await_upon_aenter: bool = field(default=False, init=False, repr=False)
     _server: Server = field(init=False, repr=False)
+    _server_task: Task[None] | None = field(default=None, init=False, repr=False)
 
+    @override
     def __post_init__(self, host: str, port: int, /) -> None:
+        super().__post_init__()  # skipif-ci
         self._server = Server(Config(self._app, host=host, port=port))  # skipif-ci
 
+    @override
+    async def __aenter__(self) -> Self:
+        _ = await super().__aenter__()  # skipif-ci
+        async with self._lock:  # skipif-ci
+            self._server_task = create_task(self._server.serve())
+        return self  # skipif-ci
+
+    @override
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        await super().__aexit__(exc_type, exc_value, traceback)  # skipif-ci
+        await self._server.shutdown()  # skipif-ci
+
     @classmethod
     async def ping(
         cls, port: int, /, *, host: str = _LOCALHOST, timeout: Duration = _TIMEOUT
@@ -66,13 +88,5 @@ class PingReceiver(InfiniteLooper):
             return False
         return response.text if response.status_code == 200 else False  # skipif-ci
 
-    @override
-    async def _initialize(self) -> None:
-        await self._server.serve()  # skipif-ci
-
-    @override
-    async def _teardown(self) -> None:
-        await self._server.shutdown()  # skipif-ci
-
 
 __all__ = ["PingReceiver"]

utilities/redis.py

@@ -23,9 +23,8 @@ from typing import (
 )
 
 from redis.asyncio import Redis
-from redis.typing import EncodableT
 
-from utilities.asyncio import EnhancedQueue, InfiniteQueueLooper, Looper, timeout_dur
+from utilities.asyncio import EnhancedQueue, Looper, timeout_dur
 from utilities.contextlib import suppress_super_object_attribute_error
 from utilities.datetime import (
     MILLISECOND,
@@ -34,7 +33,7 @@ from utilities.datetime import (
     datetime_duration_to_timedelta,
 )
 from utilities.errors import ImpossibleCaseError
-from utilities.functions import ensure_int, get_class_name, identity
+from utilities.functions import ensure_int, identity
 from utilities.iterables import always_iterable, one
 from utilities.orjson import deserialize, serialize
 
@@ -51,10 +50,10 @@ if TYPE_CHECKING:
 
     from redis.asyncio import ConnectionPool
     from redis.asyncio.client import PubSub
-    from redis.typing import ResponseT
+    from redis.typing import EncodableT, ResponseT
 
     from utilities.iterables import MaybeIterable
-    from utilities.types import Duration, MaybeType, TypeLike
+    from utilities.types import Duration, TypeLike
 
 
 _K = TypeVar("_K")
@@ -620,42 +619,6 @@ class PublishError(Exception):
 ##
 
 
-@dataclass(kw_only=True)
-class Publisher(InfiniteQueueLooper[None, tuple[str, EncodableT]]):
-    """Publish a set of messages to Redis."""
-
-    redis: Redis
-    serializer: Callable[[Any], EncodableT] | None = None
-    timeout: Duration = _PUBLISH_TIMEOUT
-
-    @override
-    async def _process_queue(self) -> None:
-        for item in self._queue.get_all_nowait():  # skipif-ci-and-not-linux
-            channel, data = item
-            _ = await publish(
-                self.redis,
-                channel,
-                data,
-                serializer=self.serializer,
-                timeout=self.timeout,
-            )
-
-    @override
-    def _yield_events_and_exceptions(
-        self,
-    ) -> Iterator[tuple[None, MaybeType[Exception]]]:
-        yield (None, PublisherError)  # skipif-ci-and-not-linux
-
-
-@dataclass(kw_only=True)
-class PublisherError(Exception):
-    publisher: Publisher
-
-    @override
-    def __str__(self) -> str:
-        return f"Error running {get_class_name(self.publisher)!r}"  # skipif-ci-and-not-linux
-
-
 @dataclass(kw_only=True)
 class PublishService(Looper[tuple[str, _T]]):
     """Service to publish items to Redis."""
@@ -1095,8 +1058,6 @@ def _deserialize(
 __all__ = [
     "PublishService",
     "PublishServiceMixin",
-    "Publisher",
-    "PublisherError",
     "RedisHashMapKey",
     "RedisKey",
     "SubscribeService",

utilities/slack_sdk.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any, Self, override
 
 from slack_sdk.webhook.async_client import AsyncWebhookClient
 
-from utilities.asyncio import InfiniteQueueLooper, Looper, timeout_dur
+from utilities.asyncio import Looper, timeout_dur
 from utilities.datetime import MINUTE, SECOND, datetime_duration_to_float
 from utilities.functools import cache
 from utilities.math import safe_round
@@ -27,53 +27,10 @@ _TIMEOUT: Duration = MINUTE
 ##
 
 
-_SLEEP: Duration = SECOND
-
-
 async def _send_adapter(url: str, text: str, /) -> None:
     await send_to_slack(url, text)  # pragma: no cover
 
 
-@dataclass(init=False, unsafe_hash=True)
-class SlackHandler(Handler, InfiniteQueueLooper[None, str]):
-    """Handler for sending messages to Slack."""
-
-    @override
-    def __init__(
-        self,
-        url: str,
-        /,
-        *,
-        level: int = NOTSET,
-        sleep_core: Duration = _SLEEP,
-        sleep_restart: Duration = _SLEEP,
-        sender: Callable[[str, str], Coroutine1[None]] = _send_adapter,
-        timeout: Duration = _TIMEOUT,
-    ) -> None:
-        InfiniteQueueLooper.__init__(self)  # InfiniteQueueLooper first
-        InfiniteQueueLooper.__post_init__(self)
-        Handler.__init__(self, level=level)  # Handler next
-        self.url = url
-        self.sender = sender
-        self.timeout = timeout
-        self.sleep_core = sleep_core
-        self.sleep_restart = sleep_restart
-
-    @override
-    def emit(self, record: LogRecord) -> None:
-        try:
-            self.put_right_nowait(self.format(record))
-        except Exception:  # noqa: BLE001  # pragma: no cover
-            self.handleError(record)
-
-    @override
-    async def _process_queue(self) -> None:
-        messages = self._queue.get_all_nowait()
-        text = "\n".join(messages)
-        async with timeout_dur(duration=self.timeout):
-            await self.sender(self.url, text)
-
-
 @dataclass(init=False, unsafe_hash=True)
 class SlackHandlerService(Handler, Looper[str]):
     """Service to send messages to Slack."""
@@ -187,4 +144,4 @@ def _get_client(url: str, /, *, timeout: Duration = _TIMEOUT) -> AsyncWebhookCli
     return AsyncWebhookClient(url, timeout=timeout_use)
 
 
-__all__ = ["SendToSlackError", "SlackHandler", "SlackHandlerService", "send_to_slack"]
+__all__ = ["SendToSlackError", "SlackHandlerService", "send_to_slack"]

utilities/sqlalchemy.py

@@ -57,7 +57,7 @@ from sqlalchemy.orm import (
 from sqlalchemy.orm.exc import UnmappedClassError
 from sqlalchemy.pool import NullPool, Pool
 
-from utilities.asyncio import InfiniteQueueLooper, Looper, timeout_dur
+from utilities.asyncio import Looper, timeout_dur
 from utilities.contextlib import suppress_super_object_attribute_error
 from utilities.datetime import SECOND
 from utilities.functions import (
@@ -82,13 +82,7 @@ from utilities.iterables import (
 )
 from utilities.reprlib import get_repr
 from utilities.text import snake_case
-from utilities.types import (
-    Duration,
-    MaybeIterable,
-    MaybeType,
-    StrMapping,
-    TupleOrStrMapping,
-)
+from utilities.types import Duration, MaybeIterable, StrMapping, TupleOrStrMapping
 
 _T = TypeVar("_T")
 type _EngineOrConnectionOrAsync = Engine | Connection | AsyncEngine | AsyncConnection
@@ -610,52 +604,6 @@ class TablenameMixin:
 ##
 
 
-@dataclass(kw_only=True)
-class Upserter(InfiniteQueueLooper[None, _InsertItem]):
-    """Upsert a set of items to a database."""
-
-    engine: AsyncEngine
-    snake: bool = False
-    selected_or_all: _SelectedOrAll = "selected"
-    chunk_size_frac: float = CHUNK_SIZE_FRAC
-    assume_tables_exist: bool = False
-    timeout_create: Duration | None = None
-    error_create: type[Exception] = TimeoutError
-    timeout_insert: Duration | None = None
-    error_insert: type[Exception] = TimeoutError
-
-    @override
-    async def _process_queue(self) -> None:
-        items = self._queue.get_all_nowait()
-        await upsert_items(
-            self.engine,
-            *items,
-            snake=self.snake,
-            selected_or_all=self.selected_or_all,
-            chunk_size_frac=self.chunk_size_frac,
-            assume_tables_exist=self.assume_tables_exist,
-            timeout_create=self.timeout_create,
-            error_create=self.error_create,
-            timeout_insert=self.timeout_insert,
-            error_insert=self.error_insert,
-        )
-
-    @override
-    def _yield_events_and_exceptions(
-        self,
-    ) -> Iterator[tuple[None, MaybeType[Exception]]]:
-        yield (None, UpserterError)
-
-
-@dataclass(kw_only=True)
-class UpserterError(Exception):
-    upserter: Upserter
-
-    @override
-    def __str__(self) -> str:
-        return f"Error running {get_class_name(self.upserter)!r}"
-
-
 @dataclass(kw_only=True)
 class UpsertService(Looper[_InsertItem]):
     """Service to upsert items to a database."""
@@ -1202,8 +1150,6 @@ __all__ = [
     "UpsertItemsError",
     "UpsertService",
     "UpsertServiceMixin",
-    "Upserter",
-    "UpserterError",
     "check_engine",
     "columnwise_max",
     "columnwise_min",