dycw-utilities 0.131.16__py3-none-any.whl → 0.131.17__py3-none-any.whl

utilities/slack_sdk.py

@@ -7,21 +7,21 @@ from typing import TYPE_CHECKING, Any, Self, override
 
 from slack_sdk.webhook.async_client import AsyncWebhookClient
 
-from utilities.asyncio import Looper, timeout_dur
-from utilities.datetime import MINUTE, SECOND, datetime_duration_to_float
+from utilities.asyncio import Looper, timeout_td
 from utilities.functools import cache
-from utilities.math import safe_round
 from utilities.sentinel import Sentinel, sentinel
+from utilities.whenever2 import MINUTE, SECOND
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
     from slack_sdk.webhook import WebhookResponse
+    from whenever import TimeDelta
 
-    from utilities.types import Coroutine1, Duration
+    from utilities.types import Coroutine1
 
 
-_TIMEOUT: Duration = MINUTE
+_TIMEOUT: TimeDelta = MINUTE
 
 
 ##
@@ -42,14 +42,14 @@ class SlackHandlerService(Handler, Looper[str]):
         url: str,
         auto_start: bool = False,
         empty_upon_exit: bool = True,
-        freq: Duration = SECOND,
-        backoff: Duration = SECOND,
+        freq: TimeDelta = SECOND,
+        backoff: TimeDelta = SECOND,
         logger: str | None = None,
-        timeout: Duration | None = None,
+        timeout: TimeDelta | None = None,
         _debug: bool = False,
         level: int = NOTSET,
         sender: Callable[[str, str], Coroutine1[None]] = _send_adapter,
-        send_timeout: Duration = SECOND,
+        send_timeout: TimeDelta = SECOND,
     ) -> None:
         Looper.__init__(  # Looper first
             self,
@@ -81,7 +81,7 @@ class SlackHandlerService(Handler, Looper[str]):
         if self.empty():
             return
         text = "\n".join(self.get_all_nowait())
-        async with timeout_dur(duration=self.send_timeout):
+        async with timeout_td(self.send_timeout):
             await self.sender(self.url, text)
 
     @override
@@ -90,10 +90,10 @@ class SlackHandlerService(Handler, Looper[str]):
         *,
         auto_start: bool | Sentinel = sentinel,
         empty_upon_exit: bool | Sentinel = sentinel,
-        freq: Duration | Sentinel = sentinel,
-        backoff: Duration | Sentinel = sentinel,
+        freq: TimeDelta | Sentinel = sentinel,
+        backoff: TimeDelta | Sentinel = sentinel,
         logger: str | None | Sentinel = sentinel,
-        timeout: Duration | None | Sentinel = sentinel,
+        timeout: TimeDelta | None | Sentinel = sentinel,
         _debug: bool | Sentinel = sentinel,
         **kwargs: Any,
     ) -> Self:
@@ -115,11 +115,11 @@ class SlackHandlerService(Handler, Looper[str]):
 
 
 async def send_to_slack(
-    url: str, text: str, /, *, timeout: Duration = _TIMEOUT
+    url: str, text: str, /, *, timeout: TimeDelta = _TIMEOUT
 ) -> None:
     """Send a message via Slack."""
     client = _get_client(url, timeout=timeout)
-    async with timeout_dur(duration=timeout):
+    async with timeout_td(timeout):
         response = await client.send(text=text)
     if response.status_code != HTTPStatus.OK:  # pragma: no cover
         raise SendToSlackError(text=text, response=response)
@@ -138,10 +138,9 @@ class SendToSlackError(Exception):
 
 
 @cache
-def _get_client(url: str, /, *, timeout: Duration = _TIMEOUT) -> AsyncWebhookClient:
+def _get_client(url: str, /, *, timeout: TimeDelta = _TIMEOUT) -> AsyncWebhookClient:
     """Get the Slack client."""
-    timeout_use = safe_round(datetime_duration_to_float(timeout))
-    return AsyncWebhookClient(url, timeout=timeout_use)
+    return AsyncWebhookClient(url, timeout=round(timeout.in_seconds()))
 
 
 __all__ = ["SendToSlackError", "SlackHandlerService", "send_to_slack"]

utilities/sqlalchemy.py

@@ -18,7 +18,16 @@ from itertools import chain
 from math import floor
 from operator import ge, le
 from re import search
-from typing import Any, Literal, TypeGuard, TypeVar, assert_never, cast, override
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    TypeGuard,
+    TypeVar,
+    assert_never,
+    cast,
+    override,
+)
 
 from sqlalchemy import (
     URL,
@@ -57,9 +66,8 @@ from sqlalchemy.orm import (
 from sqlalchemy.orm.exc import UnmappedClassError
 from sqlalchemy.pool import NullPool, Pool
 
-from utilities.asyncio import Looper, timeout_dur
+from utilities.asyncio import Looper, timeout_td
 from utilities.contextlib import suppress_super_object_attribute_error
-from utilities.datetime import SECOND
 from utilities.functions import (
     ensure_str,
     get_class_name,
@@ -82,13 +90,11 @@ from utilities.iterables import (
 )
 from utilities.reprlib import get_repr
 from utilities.text import snake_case
-from utilities.types import (
-    Duration,
-    MaybeIterable,
-    MaybeType,
-    StrMapping,
-    TupleOrStrMapping,
-)
+from utilities.types import MaybeIterable, MaybeType, StrMapping, TupleOrStrMapping
+from utilities.whenever2 import SECOND
+
+if TYPE_CHECKING:
+    from whenever import TimeDelta
 
 _T = TypeVar("_T")
 type _EngineOrConnectionOrAsync = Engine | Connection | AsyncEngine | AsyncConnection
@@ -105,7 +111,7 @@ async def check_engine(
     engine: AsyncEngine,
     /,
     *,
-    timeout: Duration | None = None,
+    timeout: TimeDelta | None = None,
     error: type[Exception] = TimeoutError,
     num_tables: int | tuple[int, float] | None = None,
 ) -> None:
@@ -229,7 +235,7 @@ async def ensure_tables_created(
     engine: AsyncEngine,
     /,
     *tables_or_orms: TableOrORMInstOrClass,
-    timeout: Duration | None = None,
+    timeout: TimeDelta | None = None,
     error: type[Exception] = TimeoutError,
 ) -> None:
     """Ensure a table/set of tables is/are created."""
@@ -258,7 +264,7 @@ async def ensure_tables_created(
 async def ensure_tables_dropped(
     engine: AsyncEngine,
     *tables_or_orms: TableOrORMInstOrClass,
-    timeout: Duration | None = None,
+    timeout: TimeDelta | None = None,
     error: type[Exception] = TimeoutError,
 ) -> None:
     """Ensure a table/set of tables is/are dropped."""
@@ -384,9 +390,9 @@ async def insert_items(
     snake: bool = False,
     chunk_size_frac: float = CHUNK_SIZE_FRAC,
     assume_tables_exist: bool = False,
-    timeout_create: Duration | None = None,
+    timeout_create: TimeDelta | None = None,
     error_create: type[Exception] = TimeoutError,
-    timeout_insert: Duration | None = None,
+    timeout_insert: TimeDelta | None = None,
     error_insert: type[Exception] = TimeoutError,
 ) -> None:
     """Insert a set of items into a database.
@@ -485,9 +491,9 @@ async def migrate_data(
     table_or_orm_to: TableOrORMInstOrClass | None = None,
     chunk_size_frac: float = CHUNK_SIZE_FRAC,
     assume_tables_exist: bool = False,
-    timeout_create: Duration | None = None,
+    timeout_create: TimeDelta | None = None,
     error_create: type[Exception] = TimeoutError,
-    timeout_insert: Duration | None = None,
+    timeout_insert: TimeDelta | None = None,
     error_insert: type[Exception] = TimeoutError,
 ) -> None:
     """Migrate the contents of a table from one database to another."""
@@ -615,8 +621,8 @@ 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)
+    freq: TimeDelta = field(default=SECOND, repr=False)
+    backoff: TimeDelta = field(default=SECOND, repr=False)
     empty_upon_exit: bool = field(default=True, repr=False)
     # self
     engine: AsyncEngine
@@ -624,9 +630,9 @@ class UpsertService(Looper[_InsertItem]):
     selected_or_all: _SelectedOrAll = "selected"
     chunk_size_frac: float = CHUNK_SIZE_FRAC
     assume_tables_exist: bool = False
-    timeout_create: Duration | None = None
+    timeout_create: TimeDelta | None = None
     error_create: type[Exception] = TimeoutError
-    timeout_insert: Duration | None = None
+    timeout_insert: TimeDelta | None = None
     error_insert: type[Exception] = TimeoutError
 
     @override
@@ -651,11 +657,11 @@ class UpsertServiceMixin:
     """Mix-in for the upsert service."""
 
     # base - looper
-    upsert_service_freq: Duration = field(default=SECOND, repr=False)
-    upsert_service_backoff: Duration = field(default=SECOND, repr=False)
+    upsert_service_freq: TimeDelta = field(default=SECOND, repr=False)
+    upsert_service_backoff: TimeDelta = field(default=SECOND, repr=False)
     upsert_service_empty_upon_exit: bool = field(default=False, repr=False)
     upsert_service_logger: str | None = field(default=None, repr=False)
-    upsert_service_timeout: Duration | None = field(default=None, repr=False)
+    upsert_service_timeout: TimeDelta | None = field(default=None, repr=False)
     upsert_service_debug: bool = field(default=False, repr=False)
     # base - upsert service
     upsert_service_database: AsyncEngine
@@ -663,9 +669,9 @@ class UpsertServiceMixin:
     upsert_service_selected_or_all: _SelectedOrAll = "selected"
     upsert_service_chunk_size_frac: float = CHUNK_SIZE_FRAC
     upsert_service_assume_tables_exist: bool = False
-    upsert_service_timeout_create: Duration | None = None
+    upsert_service_timeout_create: TimeDelta | None = None
     upsert_service_error_create: type[Exception] = TimeoutError
-    upsert_service_timeout_insert: Duration | None = None
+    upsert_service_timeout_insert: TimeDelta | None = None
     upsert_service_error_insert: type[Exception] = TimeoutError
     # self
     _upsert_service: UpsertService = field(init=False, repr=False)
@@ -713,9 +719,9 @@ async def upsert_items(
     selected_or_all: _SelectedOrAll = "selected",
     chunk_size_frac: float = CHUNK_SIZE_FRAC,
     assume_tables_exist: bool = False,
-    timeout_create: Duration | None = None,
+    timeout_create: TimeDelta | None = None,
     error_create: type[Exception] = TimeoutError,
-    timeout_insert: Duration | None = None,
+    timeout_insert: TimeDelta | None = None,
     error_insert: type[Exception] = TimeoutError,
 ) -> None:
     """Upsert a set of items into a database.
@@ -835,11 +841,11 @@ async def yield_connection(
     engine: AsyncEngine,
     /,
     *,
-    timeout: Duration | None = None,
+    timeout: TimeDelta | None = None,
     error: MaybeType[BaseException] = TimeoutError,
 ) -> AsyncIterator[AsyncConnection]:
     """Yield an async connection."""
-    async with timeout_dur(duration=timeout, error=error), engine.begin() as conn:
+    async with timeout_td(timeout, error=error), engine.begin() as conn:
         yield conn
 
 

utilities/sqlalchemy_polars.py

@@ -26,7 +26,7 @@ from polars import (
 from sqlalchemy import Column, Select, select
 from sqlalchemy.exc import DuplicateColumnError
 
-from utilities.asyncio import timeout_dur
+from utilities.asyncio import timeout_td
 from utilities.functions import identity
 from utilities.iterables import (
     CheckDuplicatesError,
@@ -63,11 +63,8 @@ if TYPE_CHECKING:
     from sqlalchemy.ext.asyncio import AsyncEngine
     from sqlalchemy.sql import ColumnCollection
     from sqlalchemy.sql.base import ReadOnlyColumnCollection
-    from tenacity.retry import RetryBaseT
-    from tenacity.stop import StopBaseT
-    from tenacity.wait import WaitBaseT
+    from whenever import TimeDelta
 
-    import utilities.types
     from utilities.types import MaybeType, TimeZoneLike
 
 
@@ -81,9 +78,9 @@ async def insert_dataframe(
     chunk_size_frac: float = CHUNK_SIZE_FRAC,
     assume_tables_exist: bool = False,
     upsert: Literal["selected", "all"] | None = None,
-    timeout_create: utilities.types.Duration | None = None,
+    timeout_create: TimeDelta | None = None,
     error_create: type[Exception] = TimeoutError,
-    timeout_insert: utilities.types.Duration | None = None,
+    timeout_insert: TimeDelta | None = None,
     error_insert: type[Exception] = TimeoutError,
 ) -> None:
     """Insert/upsert a DataFrame into a database."""
@@ -231,10 +228,7 @@ async def select_to_dataframe(
     in_clauses: tuple[Column[Any], Iterable[Any]] | None = None,
     in_clauses_chunk_size: int | None = None,
     chunk_size_frac: float = CHUNK_SIZE_FRAC,
-    stop: StopBaseT | None = None,
-    wait: WaitBaseT | None = None,
-    retry: RetryBaseT | None = None,
-    timeout: utilities.types.Duration | None = None,
+    timeout: TimeDelta | None = None,
     **kwargs: Any,
 ) -> DataFrame: ...
 @overload
@@ -249,10 +243,7 @@ async def select_to_dataframe(
     in_clauses: None = None,
     in_clauses_chunk_size: int | None = None,
     chunk_size_frac: float = CHUNK_SIZE_FRAC,
-    stop: StopBaseT | None = None,
-    wait: WaitBaseT | None = None,
-    retry: RetryBaseT | None = None,
-    timeout: utilities.types.Duration | None = None,
+    timeout: TimeDelta | None = None,
     **kwargs: Any,
 ) -> Iterable[DataFrame]: ...
 @overload
@@ -267,10 +258,7 @@ async def select_to_dataframe(
     in_clauses: tuple[Column[Any], Iterable[Any]],
     in_clauses_chunk_size: int | None = None,
     chunk_size_frac: float = CHUNK_SIZE_FRAC,
-    stop: StopBaseT | None = None,
-    wait: WaitBaseT | None = None,
-    retry: RetryBaseT | None = None,
-    timeout: utilities.types.Duration | None = None,
+    timeout: TimeDelta | None = None,
     **kwargs: Any,
 ) -> AsyncIterable[DataFrame]: ...
 @overload
@@ -285,10 +273,7 @@ async def select_to_dataframe(
     in_clauses: tuple[Column[Any], Iterable[Any]] | None = None,
     in_clauses_chunk_size: int | None = None,
     chunk_size_frac: float = CHUNK_SIZE_FRAC,
-    stop: StopBaseT | None = None,
-    wait: WaitBaseT | None = None,
-    retry: RetryBaseT | None = None,
-    timeout: utilities.types.Duration | None = None,
+    timeout: TimeDelta | None = None,
     **kwargs: Any,
 ) -> DataFrame | Iterable[DataFrame] | AsyncIterable[DataFrame]: ...
 async def select_to_dataframe(
@@ -302,7 +287,7 @@ async def select_to_dataframe(
     in_clauses: tuple[Column[Any], Iterable[Any]] | None = None,
     in_clauses_chunk_size: int | None = None,
     chunk_size_frac: float = CHUNK_SIZE_FRAC,
-    timeout: utilities.types.Duration | None = None,
+    timeout: TimeDelta | None = None,
     error: MaybeType[BaseException] = TimeoutError,
     **kwargs: Any,
 ) -> DataFrame | Iterable[DataFrame] | AsyncIterable[DataFrame]:
@@ -311,7 +296,7 @@ async def select_to_dataframe(
         sel = _select_to_dataframe_apply_snake(sel)
     schema = _select_to_dataframe_map_select_to_df_schema(sel, time_zone=time_zone)
     if in_clauses is None:
-        async with timeout_dur(duration=timeout, error=error):
+        async with timeout_td(timeout, error=error):
             return read_database(
                 sel,
                 cast("Any", engine),
@@ -328,7 +313,7 @@ async def select_to_dataframe(
         chunk_size_frac=chunk_size_frac,
     )
     if batch_size is None:
-        async with timeout_dur(duration=timeout, error=error):
+        async with timeout_td(timeout, error=error):
             dfs = [
                 await select_to_dataframe(
                     sel,
@@ -349,7 +334,7 @@ async def select_to_dataframe(
             return DataFrame(schema=schema)
 
     async def yield_dfs() -> AsyncIterator[DataFrame]:
-        async with timeout_dur(duration=timeout, error=error):
+        async with timeout_td(timeout, error=error):
             for sel_i in sels:
                 for df in await select_to_dataframe(
                     sel_i,

utilities/tenacity.py

@@ -1,145 +0,0 @@
-from __future__ import annotations
-
-from contextlib import AbstractAsyncContextManager, asynccontextmanager
-from typing import TYPE_CHECKING, Any, override
-
-from tenacity import (
-    AsyncRetrying,
-    AttemptManager,
-    RetryCallState,
-    RetryError,
-    after_nothing,
-    before_nothing,
-    retry_if_exception_type,
-    stop_never,
-    wait_none,
-)
-from tenacity import wait_exponential_jitter as _wait_exponential_jitter
-from tenacity._utils import MAX_WAIT
-from tenacity.asyncio import _portable_async_sleep
-
-from utilities.asyncio import timeout_dur
-from utilities.contextlib import NoOpContextManager
-from utilities.datetime import datetime_duration_to_float
-
-if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Callable
-
-    from tenacity.retry import RetryBaseT
-    from tenacity.stop import StopBaseT
-    from tenacity.wait import WaitBaseT
-
-    from utilities.types import Duration, MaybeAwaitable
-
-
-type MaybeAttemptManager = NoOpContextManager | AttemptManager
-type MaybeAttemptContextManager = AbstractAsyncContextManager[MaybeAttemptManager]
-
-
-class wait_exponential_jitter(_wait_exponential_jitter):  # noqa: N801
-    """Subclass of `wait_exponential_jitter` accepting durations."""
-
-    @override
-    def __init__(
-        self,
-        initial: Duration = 1,
-        max: Duration = MAX_WAIT,
-        exp_base: float = 2,
-        jitter: Duration = 1,
-    ) -> None:
-        super().__init__(
-            initial=datetime_duration_to_float(initial),
-            max=datetime_duration_to_float(max),
-            exp_base=exp_base,
-            jitter=datetime_duration_to_float(jitter),
-        )
-
-
-async def yield_attempts(
-    *,
-    sleep: Callable[[int | float], MaybeAwaitable[None]] | None = None,
-    stop: StopBaseT | None = None,
-    wait: WaitBaseT | None = None,
-    retry: RetryBaseT | None = None,
-    before: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    after: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    before_sleep: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    reraise: bool | None = None,
-    retry_error_cls: type[RetryError] | None = None,
-    retry_error_callback: Callable[[RetryCallState], MaybeAwaitable[Any]] | None = None,
-) -> AsyncIterator[MaybeAttemptManager]:
-    """Yield the attempts."""
-    if (
-        (sleep is None)
-        and (stop is None)
-        and (wait is None)
-        and (retry is None)
-        and (before is None)
-        and (after is None)
-        and (before_sleep is None)
-        and (reraise is None)
-        and (retry_error_cls is None)
-    ):
-        yield NoOpContextManager()
-    else:
-        retrying = AsyncRetrying(
-            sleep=_portable_async_sleep if sleep is None else sleep,
-            stop=stop_never if stop is None else stop,
-            wait=wait_none() if wait is None else wait,
-            retry=retry_if_exception_type() if retry is None else retry,
-            before=before_nothing if before is None else before,
-            after=after_nothing if after is None else after,
-            before_sleep=None if before_sleep is None else before_sleep,
-            reraise=False if reraise is None else reraise,
-            retry_error_cls=RetryError if retry_error_cls is None else retry_error_cls,
-            retry_error_callback=retry_error_callback,
-        )
-        async for attempt in retrying:
-            yield attempt
-
-
-async def yield_timeout_attempts(
-    *,
-    sleep: Callable[[int | float], MaybeAwaitable[None]] | None = None,
-    stop: StopBaseT | None = None,
-    wait: WaitBaseT | None = None,
-    retry: RetryBaseT | None = None,
-    before: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    after: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    before_sleep: Callable[[RetryCallState], MaybeAwaitable[None]] | None = None,
-    reraise: bool | None = None,
-    retry_error_cls: type[RetryError] | None = None,
-    retry_error_callback: Callable[[RetryCallState], MaybeAwaitable[Any]] | None = None,
-    timeout: Duration | None = None,
-) -> AsyncIterator[MaybeAttemptContextManager]:
-    """Yield the attempts, with timeout."""
-    async for attempt in yield_attempts(
-        sleep=sleep,
-        stop=stop,
-        wait=wait,
-        retry=retry,
-        before=before,
-        after=after,
-        before_sleep=before_sleep,
-        reraise=reraise,
-        retry_error_cls=retry_error_cls,
-        retry_error_callback=retry_error_callback,
-    ):
-
-        @asynccontextmanager
-        async def new(
-            attempt: MaybeAttemptManager, /
-        ) -> AsyncIterator[MaybeAttemptManager]:
-            with attempt:
-                async with timeout_dur(duration=timeout):
-                    yield attempt
-
-        yield new(attempt)
-
-
-__all__ = [
-    "MaybeAttemptManager",
-    "wait_exponential_jitter",
-    "yield_attempts",
-    "yield_timeout_attempts",
-]