dycw-utilities 0.127.0__py3-none-any.whl → 0.129.13__py3-none-any.whl

utilities/redis.py

@@ -23,9 +23,8 @@ from typing import (
 )
 
 from redis.asyncio import Redis
-from redis.typing import EncodableT
 
-from utilities.asyncio import EnhancedQueue, InfiniteQueueLooper, Looper, timeout_dur
+from utilities.asyncio import EnhancedQueue, Looper, timeout_dur
 from utilities.contextlib import suppress_super_object_attribute_error
 from utilities.datetime import (
     MILLISECOND,
@@ -34,7 +33,7 @@ from utilities.datetime import (
     datetime_duration_to_timedelta,
 )
 from utilities.errors import ImpossibleCaseError
-from utilities.functions import ensure_int, get_class_name, identity
+from utilities.functions import ensure_int, identity
 from utilities.iterables import always_iterable, one
 from utilities.orjson import deserialize, serialize
 
@@ -51,10 +50,10 @@ if TYPE_CHECKING:
 
     from redis.asyncio import ConnectionPool
     from redis.asyncio.client import PubSub
-    from redis.typing import ResponseT
+    from redis.typing import EncodableT, ResponseT
 
     from utilities.iterables import MaybeIterable
-    from utilities.types import Duration, MaybeType, TypeLike
+    from utilities.types import Duration, TypeLike
 
 
 _K = TypeVar("_K")
@@ -620,42 +619,6 @@ class PublishError(Exception):
 ##
 
 
-@dataclass(kw_only=True)
-class Publisher(InfiniteQueueLooper[None, tuple[str, EncodableT]]):
-    """Publish a set of messages to Redis."""
-
-    redis: Redis
-    serializer: Callable[[Any], EncodableT] | None = None
-    timeout: Duration = _PUBLISH_TIMEOUT
-
-    @override
-    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,
-                channel,
-                data,
-                serializer=self.serializer,
-                timeout=self.timeout,
-            )
-
-    @override
-    def _yield_events_and_exceptions(
-        self,
-    ) -> Iterator[tuple[None, MaybeType[Exception]]]:
-        yield (None, PublisherError)  # skipif-ci-and-not-linux
-
-
-@dataclass(kw_only=True)
-class PublisherError(Exception):
-    publisher: Publisher
-
-    @override
-    def __str__(self) -> str:
-        return f"Error running {get_class_name(self.publisher)!r}"  # skipif-ci-and-not-linux
-
-
 @dataclass(kw_only=True)
 class PublishService(Looper[tuple[str, _T]]):
     """Service to publish items to Redis."""
@@ -1095,8 +1058,6 @@ def _deserialize(
 __all__ = [
     "PublishService",
     "PublishServiceMixin",
-    "Publisher",
-    "PublisherError",
     "RedisHashMapKey",
     "RedisKey",
     "SubscribeService",

utilities/scipy.py

@@ -19,7 +19,7 @@ def _ppf_1d(array: NDArrayF, cutoff: float, /) -> NDArrayF:
         out = full_like(array, nan, dtype=float)
         out[j] = _ppf_1d(array[j], cutoff)
         return out
-    low, high = min(array), max(array)
+    low, high = array.min(), array.max()
     if is_zero(span := high - low):
         return zeros_like(array, dtype=float)
     centred = (array - low) / span

utilities/slack_sdk.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any, Self, override
 
 from slack_sdk.webhook.async_client import AsyncWebhookClient
 
-from utilities.asyncio import InfiniteQueueLooper, Looper, timeout_dur
+from utilities.asyncio import Looper, timeout_dur
 from utilities.datetime import MINUTE, SECOND, datetime_duration_to_float
 from utilities.functools import cache
 from utilities.math import safe_round
@@ -27,53 +27,10 @@ _TIMEOUT: Duration = MINUTE
 ##
 
 
-_SLEEP: Duration = SECOND
-
-
 async def _send_adapter(url: str, text: str, /) -> None:
     await send_to_slack(url, text)  # pragma: no cover
 
 
-@dataclass(init=False, unsafe_hash=True)
-class SlackHandler(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,
-        sender: Callable[[str, str], Coroutine1[None]] = _send_adapter,
-        timeout: Duration = _TIMEOUT,
-    ) -> None:
-        InfiniteQueueLooper.__init__(self)  # InfiniteQueueLooper first
-        InfiniteQueueLooper.__post_init__(self)
-        Handler.__init__(self, level=level)  # Handler next
-        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_right_nowait(self.format(record))
-        except Exception:  # noqa: BLE001  # pragma: no cover
-            self.handleError(record)
-
-    @override
-    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)
-
-
 @dataclass(init=False, unsafe_hash=True)
 class SlackHandlerService(Handler, Looper[str]):
     """Service to send messages to Slack."""
@@ -187,4 +144,4 @@ def _get_client(url: str, /, *, timeout: Duration = _TIMEOUT) -> AsyncWebhookCli
     return AsyncWebhookClient(url, timeout=timeout_use)
 
 
-__all__ = ["SendToSlackError", "SlackHandler", "SlackHandlerService", "send_to_slack"]
+__all__ = ["SendToSlackError", "SlackHandlerService", "send_to_slack"]

utilities/sqlalchemy.py

@@ -57,7 +57,7 @@ from sqlalchemy.orm import (
 from sqlalchemy.orm.exc import UnmappedClassError
 from sqlalchemy.pool import NullPool, Pool
 
-from utilities.asyncio import InfiniteQueueLooper, Looper, timeout_dur
+from utilities.asyncio import Looper, timeout_dur
 from utilities.contextlib import suppress_super_object_attribute_error
 from utilities.datetime import SECOND
 from utilities.functions import (
@@ -82,13 +82,7 @@ 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 Duration, MaybeIterable, StrMapping, TupleOrStrMapping
 
 _T = TypeVar("_T")
 type _EngineOrConnectionOrAsync = Engine | Connection | AsyncEngine | AsyncConnection
@@ -610,52 +604,6 @@ class TablenameMixin:
 ##
 
 
-@dataclass(kw_only=True)
-class Upserter(InfiniteQueueLooper[None, _InsertItem]):
-    """Upsert a set of items to a database."""
-
-    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 _process_queue(self) -> None:
-        items = self._queue.get_all_nowait()
-        await upsert_items(
-            self.engine,
-            *items,
-            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,
-        )
-
-    @override
-    def _yield_events_and_exceptions(
-        self,
-    ) -> Iterator[tuple[None, MaybeType[Exception]]]:
-        yield (None, UpserterError)
-
-
-@dataclass(kw_only=True)
-class UpserterError(Exception):
-    upserter: Upserter
-
-    @override
-    def __str__(self) -> str:
-        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."""
@@ -1202,8 +1150,6 @@ __all__ = [
     "UpsertItemsError",
     "UpsertService",
     "UpsertServiceMixin",
-    "Upserter",
-    "UpserterError",
     "check_engine",
     "columnwise_max",
     "columnwise_min",