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

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

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

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

@@ -94,7 +94,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.125.24"
+version = "0.125.26"
 
 [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.26"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

{dycw_utilities-0.125.24 → dycw_utilities-0.125.26}/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.26}/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.26}/src/tests/test_sqlalchemy.py

@@ -45,6 +45,7 @@ from utilities.sqlalchemy import (
     Upserter,
     UpserterError,
     UpsertItemsError,
+    UpsertService,
     _get_dialect,
     _get_dialect_max_params,
     _InsertItem,
@@ -1183,6 +1184,35 @@ class TestUpserter:
         with raises(UpserterError, match="Error running 'Upserter'"):
             raise UpserterError(upserter=upserter)
 
+    # service
+
+    @given(
+        data=data(),
+        name=_table_names(),
+        triples=_upsert_lists(nullable=True, min_size=1),
+    )
+    @mark.flaky
+    @settings(max_examples=1, phases={Phase.generate})
+    async def test_main_service(
+        self, *, data: DataObject, name: str, triples: list[tuple[int, bool, bool]]
+    ) -> None:
+        table = Table(
+            name,
+            MetaData(),
+            Column("id_", Integer, primary_key=True),
+            Column("value", Boolean, nullable=True),
+        )
+        engine = await sqlalchemy_engines(data, table)
+        service = UpsertService(freq=0.1, timeout=1.0, engine=engine)
+        pairs = [(id_, init) for id_, init, _ in triples]
+        async with service:
+            service.put_right_nowait((pairs, table))
+
+        sel = select(table)
+        async with engine.begin() as conn:
+            res = (await conn.execute(sel)).all()
+        assert set(res) == set(pairs)
+
 
 class TestUpsertItems:
     @given(data=data(), name=_table_names(), triple=_upsert_triples(nullable=True))

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

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

{dycw_utilities-0.125.24 → dycw_utilities-0.125.26}/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.26}/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"]

{dycw_utilities-0.125.24 → dycw_utilities-0.125.26}/src/utilities/sqlalchemy.py

@@ -57,7 +57,8 @@ from sqlalchemy.orm import (
 from sqlalchemy.orm.exc import UnmappedClassError
 from sqlalchemy.pool import NullPool, Pool
 
-from utilities.asyncio import InfiniteQueueLooper, timeout_dur
+from utilities.asyncio import InfiniteQueueLooper, Looper, timeout_dur
+from utilities.datetime import SECOND
 from utilities.functions import (
     ensure_str,
     get_class_name,
@@ -654,6 +655,42 @@ class UpserterError(Exception):
         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."""
+
+    # base
+    freq: Duration = field(default=SECOND, repr=False)
+    backoff: Duration = field(default=SECOND, repr=False)
+    empty_upon_exit: bool = field(default=True, repr=False)
+    # self
+    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 core(self) -> None:
+        await super().core()
+        await upsert_items(
+            self.engine,
+            *self.get_all_nowait(),
+            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,
+        )
+
+
 ##
 
 
@@ -1109,6 +1146,7 @@ __all__ = [
     "InsertItemsError",
     "TablenameMixin",
     "UpsertItemsError",
+    "UpsertService",
     "Upserter",
     "UpserterError",
     "check_engine",