dycw-utilities 0.114.3__tar.gz → 0.114.4__tar.gz

{dycw_utilities-0.114.3 → dycw_utilities-0.114.4}/PKG-INFO

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

{dycw_utilities-0.114.3 → dycw_utilities-0.114.4}/pyproject.toml

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

{dycw_utilities-0.114.3 → dycw_utilities-0.114.4}/src/tests/test_asyncio.py

@@ -375,6 +375,30 @@ class TestInfiniteLooper:
                 with raises(FalseError):
                     _ = await looper()
 
+    async def test_hashable(self) -> None:
+        class CustomError(BaseException): ...
+
+        @dataclass(kw_only=True, unsafe_hash=True)
+        class Example(InfiniteLooper[None]):
+            counter: int = 0
+
+            @override
+            async def _initialize(self) -> None:
+                self.counter = 0
+
+            @override
+            async def _core(self) -> None:
+                self.counter += 1
+
+            @override
+            def _yield_events_and_exceptions(
+                self,
+            ) -> Iterator[tuple[bool, MaybeType[BaseException]]]:
+                yield (None, CustomError)
+
+        looper = Example(sleep_core=0.1)
+        _ = hash(looper)
+
     async def test_multiple(self) -> None:
         class ChildError(BaseException): ...
 

{dycw_utilities-0.114.3 → dycw_utilities-0.114.4}/src/tests/test_slack_sdk.py

@@ -9,11 +9,17 @@ from aiohttp import InvalidUrlClientError
 from pytest import mark, raises
 from slack_sdk.webhook.async_client import AsyncWebhookClient
 
+from utilities.asyncio import EnhancedTaskGroup, sleep_dur
 from utilities.datetime import MINUTE
 from utilities.iterables import one
 from utilities.os import get_env_var
 from utilities.pytest import throttle
-from utilities.slack_sdk import SlackHandler, _get_client, send_to_slack
+from utilities.slack_sdk import (
+    SlackHandler,
+    SlackHandlerIQL,
+    _get_client,
+    send_to_slack,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -138,3 +144,45 @@ class TestSlackHandler:
                     "message %d from %s", i, TestSlackHandler.test_real.__qualname__
                 )
         await sleep(0.1)
+
+
+class TestSlackHandlerIQL:
+    async def test_main(self, *, tmp_path: Path) -> None:
+        messages: Sequence[str] = []
+
+        async def sender(_: str, text: str, /) -> None:
+            await sleep(0.01)
+            messages.append(text)
+
+        logger = getLogger(str(tmp_path))
+        logger.addHandler(handler := SlackHandlerIQL("url", sender=sender))
+
+        async def sleep_then_log() -> None:
+            await sleep_dur(duration=0.1)
+            logger.warning("message")
+
+        with raises(ExceptionGroup):  # noqa: PT012
+            async with EnhancedTaskGroup(timeout=0.5) as tg:
+                _ = tg.create_task(handler())
+                _ = tg.create_task(sleep_then_log())
+
+        assert messages == ["message"]
+
+    @mark.skipif(get_env_var("SLACK", nullable=True) is None, reason="'SLACK' not set")
+    @throttle(duration=5 * MINUTE)
+    async def test_real(self, *, tmp_path: Path) -> None:
+        url = get_env_var("SLACK")
+        logger = getLogger(str(tmp_path))
+        logger.addHandler(handler := SlackHandlerIQL(url))
+
+        async def sleep_then_log() -> None:
+            await sleep_dur(duration=0.1)
+            for i in range(10):
+                logger.warning(
+                    "message %d from %s", i, TestSlackHandlerIQL.test_real.__qualname__
+                )
+
+        with raises(ExceptionGroup):  # noqa: PT012
+            async with EnhancedTaskGroup(timeout=0.5) as tg:
+                _ = tg.create_task(handler())
+                _ = tg.create_task(sleep_then_log())

{dycw_utilities-0.114.3 → dycw_utilities-0.114.4}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.114.3"
+__version__ = "0.114.4"

{dycw_utilities-0.114.3 → dycw_utilities-0.114.4}/src/utilities/asyncio.py

@@ -326,7 +326,7 @@ class ExceptionProcessor(QueueProcessor[Exception | type[Exception]]):
 ##
 
 
-@dataclass(kw_only=True)
+@dataclass(kw_only=True, unsafe_hash=True)
 class InfiniteLooper(ABC, Generic[THashable]):
     """An infinite loop which can throw exceptions by setting events."""
 
@@ -334,7 +334,7 @@ class InfiniteLooper(ABC, Generic[THashable]):
     sleep_restart: Duration = MINUTE
     logger: str | None = None
     _events: Mapping[THashable, Event] = field(
-        default_factory=dict, init=False, repr=False
+        default_factory=dict, init=False, repr=False, hash=False
     )
 
     def __post_init__(self) -> None:

{dycw_utilities-0.114.3 → dycw_utilities-0.114.4}/src/utilities/slack_sdk.py

@@ -9,7 +9,12 @@ from typing import TYPE_CHECKING, override
 
 from slack_sdk.webhook.async_client import AsyncWebhookClient
 
-from utilities.asyncio import QueueProcessor, sleep_dur, timeout_dur
+from utilities.asyncio import (
+    InfiniteQueueLooper,
+    QueueProcessor,
+    sleep_dur,
+    timeout_dur,
+)
 from utilities.datetime import MINUTE, SECOND, datetime_duration_to_float
 from utilities.functools import cache
 from utilities.math import safe_round
@@ -95,6 +100,49 @@ class SlackHandler(Handler, QueueProcessor[str]):
             await sleep_dur(duration=self.sleep)
 
 
+@dataclass(init=False, unsafe_hash=True)
+class SlackHandlerIQL(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,
+        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.__post_init__(self)
+        Handler.__init__(self, level=level)
+        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_items_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 with timeout_dur(duration=self.timeout):
+            await self.sender(self.url, text)
+
+
 ##
 
 
@@ -128,4 +176,4 @@ def _get_client(url: str, /, *, timeout: Duration = _TIMEOUT) -> AsyncWebhookCli
     return AsyncWebhookClient(url, timeout=timeout_use)
 
 
-__all__ = ["SendToSlackError", "SlackHandler", "send_to_slack"]
+__all__ = ["SendToSlackError", "SlackHandler", "SlackHandlerIQL", "send_to_slack"]