dycw-utilities 0.125.24__tar.gz → 0.125.25__tar.gz

{dycw_utilities-0.125.24 → dycw_utilities-0.125.25}/PKG-INFO

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

{dycw_utilities-0.125.24 → dycw_utilities-0.125.25}/pyproject.toml

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

{dycw_utilities-0.125.24 → dycw_utilities-0.125.25}/src/tests/test_asyncio.py

@@ -1381,25 +1381,27 @@ class TestLooper:
         stats = looper.stats
         assert stats.entries == entries
         assert stats.core_attempts == (stats.core_successes + stats.core_failures)
-        assert stats.core_successes == approx(core_successes, rel=0.5)
-        assert stats.core_failures == approx(core_failures, rel=0.5)
+        assert stats.core_successes == approx(core_successes, rel=0.75)
+        assert stats.core_failures == approx(core_failures, rel=0.75)
         assert stats.initialization_attempts == (
             stats.initialization_successes + stats.initialization_failures
         )
         assert stats.initialization_successes == approx(
-            initialization_successes, rel=0.5
+            initialization_successes, rel=0.75
+        )
+        assert stats.initialization_failures == approx(
+            initialization_failures, rel=0.75
         )
-        assert stats.initialization_failures == approx(initialization_failures, rel=0.5)
         assert stats.tear_down_attempts == (
             stats.tear_down_successes + stats.tear_down_failures
         )
-        assert stats.tear_down_successes == approx(tear_down_successes, rel=0.5)
-        assert stats.tear_down_failures == approx(tear_down_failures, rel=0.5)
+        assert stats.tear_down_successes == approx(tear_down_successes, rel=0.75)
+        assert stats.tear_down_failures == approx(tear_down_failures, rel=0.75)
         assert stats.restart_attempts == (
             stats.restart_successes + stats.restart_failures
         )
-        assert stats.restart_successes == approx(restart_successes, rel=0.5)
-        assert stats.restart_failures == approx(restart_failures, rel=0.5)
+        assert stats.restart_successes == approx(restart_successes, rel=0.75)
+        assert stats.restart_failures == approx(restart_failures, rel=0.75)
         assert stats.stops == stops
 
 

{dycw_utilities-0.125.24 → dycw_utilities-0.125.25}/src/tests/test_slack_sdk.py

@@ -5,13 +5,18 @@ from logging import getLogger
 from typing import TYPE_CHECKING
 
 from aiohttp import InvalidUrlClientError
-from pytest import mark, raises
+from pytest import mark, param, raises
 from slack_sdk.webhook.async_client import AsyncWebhookClient
 
 from utilities.datetime import MINUTE
 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,
+    SlackHandlerService,
+    _get_client,
+    send_to_slack,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -64,3 +69,42 @@ class TestSlackHandler:
                 logger.warning(
                     "message %d from %s", i, TestSlackHandler.test_real.__qualname__
                 )
+
+    # service
+
+    @mark.parametrize("auto_start", [param(True), param(False)])
+    async def test_main_service(self, *, tmp_path: Path, auto_start: bool) -> None:
+        messages: Sequence[str] = []
+
+        async def sender(_: str, text: str, /) -> None:
+            messages.append(text)
+
+        logger = getLogger(str(tmp_path))
+        logger.addHandler(
+            handler := SlackHandlerService(
+                auto_start=auto_start, url="url", freq=0.05, sender=sender, timeout=1.0
+            )
+        )
+        async with handler:
+            logger.warning("message")
+        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_service(self, *, tmp_path: Path) -> None:
+        url = get_env_var("SLACK")
+        logger = getLogger(str(tmp_path))
+        logger.addHandler(handler := SlackHandlerService(url=url, freq=0.05))
+        async with timeout(1.0), handler:
+            for i in range(10):
+                logger.warning(
+                    "message %d from %s",
+                    i,
+                    TestSlackHandler.test_real_service.__qualname__,
+                )
+
+    async def test_replace(self) -> None:
+        handler = SlackHandlerService(url="url")
+        new = handler.replace(freq=10.0)
+        assert new.url == handler.url
+        assert new.freq == 10.0

{dycw_utilities-0.125.24 → dycw_utilities-0.125.25}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.125.24"
+__version__ = "0.125.25"

{dycw_utilities-0.125.24 → dycw_utilities-0.125.25}/src/utilities/asyncio.py

@@ -901,6 +901,7 @@ class Looper(Generic[_T]):
         timeout: Duration | None | Sentinel = sentinel,
         timeout_error: type[Exception] | Sentinel = sentinel,
         _debug: bool | Sentinel = sentinel,
+        **kwargs: Any,
     ) -> Self:
         """Replace elements of the looper."""
         return replace_non_sentinel(
@@ -913,6 +914,7 @@ class Looper(Generic[_T]):
             timeout=timeout,
             timeout_error=timeout_error,
             _debug=_debug,
+            **kwargs,
         )
 
     def request_restart(self) -> None:

{dycw_utilities-0.125.24 → dycw_utilities-0.125.25}/src/utilities/slack_sdk.py

@@ -3,14 +3,20 @@ from __future__ import annotations
 from dataclasses import dataclass
 from http import HTTPStatus
 from logging import NOTSET, Handler, LogRecord
-from typing import TYPE_CHECKING, override
+from typing import TYPE_CHECKING, Any, Self, override
 
 from slack_sdk.webhook.async_client import AsyncWebhookClient
 
-from utilities.asyncio import InfiniteQueueLooper, timeout_dur
+from utilities.asyncio import (
+    InfiniteQueueLooper,
+    Looper,
+    LooperTimeoutError,
+    timeout_dur,
+)
 from utilities.datetime import MINUTE, SECOND, datetime_duration_to_float
 from utilities.functools import cache
 from utilities.math import safe_round
+from utilities.sentinel import Sentinel, sentinel
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -73,6 +79,90 @@ class SlackHandler(Handler, InfiniteQueueLooper[None, str]):
             await self.sender(self.url, text)
 
 
+@dataclass(init=False, unsafe_hash=True)
+class SlackHandlerService(Handler, Looper[str]):
+    """Service to send messages to Slack."""
+
+    @override
+    def __init__(
+        self,
+        *,
+        url: str,
+        auto_start: bool = False,
+        empty_upon_exit: bool = True,
+        freq: Duration = SECOND,
+        backoff: Duration = SECOND,
+        logger: str | None = None,
+        timeout: Duration | None = None,
+        timeout_error: type[Exception] = LooperTimeoutError,
+        _debug: bool = False,
+        level: int = NOTSET,
+        sender: Callable[[str, str], Coroutine1[None]] = _send_adapter,
+        send_timeout: Duration = SECOND,
+    ) -> None:
+        Looper.__init__(  # Looper first
+            self,
+            auto_start=auto_start,
+            freq=freq,
+            empty_upon_exit=empty_upon_exit,
+            backoff=backoff,
+            logger=logger,
+            timeout=timeout,
+            timeout_error=timeout_error,
+            _debug=_debug,
+        )
+        Looper.__post_init__(self)
+        Handler.__init__(self, level=level)  # Handler next
+        self.url = url
+        self.sender = sender
+        self.send_timeout = send_timeout
+
+    @override
+    def emit(self, record: LogRecord) -> None:
+        fmtted = self.format(record)
+        try:
+            self.put_right_nowait(fmtted)
+        except Exception:  # noqa: BLE001  # pragma: no cover
+            self.handleError(record)
+
+    @override
+    async def core(self) -> None:
+        await super().core()
+        if self.empty():
+            return
+        text = "\n".join(self.get_all_nowait())
+        async with timeout_dur(duration=self.send_timeout):
+            await self.sender(self.url, text)
+
+    @override
+    def replace(
+        self,
+        *,
+        auto_start: bool | Sentinel = sentinel,
+        empty_upon_exit: bool | Sentinel = sentinel,
+        freq: Duration | Sentinel = sentinel,
+        backoff: Duration | Sentinel = sentinel,
+        logger: str | None | Sentinel = sentinel,
+        timeout: Duration | None | Sentinel = sentinel,
+        timeout_error: type[Exception] | Sentinel = sentinel,
+        _debug: bool | Sentinel = sentinel,
+        **kwargs: Any,
+    ) -> Self:
+        """Replace elements of the looper."""
+        return super().replace(
+            url=self.url,
+            auto_start=auto_start,
+            empty_upon_exit=empty_upon_exit,
+            freq=freq,
+            backoff=backoff,
+            logger=logger,
+            timeout=timeout,
+            timeout_error=timeout_error,
+            _debug=_debug,
+            **kwargs,
+        )
+
+
 ##
 
 
@@ -106,4 +196,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", "SlackHandlerService", "send_to_slack"]