dycw-utilities 0.123.0__tar.gz → 0.124.0__tar.gz

{dycw_utilities-0.123.0 → dycw_utilities-0.124.0}/PKG-INFO

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

{dycw_utilities-0.123.0 → dycw_utilities-0.124.0}/pyproject.toml

@@ -92,7 +92,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.123.0"
+version = "0.124.0"
 
 [project.optional-dependencies]
 test = [
@@ -334,7 +334,7 @@ zzz-test-zoneinfo = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.123.0"
+current_version = "0.124.0"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.123.0 → dycw_utilities-0.124.0}/src/tests/test_asyncio.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from asyncio import CancelledError, Event, Queue, TaskGroup, run, sleep, timeout
+from asyncio import CancelledError, Event, Queue, run, sleep
+from collections import deque
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from functools import partial
@@ -8,9 +9,10 @@ from itertools import chain, count
 from re import search
 from typing import TYPE_CHECKING, Any, ClassVar, Self, cast, override
 
-from hypothesis import HealthCheck, Phase, given, settings
+from hypothesis import HealthCheck, Phase, assume, given, settings
 from hypothesis.strategies import (
     DataObject,
+    booleans,
     data,
     integers,
     just,
@@ -22,6 +24,7 @@ from hypothesis.strategies import (
 from pytest import LogCaptureFixture, mark, param, raises
 
 from utilities.asyncio import (
+    EnhancedQueue,
     EnhancedTaskGroup,
     InfiniteLooper,
     InfiniteQueueLooper,
@@ -65,6 +68,77 @@ if TYPE_CHECKING:
     )
 
 
+class TestEnhancedQueue:
+    @given(
+        xs=lists(integers()),
+        wait=booleans(),
+        put_all=booleans(),
+        get_reverse=booleans(),
+    )
+    async def test_left(
+        self, *, xs: list[int], wait: int, put_all: bool, get_reverse: bool
+    ) -> None:
+        _ = assume(not ((len(xs) == 0) and wait))
+        deq: deque[int] = deque()
+        for x in xs:
+            deq.appendleft(x)
+        queue: EnhancedQueue[int] = EnhancedQueue()
+        if put_all:
+            if wait:
+                await queue.put_left(*xs)
+            else:
+                queue.put_left_nowait(*xs)
+        else:
+            for i, x in enumerate(xs, start=1):
+                if wait:
+                    await queue.put_left(x)
+                else:
+                    queue.put_left_nowait(x)
+                assert queue.qsize() == i
+        assert list(deq) == xs[::-1]
+        if wait:
+            res = await queue.get_all(reverse=get_reverse)
+        else:
+            res = queue.get_all_nowait(reverse=get_reverse)
+        expected = xs if get_reverse else xs[::-1]
+        assert res == expected
+
+    @given(
+        xs=lists(integers()),
+        wait=booleans(),
+        put_all=booleans(),
+        get_reverse=booleans(),
+    )
+    async def test_right(
+        self, *, xs: list[int], wait: int, put_all: bool, get_reverse: bool
+    ) -> None:
+        _ = assume(not ((len(xs) == 0) and wait))
+        deq: deque[int] = deque()
+        for x in xs:
+            deq.append(x)
+        queue: EnhancedQueue[int] = EnhancedQueue()
+        if put_all:
+            if wait:
+                await queue.put_right(*xs)
+            else:
+                queue.put_right_nowait(*xs)
+            assert queue.qsize() == len(xs)
+        else:
+            for i, x in enumerate(xs, start=1):
+                if wait:
+                    await queue.put_right(x)
+                else:
+                    queue.put_right_nowait(x)
+                assert queue.qsize() == i
+        assert list(deq) == xs
+        if wait:
+            res = await queue.get_all(reverse=get_reverse)
+        else:
+            res = queue.get_all_nowait(reverse=get_reverse)
+        expected = xs[::-1] if get_reverse else xs
+        assert res == expected
+
+
 class TestEnhancedTaskGroup:
     async def test_create_task_context_coroutine(self) -> None:
         flag: bool = False
@@ -175,6 +249,24 @@ class TestGetEvent:
         assert get_event(event=lambda: event) is event
 
 
+class TestGetItems:
+    @given(
+        xs=lists(integers(), min_size=1),
+        max_size=integers(1, 10) | none(),
+        wait=booleans(),
+    )
+    async def test_main(
+        self, *, xs: list[int], max_size: int | None, wait: bool
+    ) -> None:
+        queue: Queue[int] = Queue()
+        put_items_nowait(xs, queue)
+        if wait:
+            result = await get_items(queue, max_size=max_size)
+        else:
+            result = get_items_nowait(queue, max_size=max_size)
+        assert result == xs[:max_size]
+
+
 class TestInfiniteLooper:
     sleep_restart_cases: ClassVar[list[Any]] = [
         param(60.0, "for 0:01:00"),
@@ -386,9 +478,9 @@ class TestInfiniteLooper:
             Example(sleep_core=0.05, sleep_restart=0.05) as looper,
         ):
             ...
-        assert 4 <= looper.initializations <= 6
-        assert 0 <= looper.counter <= 7
-        assert 14 <= external <= 21
+        assert 3 <= looper.initializations <= 7
+        assert 0 <= looper.counter <= 8
+        assert 13 <= external <= 22
 
     async def test_with_coroutine_self_error(self) -> None:
         class CustomError(Exception): ...
@@ -661,13 +753,13 @@ class TestInfiniteQueueLooper:
             counter: int = 0
 
             @override
-            async def _process_items(self, *items: int) -> None:
-                self.counter += len(items)
+            async def _process_queue(self) -> None:
+                self.counter += len(self._queue.get_all_nowait())
 
         async with timeout_dur(duration=1.0), Example(sleep_core=0.05) as looper:
             await sleep(0.1)
             for i in range(10):
-                looper.put_items_nowait(i)
+                looper.put_right_nowait(i)
                 await sleep(0.05)
 
             assert looper.counter == 10
@@ -678,13 +770,13 @@ class TestInfiniteQueueLooper:
             output: set[int] = field(default_factory=set)
 
             @override
-            async def _process_items(self, *items: int) -> None:
-                self.output.update(items)
+            async def _process_queue(self) -> None:
+                self.output.update(self._queue.get_all_nowait())
 
         looper = Example(sleep_core=0.05)
         assert len(looper) == 0
         assert looper.empty()
-        looper.put_items_nowait(*range(n))
+        looper.put_right_nowait(*range(n))
         assert len(looper) == n
         assert not looper.empty()
 
@@ -694,11 +786,11 @@ class TestInfiniteQueueLooper:
             output: set[int] = field(default_factory=set)
 
             @override
-            async def _process_items(self, *items: int) -> None:
-                self.output.update(items)
+            async def _process_queue(self) -> None:
+                self.output.update(self._queue.get_all_nowait())
 
         looper = Example(sleep_core=0.05)
-        looper.put_items_nowait(*range(10))
+        looper.put_right_nowait(*range(10))
         async with looper:
             await looper.run_until_empty()
         assert looper.empty()
@@ -715,66 +807,32 @@ class TestInfiniteQueueLooper:
             output: set[int] = field(default_factory=set)
 
             @override
-            async def _process_items(self, *items: int) -> None:
-                raise CustomError(*items)
+            async def _process_queue(self) -> None:
+                raise CustomError
 
         async with (
             timeout_dur(duration=1.0),
             Example(sleep_core=0.05, logger=logger) as looper,
         ):
-            looper.put_items_nowait(1)
+            looper.put_left_nowait(1)
         if logger is not None:
             message = caplog.messages[0]
-            expected = "'Example' encountered CustomError(1) whilst processing 1 item(s) [1]; sleeping for 0:01:00..."
+            expected = "'Example' encountered 'CustomError()'; sleeping for 0:01:00..."
             assert message == expected
 
 
-class TestPutAndGetItems:
-    @given(xs=lists(integers(), min_size=1), max_size=integers(1, 10) | none())
-    async def test_put_then_get(self, *, xs: list[int], max_size: int | None) -> None:
+class TestPutItems:
+    @given(xs=lists(integers(), min_size=1), wait=booleans())
+    async def test_main(self, *, xs: list[int], wait: bool) -> None:
         queue: Queue[int] = Queue()
-        await put_items(xs, queue)
-        result = await get_items(queue, max_size=max_size)
-        if max_size is None:
-            assert result == xs
+        if wait:
+            put_items_nowait(xs, queue)
         else:
-            assert result == xs[:max_size]
-
-    @given(xs=lists(integers(), min_size=1), max_size=integers(1, 10) | none())
-    async def test_get_then_put(self, *, xs: list[int], max_size: int | None) -> None:
-        queue: Queue[int] = Queue()
-
-        async def put() -> None:
-            await sleep(0.01)
             await put_items(xs, queue)
-
-        async with TaskGroup() as tg:
-            task = tg.create_task(get_items(queue, max_size=max_size))
-            _ = tg.create_task(put())
-        result = task.result()
-        if max_size is None:
-            assert result == xs
-        else:
-            assert result == xs[:max_size]
-
-    async def test_empty(self) -> None:
-        queue: Queue[int] = Queue()
-        with raises(TimeoutError):  # noqa: PT012
-            async with timeout(0.01), TaskGroup() as tg:
-                _ = tg.create_task(get_items(queue))
-                _ = tg.create_task(sleep(0.02))
-
-
-class TestPutAndGetItemsNoWait:
-    @given(xs=lists(integers(), min_size=1), max_size=integers(1, 10) | none())
-    def test_main(self, *, xs: list[int], max_size: int | None) -> None:
-        queue: Queue[int] = Queue()
-        put_items_nowait(xs, queue)
-        result = get_items_nowait(queue, max_size=max_size)
-        if max_size is None:
-            assert result == xs
-        else:
-            assert result == xs[:max_size]
+        result: list[int] = []
+        while not queue.empty():
+            result.append(await queue.get())
+        assert result == xs
 
 
 class TestUniquePriorityQueue:

{dycw_utilities-0.123.0 → dycw_utilities-0.124.0}/src/tests/test_redis.py

@@ -150,7 +150,7 @@ class TestPublisher:
 
             async def sleep_then_put() -> None:
                 await sleep(0.1)
-                publisher.put_items_nowait((channel, obj))
+                publisher.put_right_nowait((channel, obj))
 
             with raises(ExceptionGroup):  # noqa: PT012
                 async with EnhancedTaskGroup(timeout=1.0) as tg:
@@ -187,7 +187,7 @@ class TestPublisher:
 
             async def sleep_then_put() -> None:
                 await sleep(0.1)
-                publisher.put_items_nowait((channel, text))
+                publisher.put_right_nowait((channel, text))
 
             with raises(ExceptionGroup):  # noqa: PT012
                 async with EnhancedTaskGroup(timeout=1.0) as tg:

{dycw_utilities-0.123.0 → dycw_utilities-0.124.0}/src/tests/test_sqlalchemy.py

@@ -1169,7 +1169,7 @@ class TestUpserter:
         engine = await sqlalchemy_engines(data, table)
         pairs = [(id_, init) for id_, init, _ in triples]
         async with Upserter(duration=1.0, sleep_core=0.1, engine=engine) as upserter:
-            upserter.put_items_nowait((pairs, table))
+            upserter.put_right_nowait((pairs, table))
 
         sel = select(table)
         async with engine.begin() as conn:

{dycw_utilities-0.123.0 → dycw_utilities-0.124.0}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.123.0"
+__version__ = "0.124.0"

{dycw_utilities-0.123.0 → dycw_utilities-0.124.0}/src/utilities/asyncio.py

@@ -8,6 +8,7 @@ from asyncio import (
     PriorityQueue,
     Queue,
     QueueEmpty,
+    QueueFull,
     Semaphore,
     StreamReader,
     Task,
@@ -27,6 +28,7 @@ from contextlib import (
 )
 from dataclasses import dataclass, field
 from io import StringIO
+from itertools import chain
 from logging import getLogger
 from subprocess import PIPE
 from sys import stderr, stdout
@@ -43,6 +45,8 @@ from typing import (
     override,
 )
 
+from typing_extensions import deprecated
+
 from utilities.datetime import (
     MINUTE,
     SECOND,
@@ -53,7 +57,6 @@ from utilities.datetime import (
 )
 from utilities.errors import ImpossibleCaseError, 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
 from utilities.types import (
     Coroutine1,
@@ -67,6 +70,7 @@ from utilities.types import (
 if TYPE_CHECKING:
     from asyncio import _CoroutineLike
     from asyncio.subprocess import Process
+    from collections import deque
     from collections.abc import AsyncIterator, Sequence
     from contextvars import Context
     from types import TracebackType
@@ -77,6 +81,164 @@ if TYPE_CHECKING:
 _T = TypeVar("_T")
 
 
+class EnhancedQueue(Queue[_T]):
+    """An asynchronous deque."""
+
+    @override
+    def __init__(self, maxsize: int = 0) -> None:
+        super().__init__(maxsize=maxsize)
+        self._finished: Event
+        self._getters: deque[Any]
+        self._putters: deque[Any]
+        self._queue: deque[_T]
+        self._unfinished_tasks: int
+
+    @override
+    @deprecated("Use `get_left`/`get_right` instead")
+    async def get(self) -> _T:
+        raise RuntimeError  # pragma: no cover
+
+    @override
+    @deprecated("Use `get_left_nowait`/`get_right_nowait` instead")
+    def get_nowait(self) -> _T:
+        raise RuntimeError  # pragma: no cover
+
+    @override
+    @deprecated("Use `put_left`/`put_right` instead")
+    async def put(self, item: _T) -> None:
+        raise RuntimeError(item)  # pragma: no cover
+
+    @override
+    @deprecated("Use `put_left_nowait`/`put_right_nowait` instead")
+    def put_nowait(self, item: _T) -> None:
+        raise RuntimeError(item)  # pragma: no cover
+
+    # get all
+
+    async def get_all(self, *, reverse: bool = False) -> Sequence[_T]:
+        """Remove and return all items from the queue."""
+        first = await (self.get_right() if reverse else self.get_left())
+        return list(chain([first], self.get_all_nowait(reverse=reverse)))
+
+    def get_all_nowait(self, *, reverse: bool = False) -> Sequence[_T]:
+        """Remove and return all items from the queue without blocking."""
+        items: Sequence[_T] = []
+        while True:
+            try:
+                items.append(
+                    self.get_right_nowait() if reverse else self.get_left_nowait()
+                )
+            except QueueEmpty:
+                return items
+
+    # get left/right
+
+    async def get_left(self) -> _T:
+        """Remove and return an item from the start of the queue."""
+        return await self._get_left_or_right(self._get)
+
+    async def get_right(self) -> _T:
+        """Remove and return an item from the end of the queue."""
+        return await self._get_left_or_right(self._get_right)
+
+    def get_left_nowait(self) -> _T:
+        """Remove and return an item from the start of the queue without blocking."""
+        return self._get_left_or_right_nowait(self._get)
+
+    def get_right_nowait(self) -> _T:
+        """Remove and return an item from the end of the queue without blocking."""
+        return self._get_left_or_right_nowait(self._get_right)
+
+    # put left/right
+
+    async def put_left(self, *items: _T) -> None:
+        """Put items into the queue at the start."""
+        return await self._put_left_or_right(self._put_left, *items)
+
+    async def put_right(self, *items: _T) -> None:
+        """Put items into the queue at the end."""
+        return await self._put_left_or_right(self._put, *items)
+
+    def put_left_nowait(self, *items: _T) -> None:
+        """Put items into the queue at the start without blocking."""
+        self._put_left_or_right_nowait(self._put_left, *items)
+
+    def put_right_nowait(self, *items: _T) -> None:
+        """Put items into the queue at the end without blocking."""
+        self._put_left_or_right_nowait(self._put, *items)
+
+    # private
+
+    def _put_left(self, item: _T) -> None:
+        self._queue.appendleft(item)
+
+    def _get_right(self) -> _T:
+        return self._queue.pop()
+
+    async def _get_left_or_right(self, getter_use: Callable[[], _T], /) -> _T:
+        while self.empty():  # pragma: no cover
+            getter = self._get_loop().create_future()  # pyright: ignore[reportAttributeAccessIssue]
+            self._getters.append(getter)
+            try:
+                await getter
+            except:
+                getter.cancel()
+                with suppress(ValueError):
+                    self._getters.remove(getter)
+                if not self.empty() and not getter.cancelled():
+                    self._wakeup_next(self._getters)  # pyright: ignore[reportAttributeAccessIssue]
+                raise
+        return getter_use()
+
+    def _get_left_or_right_nowait(self, getter: Callable[[], _T], /) -> _T:
+        if self.empty():
+            raise QueueEmpty
+        item = getter()
+        self._wakeup_next(self._putters)  # pyright: ignore[reportAttributeAccessIssue]
+        return item
+
+    async def _put_left_or_right(
+        self, putter_use: Callable[[_T], None], /, *items: _T
+    ) -> None:
+        """Put an item into the queue."""
+        for item in items:
+            await self._put_left_or_right_one(putter_use, item)
+
+    async def _put_left_or_right_one(
+        self, putter_use: Callable[[_T], None], item: _T, /
+    ) -> None:
+        """Put an item into the queue."""
+        while self.full():  # pragma: no cover
+            putter = self._get_loop().create_future()  # pyright: ignore[reportAttributeAccessIssue]
+            self._putters.append(putter)
+            try:
+                await putter
+            except:
+                putter.cancel()
+                with suppress(ValueError):
+                    self._putters.remove(putter)
+                if not self.full() and not putter.cancelled():
+                    self._wakeup_next(self._putters)  # pyright: ignore[reportAttributeAccessIssue]
+                raise
+        return putter_use(item)
+
+    def _put_left_or_right_nowait(
+        self, putter: Callable[[_T], None], /, *items: _T
+    ) -> None:
+        for item in items:
+            self._put_left_or_right_nowait_one(putter, item)
+
+    def _put_left_or_right_nowait_one(
+        self, putter: Callable[[_T], None], item: _T, /
+    ) -> None:
+        if self.full():  # pragma: no cover
+            raise QueueFull
+        putter(item)
+        self._unfinished_tasks += 1
+        self._finished.clear()
+        self._wakeup_next(self._getters)  # pyright: ignore[reportAttributeAccessIssue]
+
+
 ##
 
 
@@ -428,14 +590,13 @@ class _InfiniteLooperDefaultEventError(InfiniteLooperError):
 class InfiniteQueueLooper(InfiniteLooper[THashable], Generic[THashable, _T]):
     """An infinite loop which processes a queue."""
 
-    queue_type: type[Queue[_T]] = field(default=Queue, repr=False)
     _await_upon_aenter: bool = field(default=False, init=False, repr=False)
-    _queue: Queue[_T] = field(init=False)
+    _queue: EnhancedQueue[_T] = field(init=False, repr=False)
 
     @override
     def __post_init__(self) -> None:
         super().__post_init__()
-        self._queue = self.queue_type()
+        self._queue = EnhancedQueue()
 
     def __len__(self) -> int:
         return self._queue.qsize()
@@ -443,55 +604,32 @@ class InfiniteQueueLooper(InfiniteLooper[THashable], Generic[THashable, _T]):
     @override
     async def _core(self) -> None:
         """Run the core part of the loop."""
-        items = await get_items(self._queue)
-        try:
-            await self._process_items(*items)
-        except Exception as error:  # noqa: BLE001
-            raise InfiniteQueueLooperError(
-                looper=self, items=items, error=error
-            ) from None
+        first = await self._queue.get_left()
+        self._queue.put_left_nowait(first)
+        await self._process_queue()
 
     @abstractmethod
-    async def _process_items(self, *items: _T) -> None:
-        """Process the items."""
+    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_items_nowait(self, *items: _T) -> None:
-        """Put items into the queue."""
-        put_items_nowait(items, self._queue)
+    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
 
     async def run_until_empty(self) -> None:
         """Run until the queue is empty."""
         while not self.empty():
-            await self._process_items(*get_items_nowait(self._queue))
+            await self._process_queue()
         await self.stop()
 
-    @override
-    def _error_upon_core(self, error: Exception, /) -> None:
-        """Handle any errors upon running the core function."""
-        if self.logger is not None:
-            if isinstance(error, InfiniteQueueLooperError):
-                getLogger(name=self.logger).error(
-                    "%r encountered %s whilst processing %d item(s) %s; sleeping %s...",
-                    get_class_name(self),
-                    repr_error(error.error),
-                    len(error.items),
-                    get_repr(error.items),
-                    self._sleep_restart_desc,
-                )
-            else:
-                super()._error_upon_core(error)  # pragma: no cover
-
-
-@dataclass(kw_only=True, slots=True)
-class InfiniteQueueLooperError(Exception, Generic[_T]):
-    looper: InfiniteQueueLooper[Any, Any]
-    items: Sequence[_T]
-    error: Exception
-
 
 ##
 
@@ -715,11 +853,11 @@ async def timeout_dur(
 
 
 __all__ = [
+    "EnhancedQueue",
     "EnhancedTaskGroup",
     "InfiniteLooper",
     "InfiniteLooperError",
     "InfiniteQueueLooper",
-    "InfiniteQueueLooperError",
     "StreamCommandOutput",
     "UniquePriorityQueue",
     "UniqueQueue",

{dycw_utilities-0.123.0 → dycw_utilities-0.124.0}/src/utilities/redis.py

@@ -597,8 +597,8 @@ class Publisher(InfiniteQueueLooper[None, tuple[str, EncodableT]]):
     timeout: Duration = _PUBLISH_TIMEOUT
 
     @override
-    async def _process_items(self, *items: tuple[str, EncodableT]) -> None:
-        for item in items:  # skipif-ci-and-not-linux
+    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,

{dycw_utilities-0.123.0 → dycw_utilities-0.124.0}/src/utilities/slack_sdk.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from asyncio import Queue
 from dataclasses import dataclass
 from http import HTTPStatus
 from logging import NOTSET, Handler, LogRecord
@@ -47,15 +46,12 @@ class SlackHandler(Handler, InfiniteQueueLooper[None, str]):
         level: int = NOTSET,
         sleep_core: Duration = _SLEEP,
         sleep_restart: Duration = _SLEEP,
-        queue_type: type[Queue[str]] = Queue,
         sender: Callable[[str, str], Coroutine1[None]] = _send_adapter,
         timeout: Duration = _TIMEOUT,
     ) -> None:
-        InfiniteQueueLooper.__init__(  # InfiniteQueueLooper first
-            self, queue_type=queue_type
-        )
+        InfiniteQueueLooper.__init__(self)  # InfiniteQueueLooper first
         InfiniteQueueLooper.__post_init__(self)
-        Handler.__init__(self, level=level)
+        Handler.__init__(self, level=level)  # Handler next
         self.url = url
         self.sender = sender
         self.timeout = timeout
@@ -65,14 +61,14 @@ class SlackHandler(Handler, InfiniteQueueLooper[None, str]):
     @override
     def emit(self, record: LogRecord) -> None:
         try:
-            self.put_items_nowait(self.format(record))
+            self.put_right_nowait(self.format(record))
         except Exception:  # noqa: BLE001  # pragma: no cover
             self.handleError(record)
 
     @override
-    async def _process_items(self, *items: str) -> None:
-        """Process the first item."""
-        text = "\n".join(items)
+    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)