dycw-utilities 0.117.0__py3-none-any.whl → 0.118.0__py3-none-any.whl

{dycw_utilities-0.117.0.dist-info → dycw_utilities-0.118.0.dist-info}/METADATA

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

{dycw_utilities-0.117.0.dist-info → dycw_utilities-0.118.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-utilities/__init__.py,sha256=P9EtLQQfrOCDM1TAOhodQ4gfhNisheGhmugAZrQJYYc,60
+utilities/__init__.py,sha256=m9DsK8iICHcyqc8Uf9izHc2F4wKsVwGwOOvxhVTp46A,60
 utilities/altair.py,sha256=Gpja-flOo-Db0PIPJLJsgzAlXWoKUjPU1qY-DQ829ek,9156
 utilities/astor.py,sha256=xuDUkjq0-b6fhtwjhbnebzbqQZAjMSHR1IIS5uOodVg,777
-utilities/asyncio.py,sha256=HqPgdti3ZJPH7uHJkvmZ2weIVKYEpB6FKh6FBriMAPU,24287
+utilities/asyncio.py,sha256=HGX79AKzpQbbDBW3paxAXrhWYeudcJjiO1ETU40d_-8,18463
 utilities/atomicwrites.py,sha256=geFjn9Pwn-tTrtoGjDDxWli9NqbYfy3gGL6ZBctiqSo,5393
 utilities/atools.py,sha256=IYMuFSFGSKyuQmqD6v5IUtDlz8PPw0Sr87Cub_gRU3M,1168
 utilities/cachetools.py,sha256=C1zqOg7BYz0IfQFK8e3qaDDgEZxDpo47F15RTfJM37Q,2910
@@ -16,7 +16,7 @@ utilities/datetime.py,sha256=VOwjPibw63Myv-CRYhT2eEHpz277GqUiEDEaI7p-nQw,38985
 utilities/enum.py,sha256=HoRwVCWzsnH0vpO9ZEcAAIZLMv0Sn2vJxxA4sYMQgDs,5793
 utilities/errors.py,sha256=gxsaa7eq7jbYl41Of40-ivjXqJB5gt4QAcJ0smZZMJE,829
 utilities/eventkit.py,sha256=6M5Xu1SzN-juk9PqBHwy5dS-ta7T0qA6SMpDsakOJ0E,13039
-utilities/fastapi.py,sha256=y-35at3005jzlNx2wJoiSvB1Ch5bMo30wgU_so3IDdI,2467
+utilities/fastapi.py,sha256=eiisloI6kQVCkPfDpBzlLrDZDi8yJ0VmrSPlJ2k84Mo,2334
 utilities/fpdf2.py,sha256=y1NGXR5chWqLXWpewGV3hlRGMr_5yV1lVRkPBhPEgJI,1843
 utilities/functions.py,sha256=jgt592voaHNtX56qX0SRvFveVCRmSIxCZmqvpLZCnY8,27305
 utilities/functools.py,sha256=WrpHt7NLNWSUn9A1Q_ZIWlNaYZOEI4IFKyBG9HO3BC4,1643
@@ -59,15 +59,15 @@ utilities/pytest_regressions.py,sha256=-SVT9647Dg6-JcdsiaDKXe3NdOmmrvGevLKWwGjxq
 utilities/python_dotenv.py,sha256=iWcnpXbH7S6RoXHiLlGgyuH6udCupAcPd_gQ0eAenQ0,3190
 utilities/random.py,sha256=lYdjgxB7GCfU_fwFVl5U-BIM_HV3q6_urL9byjrwDM8,4157
 utilities/re.py,sha256=5J4d8VwIPFVrX2Eb8zfoxImDv7IwiN_U7mJ07wR2Wvs,3958
-utilities/redis.py,sha256=P766qKT2SkDeKa9PpPEZIPCnAc2QDIi35ow2EEHGd20,27225
+utilities/redis.py,sha256=OHw3J2dBA5QssDluKXAG1zIAK2mJJTd6uBuf_1YQuAE,26646
 utilities/reprlib.py,sha256=Re9bk3n-kC__9DxQmRlevqFA86pE6TtVfWjUgpbVOv0,1849
 utilities/rich.py,sha256=t50MwwVBsoOLxzmeVFSVpjno4OW6Ufum32skXbV8-Bs,1911
 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=wPqn9F5AMXgmkp3zgIrBMllLt2SDCCnBNNyi-ag3yzw,5555
+utilities/slack_sdk.py,sha256=NLHmWYK6wc5bz4CGImugXceaToasNBLSqA5sd5ld2r4,3307
 utilities/socket.py,sha256=K77vfREvzoVTrpYKo6MZakol0EYu2q1sWJnnZqL0So0,118
-utilities/sqlalchemy.py,sha256=585hWuuXVTKTnyn0Pfd9JI6jp-hmKW6pLKGYMjXjytM,36959
+utilities/sqlalchemy.py,sha256=09stMwvmI68zlk-DSy9GDk5_YxcMddLh87RPC8Bs4yY,35469
 utilities/sqlalchemy_polars.py,sha256=wjJpoUo-yO9E2ujpG_06vV5r2OdvBiQ4yvV6wKCa2Tk,15605
 utilities/statsmodels.py,sha256=koyiBHvpMcSiBfh99wFUfSggLNx7cuAw3rwyfAhoKpQ,3410
 utilities/streamlit.py,sha256=U9PJBaKP1IdSykKhPZhIzSPTZsmLsnwbEPZWzNhJPKk,2955
@@ -88,7 +88,7 @@ utilities/warnings.py,sha256=un1LvHv70PU-LLv8RxPVmugTzDJkkGXRMZTE2-fTQHw,1771
 utilities/whenever.py,sha256=fC0ZtnO0AyFHsxP4SWj0POI1bf4BIL3Hh4rR51BHfaw,17803
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=-Xm57PMMwDTYpxJdkiJG13wnbwK--I7XItBh5WVhD-o,1874
-dycw_utilities-0.117.0.dist-info/METADATA,sha256=OB8XvTMe2rLu98khXHV7Y43VtZl_4iotbtejKesZsZg,12943
-dycw_utilities-0.117.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.117.0.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.117.0.dist-info/RECORD,,
+dycw_utilities-0.118.0.dist-info/METADATA,sha256=5nkN-STFMRlbctAGspdNN6t3wanBvmbU4JY8eBG3KVg,12943
+dycw_utilities-0.118.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.118.0.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.118.0.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.117.0"
+__version__ = "0.118.0"

utilities/asyncio.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
+import datetime as dt
 from abc import ABC, abstractmethod
 from asyncio import (
-    CancelledError,
     Event,
     PriorityQueue,
     Queue,
@@ -12,17 +12,11 @@ from asyncio import (
     Task,
     TaskGroup,
     create_subprocess_shell,
-    create_task,
     sleep,
     timeout,
 )
 from collections.abc import Callable, Hashable, Iterable, Iterator, Mapping
-from contextlib import (
-    AsyncExitStack,
-    _AsyncGeneratorContextManager,
-    asynccontextmanager,
-    suppress,
-)
+from contextlib import _AsyncGeneratorContextManager, asynccontextmanager
 from dataclasses import dataclass, field
 from io import StringIO
 from logging import getLogger
@@ -32,8 +26,8 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
+    Literal,
     NoReturn,
-    Self,
     TextIO,
     TypeVar,
     assert_never,
@@ -42,14 +36,14 @@ from typing import (
 )
 
 from utilities.datetime import (
-    MILLISECOND,
     MINUTE,
     SECOND,
     datetime_duration_to_float,
+    datetime_duration_to_timedelta,
     get_now,
     round_datetime,
 )
-from utilities.errors import ImpossibleCaseError, repr_error
+from utilities.errors import repr_error
 from utilities.functions import ensure_int, ensure_not_none, get_class_name
 from utilities.reprlib import get_repr
 from utilities.sentinel import Sentinel, sentinel
@@ -62,12 +56,10 @@ from utilities.types import (
 )
 
 if TYPE_CHECKING:
-    import datetime as dt
     from asyncio import _CoroutineLike
     from asyncio.subprocess import Process
     from collections.abc import AsyncIterator, Sequence
     from contextvars import Context
-    from types import TracebackType
 
     from utilities.types import Duration
 
@@ -78,120 +70,6 @@ _T = TypeVar("_T")
 ##
 
 
-@dataclass(kw_only=True)
-class AsyncService(ABC):
-    """A long-running, asynchronous service."""
-
-    duration: Duration | None = None
-    _await_upon_aenter: bool = field(default=True, init=False, repr=False)
-    _event: Event = field(default_factory=Event, init=False, repr=False)
-    _stack: AsyncExitStack = field(
-        default_factory=AsyncExitStack, init=False, repr=False
-    )
-    _state: bool = field(default=False, init=False, repr=False)
-    _task: Task[None] | None = field(default=None, init=False, repr=False)
-    _depth: int = field(default=0, init=False, repr=False)
-
-    async def __aenter__(self) -> Self:
-        """Context manager entry."""
-        if (self._task is None) and (self._depth == 0):
-            _ = await self._stack.__aenter__()
-            self._task = create_task(self._start_runner())
-            if self._await_upon_aenter:
-                with suppress(CancelledError):
-                    await self._task
-        elif (self._task is not None) and (self._depth >= 1):
-            ...
-        else:
-            raise ImpossibleCaseError(  # pragma: no cover
-                case=[f"{self._task=}", f"{self._depth=}"]
-            )
-        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)
-        if (self._task is None) or (self._depth == 0):
-            raise ImpossibleCaseError(  # pragma: no cover
-                case=[f"{self._task=}", f"{self._depth=}"]
-            )
-        self._state = False
-        self._depth -= 1
-        if self._depth == 0:
-            _ = await self._stack.__aexit__(exc_type, exc_value, traceback)
-            await self.stop()
-            with suppress(CancelledError):
-                await self._task
-            self._task = None
-
-    @abstractmethod
-    async def _start(self) -> None:
-        """Start the service."""
-
-    async def _start_runner(self) -> None:
-        """Coroutine to start the service."""
-        if self.duration is None:
-            _ = await self._start()
-            _ = await self._event.wait()
-        else:
-            try:
-                async with timeout_dur(duration=self.duration):
-                    _ = await self._start()
-            except TimeoutError:
-                await self.stop()
-
-    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()
-
-
-##
-
-
-@dataclass(kw_only=True)
-class AsyncLoopingService(AsyncService):
-    """A long-running, asynchronous service which loops a core function."""
-
-    sleep: Duration = MILLISECOND
-    _await_upon_aenter: bool = field(default=True, init=False, repr=False)
-
-    @abstractmethod
-    async def _run(self) -> None:
-        """Run the core function once."""
-        raise NotImplementedError  # pragma: no cover
-
-    async def _run_failure(self, error: Exception, /) -> None:
-        """Process the failure."""
-        raise error
-
-    @override
-    async def _start(self) -> None:
-        """Start the service, assuming no task is present."""
-        while True:
-            try:
-                await self._run()
-            except CancelledError:
-                await self.stop()
-                break
-            except Exception as error:  # noqa: BLE001
-                await self._run_failure(error)
-                await sleep_dur(duration=self.sleep)
-            else:
-                await sleep_dur(duration=self.sleep)
-
-
-##
-
-
 class EnhancedTaskGroup(TaskGroup):
     """Task group with enhanced features."""
 
@@ -243,106 +121,15 @@ class EnhancedTaskGroup(TaskGroup):
 ##
 
 
-@dataclass(kw_only=True)
-class QueueProcessor(AsyncService, Generic[_T]):
-    """Process a set of items in a queue."""
-
-    queue_type: type[Queue[_T]] = field(default=Queue, repr=False)
-    queue_max_size: int | None = field(default=None, repr=False)
-    sleep: Duration = MILLISECOND
-    _await_upon_aenter: bool = field(default=False, init=False, repr=False)
-    _queue: Queue[_T] = field(init=False, repr=False)
-
-    def __post_init__(self) -> None:
-        self._queue = self.queue_type(
-            maxsize=0 if self.queue_max_size is None else self.queue_max_size
-        )
-
-    def __len__(self) -> int:
-        return self._queue.qsize()
-
-    def empty(self) -> bool:
-        """Check if the queue is empty."""
-        return self._queue.empty()
-
-    def enqueue(self, *items: _T) -> None:
-        """Enqueue a set items."""
-        for item in items:
-            self._queue.put_nowait(item)
-
-    async def run_until_empty(self) -> None:
-        """Run the processor until the queue is empty."""
-        while not self.empty():
-            await self._run()
-            await sleep_dur(duration=self.sleep)
-
-    def _get_items_nowait(self, *, max_size: int | None = None) -> Sequence[_T]:
-        """Get items from the queue; no waiting."""
-        return get_items_nowait(self._queue, max_size=max_size)
-
-    @abstractmethod
-    async def _process_item(self, item: _T, /) -> None:
-        """Process the first item."""
-        raise NotImplementedError(item)  # pragma: no cover
-
-    async def _process_item_failure(self, item: _T, error: Exception, /) -> None:
-        """Process the failure."""
-        _ = item
-        raise error
-
-    async def _run(self) -> None:
-        """Run the processer."""
-        try:
-            (item,) = self._get_items_nowait(max_size=1)
-        except ValueError:
-            raise QueueEmpty from None
-        try:
-            await self._process_item(item)
-        except Exception as error:  # noqa: BLE001
-            await self._process_item_failure(item, error)
-
-    @override
-    async def _start(self) -> None:
-        """Start the processor."""
-        while True:
-            try:
-                await self._run()
-            except QueueEmpty:
-                await sleep_dur(duration=self.sleep)
-            except CancelledError:
-                await self.stop()
-                break
-            else:
-                await sleep_dur(duration=self.sleep)
-
-    @override
-    async def stop(self) -> None:
-        """Stop the processor."""
-        await self.run_until_empty()
-        await super().stop()
-
-
-@dataclass(kw_only=True)
-class ExceptionProcessor(QueueProcessor[Exception | type[Exception]]):
-    """Raise an exception in a queue."""
-
-    queue_max_size: int | None = field(default=1, repr=False)
-
-    @override
-    async def _process_item(self, item: Exception | type[Exception], /) -> None:
-        """Run the processor on the first item."""
-        raise item
-
-
-##
+type _DurationOrEvery = Duration | tuple[Literal["every"], Duration]
 
 
 @dataclass(kw_only=True, unsafe_hash=True)
 class InfiniteLooper(ABC, Generic[THashable]):
     """An infinite loop which can throw exceptions by setting events."""
 
-    sleep_core: Duration = SECOND
-    sleep_restart: Duration = MINUTE
+    sleep_core: _DurationOrEvery = SECOND
+    sleep_restart: _DurationOrEvery = MINUTE
     logger: str | None = None
     _events: Mapping[THashable, Event] = field(
         default_factory=dict, init=False, repr=False, hash=False
@@ -369,7 +156,7 @@ class InfiniteLooper(ABC, Generic[THashable]):
                     await self._initialize()
                 except Exception as error:  # noqa: BLE001
                     self._error_upon_initialize(error)
-                    await sleep_dur(duration=self.sleep_restart)
+                    await self._run_sleep(self.sleep_restart)
                 else:
                     while True:
                         try:
@@ -380,14 +167,14 @@ class InfiniteLooper(ABC, Generic[THashable]):
                             )
                         except StopIteration:
                             await self._core()
-                            await sleep_dur(duration=self.sleep_core)
+                            await self._run_sleep(self.sleep_core)
                         else:
                             self._raise_error(event)
             except InfiniteLooperError:
                 raise
             except Exception as error:  # noqa: BLE001
                 self._error_upon_core(error)
-                await sleep_dur(duration=self.sleep_restart)
+                await self._run_sleep(self.sleep_restart)
 
     async def _run_looper_with_coroutines(
         self, *coroutines: Callable[[], Coroutine1[None]]
@@ -401,7 +188,7 @@ class InfiniteLooper(ABC, Generic[THashable]):
                     _ = [tg.create_task(c()) for c in coroutines]
             except ExceptionGroup as error:
                 self._error_group_upon_coroutines(error)
-                await sleep_dur(duration=self.sleep_restart)
+                await self._run_sleep(self.sleep_restart)
 
     async def _initialize(self) -> None:
         """Initialize the loop."""
@@ -413,20 +200,20 @@ class InfiniteLooper(ABC, Generic[THashable]):
         """Handle any errors upon initializing the looper."""
         if self.logger is not None:
             getLogger(name=self.logger).error(
-                "%r encountered %r whilst initializing; sleeping for %s...",
+                "%r encountered %r whilst initializing; sleeping %s...",
                 get_class_name(self),
                 repr_error(error),
-                self.sleep_restart,
+                self._sleep_restart_desc,
             )
 
     def _error_upon_core(self, error: Exception, /) -> None:
         """Handle any errors upon running the core function."""
         if self.logger is not None:
             getLogger(name=self.logger).error(
-                "%r encountered %r; sleeping for %s...",
+                "%r encountered %r; sleeping %s...",
                 get_class_name(self),
                 repr_error(error),
-                self.sleep_restart,
+                self._sleep_restart_desc,
             )
 
     def _error_group_upon_coroutines(self, group: ExceptionGroup, /) -> None:
@@ -439,7 +226,7 @@ class InfiniteLooper(ABC, Generic[THashable]):
                 f"- Error #{i}/{n}: {repr_error(e)}"
                 for i, e in enumerate(errors, start=1)
             )
-            msgs.append(f"Sleeping for {self.sleep_restart}...")
+            msgs.append(f"Sleeping {self._sleep_restart_desc}...")
             getLogger(name=self.logger).error("\n".join(msgs))
 
     def _raise_error(self, event: THashable, /) -> NoReturn:
@@ -454,6 +241,29 @@ class InfiniteLooper(ABC, Generic[THashable]):
             event: Event() for event, _ in self._yield_events_and_exceptions()
         }
 
+    async def _run_sleep(self, sleep: _DurationOrEvery, /) -> 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:
         """Set the given event."""
         try:
@@ -779,15 +589,11 @@ async def timeout_dur(
 
 
 __all__ = [
-    "AsyncLoopingService",
-    "AsyncService",
     "EnhancedTaskGroup",
-    "ExceptionProcessor",
     "InfiniteLooper",
     "InfiniteLooperError",
     "InfiniteQueueLooper",
     "InfiniteQueueLooperError",
-    "QueueProcessor",
     "StreamCommandOutput",
     "UniquePriorityQueue",
     "UniqueQueue",

utilities/fastapi.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, Literal, override
 from fastapi import FastAPI
 from uvicorn import Config, Server
 
-from utilities.asyncio import AsyncService
+from utilities.asyncio import InfiniteLooper
 from utilities.datetime import SECOND, datetime_duration_to_float
 
 if TYPE_CHECKING:
@@ -36,7 +36,7 @@ class _PingerReceiverApp(FastAPI):
 
 
 @dataclass(kw_only=True)
-class PingReceiver(AsyncService):
+class PingReceiver(InfiniteLooper):
     """A ping receiver."""
 
     host: InitVar[str] = _LOCALHOST
@@ -67,13 +67,8 @@ class PingReceiver(AsyncService):
         return response.text if response.status_code == 200 else False  # skipif-ci
 
     @override
-    async def _start(self) -> None:
+    async def _initialize(self) -> None:
         await self._server.serve()  # skipif-ci
 
-    @override
-    async def stop(self) -> None:
-        await self._server.shutdown()  # skipif-ci
-        await super().stop()  # skipif-ci
-
 
 __all__ = ["PingReceiver"]

utilities/redis.py

@@ -22,7 +22,7 @@ from redis.asyncio import Redis
 from redis.asyncio.client import PubSub
 from redis.typing import EncodableT
 
-from utilities.asyncio import InfiniteQueueLooper, QueueProcessor, timeout_dur
+from utilities.asyncio import InfiniteQueueLooper, timeout_dur
 from utilities.datetime import (
     MILLISECOND,
     SECOND,
@@ -588,22 +588,6 @@ async def publish(
 ##
 
 
-@dataclass(kw_only=True)
-class Publisher(QueueProcessor[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_item(self, item: tuple[str, EncodableT], /) -> None:
-        channel, data = item  # skipif-ci-and-not-linux
-        _ = await publish(  # skipif-ci-and-not-linux
-            self.redis, channel, data, serializer=self.serializer, timeout=self.timeout
-        )
-
-
 @dataclass(kw_only=True)
 class PublisherIQL(InfiniteQueueLooper[None, tuple[str, EncodableT]]):
     """Publish a set of messages to Redis."""
@@ -828,7 +812,6 @@ _ = _TestRedis
 
 
 __all__ = [
-    "Publisher",
     "PublisherIQL",
     "PublisherIQLError",
     "RedisHashMapKey",

utilities/slack_sdk.py

@@ -3,18 +3,12 @@ from __future__ import annotations
 from asyncio import Queue
 from dataclasses import dataclass
 from http import HTTPStatus
-from itertools import chain
 from logging import NOTSET, Handler, LogRecord
 from typing import TYPE_CHECKING, override
 
 from slack_sdk.webhook.async_client import AsyncWebhookClient
 
-from utilities.asyncio import (
-    InfiniteQueueLooper,
-    QueueProcessor,
-    sleep_dur,
-    timeout_dur,
-)
+from utilities.asyncio import InfiniteQueueLooper, timeout_dur
 from utilities.datetime import MINUTE, SECOND, datetime_duration_to_float
 from utilities.functools import cache
 from utilities.math import safe_round
@@ -40,66 +34,6 @@ async def _send_adapter(url: str, text: str, /) -> None:
     await send_to_slack(url, text)  # pragma: no cover
 
 
-@dataclass(init=False, order=True, unsafe_hash=True)
-class SlackHandler(Handler, QueueProcessor[str]):
-    """Handler for sending messages to Slack."""
-
-    @override
-    def __init__(
-        self,
-        url: str,
-        /,
-        *,
-        level: int = NOTSET,
-        queue_type: type[Queue[str]] = Queue,
-        queue_max_size: int | None = None,
-        sender: Callable[[str, str], Coroutine1[None]] = _send_adapter,
-        timeout: Duration = _TIMEOUT,
-        callback_failure: Callable[[str, Exception], None] | None = None,
-        callback_success: Callable[[str], None] | None = None,
-        callback_final: Callable[[str], None] | None = None,
-        sleep: Duration = _SLEEP,
-    ) -> None:
-        QueueProcessor.__init__(  # QueueProcessor first
-            self, queue_type=queue_type, queue_max_size=queue_max_size
-        )
-        QueueProcessor.__post_init__(self)
-        Handler.__init__(self, level=level)
-        self.url = url
-        self.sender = sender
-        self.timeout = timeout
-        self.callback_failure = callback_failure
-        self.callback_success = callback_success
-        self.callback_final = callback_final
-        self.sleep = sleep
-
-    @override
-    def emit(self, record: LogRecord) -> None:
-        try:
-            self.enqueue(self.format(record))
-        except Exception:  # noqa: BLE001  # pragma: no cover
-            self.handleError(record)
-
-    @override
-    async def _process_item(self, item: str, /) -> None:
-        """Process the first item."""
-        items = list(chain([item], self._get_items_nowait()))
-        text = "\n".join(items)
-        try:
-            async with timeout_dur(duration=self.timeout):
-                await self.sender(self.url, text)
-        except Exception as error:  # noqa: BLE001
-            if self.callback_failure is not None:
-                self.callback_failure(text, error)
-        else:
-            if self.callback_success is not None:
-                self.callback_success(text)
-        finally:
-            if self.callback_final is not None:
-                self.callback_final(text)
-            await sleep_dur(duration=self.sleep)
-
-
 @dataclass(init=False, unsafe_hash=True)
 class SlackHandlerIQL(Handler, InfiniteQueueLooper[None, str]):
     """Handler for sending messages to Slack."""
@@ -176,4 +110,4 @@ def _get_client(url: str, /, *, timeout: Duration = _TIMEOUT) -> AsyncWebhookCli
     return AsyncWebhookClient(url, timeout=timeout_use)
 
 
-__all__ = ["SendToSlackError", "SlackHandler", "SlackHandlerIQL", "send_to_slack"]
+__all__ = ["SendToSlackError", "SlackHandlerIQL", "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, QueueProcessor, timeout_dur
+from utilities.asyncio import InfiniteQueueLooper, timeout_dur
 from utilities.functions import (
     ensure_str,
     get_class_name,
@@ -608,48 +608,6 @@ class TablenameMixin:
 ##
 
 
-@dataclass(kw_only=True)
-class Upserter(QueueProcessor[_InsertItem]):
-    """Upsert a set of items into 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
-
-    async def _pre_upsert(self, items: Sequence[_InsertItem], /) -> None:
-        """Pre-upsert coroutine."""
-        _ = items
-
-    async def _post_upsert(self, items: Sequence[_InsertItem], /) -> None:
-        """Post-upsert coroutine."""
-        _ = items
-
-    @override
-    async def _process_item(self, item: _InsertItem, /) -> None:
-        """Process the first item."""
-        items = list(chain([item], self._get_items_nowait()))
-        await self._pre_upsert(items)
-        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,
-        )
-        await self._post_upsert(items)
-
-
 @dataclass(kw_only=True)
 class UpserterIQL(InfiniteQueueLooper[None, _InsertItem]):
     """Upsert a set of items to a database."""
@@ -1150,7 +1108,6 @@ __all__ = [
     "InsertItemsError",
     "TablenameMixin",
     "UpsertItemsError",
-    "Upserter",
     "UpserterIQL",
     "UpserterIQLError",
     "check_engine",