dycw-utilities 0.117.1__py3-none-any.whl → 0.119.0__py3-none-any.whl

utilities/datetime.py

@@ -457,7 +457,7 @@ class EnsureMonthError(Exception):
 
 
 def format_datetime_local_and_utc(datetime: dt.datetime, /) -> str:
-    """Format a local datetime locally & in UTC."""
+    """Format a plain datetime locally & in UTC."""
     time_zone = ensure_time_zone(datetime)
     if time_zone is UTC:
         return datetime.strftime("%Y-%m-%d %H:%M:%S (%a, UTC)")
@@ -706,8 +706,8 @@ def is_integral_timedelta(duration: Duration, /) -> bool:
 ##
 
 
-def is_local_datetime(obj: Any, /) -> TypeGuard[dt.datetime]:
-    """Check if an object is a local datetime."""
+def is_plain_datetime(obj: Any, /) -> TypeGuard[dt.datetime]:
+    """Check if an object is a plain datetime."""
     return isinstance(obj, dt.datetime) and (obj.tzinfo is None)
 
 
@@ -1105,7 +1105,7 @@ class SerializeCompactError(Exception):
 
     @override
     def __str__(self) -> str:
-        return f"Unable to serialize local datetime {self.datetime}"
+        return f"Unable to serialize plain datetime {self.datetime}"
 
 
 def parse_date_compact(text: str, /) -> dt.date:
@@ -1388,7 +1388,7 @@ __all__ = [
     "get_today",
     "get_years",
     "is_integral_timedelta",
-    "is_local_datetime",
+    "is_plain_datetime",
     "is_weekday",
     "is_zero_time",
     "is_zoned_datetime",

utilities/fastapi.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, Literal, override
 from fastapi import FastAPI
 from uvicorn import Config, Server
 
-from utilities.asyncio import AsyncService
+from utilities.asyncio import InfiniteLooper
 from utilities.datetime import SECOND, datetime_duration_to_float
 
 if TYPE_CHECKING:
@@ -36,7 +36,7 @@ class _PingerReceiverApp(FastAPI):
 
 
 @dataclass(kw_only=True)
-class PingReceiver(AsyncService):
+class PingReceiver(InfiniteLooper):
     """A ping receiver."""
 
     host: InitVar[str] = _LOCALHOST
@@ -67,13 +67,8 @@ class PingReceiver(AsyncService):
         return response.text if response.status_code == 200 else False  # skipif-ci
 
     @override
-    async def _start(self) -> None:
+    async def _initialize(self) -> None:
         await self._server.serve()  # skipif-ci
 
-    @override
-    async def stop(self) -> None:
-        await self._server.shutdown()  # skipif-ci
-        await super().stop()  # skipif-ci
-
 
 __all__ = ["PingReceiver"]

utilities/hypothesis.py

@@ -642,43 +642,6 @@ def lists_fixed_length(
 ##
 
 
-@composite
-def local_datetimes(
-    draw: DrawFn,
-    /,
-    *,
-    min_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MIN_NAIVE,
-    max_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MAX_NAIVE,
-    round_: RoundMode | None = None,
-    timedelta: dt.timedelta | None = None,
-    rel_tol: float | None = None,
-    abs_tol: float | None = None,
-) -> dt.datetime:
-    """Strategy for generating local datetimes."""
-    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
-    datetime = draw(datetimes(min_value=min_value_, max_value=max_value_))
-    if round_ is not None:
-        if timedelta is None:
-            raise LocalDateTimesError(round_=round_)
-        datetime = round_datetime(
-            datetime, timedelta, mode=round_, rel_tol=rel_tol, abs_tol=abs_tol
-        )
-        _ = assume(min_value_ <= datetime <= max_value_)
-    return datetime
-
-
-@dataclass(kw_only=True, slots=True)
-class LocalDateTimesError(Exception):
-    round_: RoundMode
-
-    @override
-    def __str__(self) -> str:
-        return "Rounding requires a timedelta; got None"
-
-
-##
-
-
 @composite
 def min_and_max_datetimes(
     draw: DrawFn,
@@ -991,6 +954,43 @@ def paths() -> SearchStrategy[Path]:
 ##
 
 
+@composite
+def plain_datetimes(
+    draw: DrawFn,
+    /,
+    *,
+    min_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MIN_NAIVE,
+    max_value: MaybeSearchStrategy[dt.datetime] = DATETIME_MAX_NAIVE,
+    round_: RoundMode | None = None,
+    timedelta: dt.timedelta | None = None,
+    rel_tol: float | None = None,
+    abs_tol: float | None = None,
+) -> dt.datetime:
+    """Strategy for generating plain datetimes."""
+    min_value_, max_value_ = [draw2(draw, v) for v in [min_value, max_value]]
+    datetime = draw(datetimes(min_value=min_value_, max_value=max_value_))
+    if round_ is not None:
+        if timedelta is None:
+            raise PlainDateTimesError(round_=round_)
+        datetime = round_datetime(
+            datetime, timedelta, mode=round_, rel_tol=rel_tol, abs_tol=abs_tol
+        )
+        _ = assume(min_value_ <= datetime <= max_value_)
+    return datetime
+
+
+@dataclass(kw_only=True, slots=True)
+class PlainDateTimesError(Exception):
+    round_: RoundMode
+
+    @override
+    def __str__(self) -> str:
+        return "Rounding requires a timedelta; got None"
+
+
+##
+
+
 @composite
 def random_states(
     draw: DrawFn, /, *, seed: MaybeSearchStrategy[int | None] = None
@@ -1478,7 +1478,7 @@ def zoned_datetimes(
 ) -> dt.datetime:
     """Strategy for generating zoned datetimes."""
     from utilities.whenever import (
-        CheckValidZonedDateimeError,
+        CheckValidZonedDateTimeError,
         check_valid_zoned_datetime,
     )
 
@@ -1496,7 +1496,7 @@ def zoned_datetimes(
             max_value_ = max_value_.astimezone(time_zone_)
     try:
         datetime = draw(
-            local_datetimes(
+            plain_datetimes(
                 min_value=min_value_.replace(tzinfo=None),
                 max_value=max_value_.replace(tzinfo=None),
                 round_=round_,
@@ -1505,13 +1505,13 @@ def zoned_datetimes(
                 abs_tol=abs_tol,
             )
         )
-    except LocalDateTimesError as error:
+    except PlainDateTimesError as error:
         raise ZonedDateTimesError(round_=error.round_) from None
     datetime = datetime.replace(tzinfo=time_zone_)
     _ = assume(min_value_ <= datetime <= max_value_)
     if valid:
         with assume_does_not_raise(  # skipif-ci-and-windows
-            CheckValidZonedDateimeError
+            CheckValidZonedDateTimeError
         ):
             check_valid_zoned_datetime(datetime)
     return datetime
@@ -1528,8 +1528,8 @@ class ZonedDateTimesError(Exception):
 
 __all__ = [
     "Draw2Error",
-    "LocalDateTimesError",
     "MaybeSearchStrategy",
+    "PlainDateTimesError",
     "Shape",
     "ZonedDateTimesError",
     "assume_does_not_raise",
@@ -1548,8 +1548,6 @@ __all__ = [
     "int64s",
     "int_arrays",
     "lists_fixed_length",
-    "local_datetimes",
-    "local_datetimes",
     "min_and_max_datetimes",
     "min_and_maybe_max_datetimes",
     "min_and_maybe_max_sizes",
@@ -1559,6 +1557,8 @@ __all__ = [
     "numbers",
     "pairs",
     "paths",
+    "plain_datetimes",
+    "plain_datetimes",
     "random_states",
     "sentinels",
     "sets_fixed_length",

utilities/orjson.py

@@ -48,7 +48,7 @@ from utilities.uuid import UUID_PATTERN
 from utilities.version import Version, parse_version
 from utilities.whenever import (
     parse_date,
-    parse_local_datetime,
+    parse_plain_datetime,
     parse_time,
     parse_timedelta,
     parse_zoned_datetime,
@@ -424,7 +424,7 @@ def _object_hook(
             if match := _FLOAT_PATTERN.search(text):
                 return float(match.group(1))
             if match := _LOCAL_DATETIME_PATTERN.search(text):
-                return parse_local_datetime(match.group(1))
+                return parse_plain_datetime(match.group(1))
             if match := _PATH_PATTERN.search(text):
                 return Path(match.group(1))
             if match := _TIME_PATTERN.search(text):

utilities/period.py

@@ -23,7 +23,7 @@ from utilities.sentinel import Sentinel, sentinel
 from utilities.typing import is_instance_gen
 from utilities.whenever import (
     serialize_date,
-    serialize_local_datetime,
+    serialize_plain_datetime,
     serialize_zoned_datetime,
 )
 from utilities.zoneinfo import EnsureTimeZoneError, ensure_time_zone
@@ -137,7 +137,7 @@ class Period(Generic[_TPeriod]):
                     )
                     return f"{cls}({start}, {end})"
                 start, end = (
-                    serialize_local_datetime(t.replace(tzinfo=None))
+                    serialize_plain_datetime(t.replace(tzinfo=None))
                     for t in [result.start, result.end]
                 )
                 return f"{cls}({start}, {end}, {time_zone})"

utilities/redis.py

@@ -22,7 +22,7 @@ from redis.asyncio import Redis
 from redis.asyncio.client import PubSub
 from redis.typing import EncodableT
 
-from utilities.asyncio import InfiniteQueueLooper, QueueProcessor, timeout_dur
+from utilities.asyncio import InfiniteQueueLooper, timeout_dur
 from utilities.datetime import (
     MILLISECOND,
     SECOND,
@@ -588,22 +588,6 @@ async def publish(
 ##
 
 
-@dataclass(kw_only=True)
-class Publisher(QueueProcessor[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_item(self, item: tuple[str, EncodableT], /) -> None:
-        channel, data = item  # skipif-ci-and-not-linux
-        _ = await publish(  # skipif-ci-and-not-linux
-            self.redis, channel, data, serializer=self.serializer, timeout=self.timeout
-        )
-
-
 @dataclass(kw_only=True)
 class PublisherIQL(InfiniteQueueLooper[None, tuple[str, EncodableT]]):
     """Publish a set of messages to Redis."""
@@ -828,7 +812,6 @@ _ = _TestRedis
 
 
 __all__ = [
-    "Publisher",
     "PublisherIQL",
     "PublisherIQLError",
     "RedisHashMapKey",

utilities/slack_sdk.py

@@ -3,18 +3,12 @@ from __future__ import annotations
 from asyncio import Queue
 from dataclasses import dataclass
 from http import HTTPStatus
-from itertools import chain
 from logging import NOTSET, Handler, LogRecord
 from typing import TYPE_CHECKING, override
 
 from slack_sdk.webhook.async_client import AsyncWebhookClient
 
-from utilities.asyncio import (
-    InfiniteQueueLooper,
-    QueueProcessor,
-    sleep_dur,
-    timeout_dur,
-)
+from utilities.asyncio import InfiniteQueueLooper, timeout_dur
 from utilities.datetime import MINUTE, SECOND, datetime_duration_to_float
 from utilities.functools import cache
 from utilities.math import safe_round
@@ -40,66 +34,6 @@ async def _send_adapter(url: str, text: str, /) -> None:
     await send_to_slack(url, text)  # pragma: no cover
 
 
-@dataclass(init=False, order=True, unsafe_hash=True)
-class SlackHandler(Handler, QueueProcessor[str]):
-    """Handler for sending messages to Slack."""
-
-    @override
-    def __init__(
-        self,
-        url: str,
-        /,
-        *,
-        level: int = NOTSET,
-        queue_type: type[Queue[str]] = Queue,
-        queue_max_size: int | None = None,
-        sender: Callable[[str, str], Coroutine1[None]] = _send_adapter,
-        timeout: Duration = _TIMEOUT,
-        callback_failure: Callable[[str, Exception], None] | None = None,
-        callback_success: Callable[[str], None] | None = None,
-        callback_final: Callable[[str], None] | None = None,
-        sleep: Duration = _SLEEP,
-    ) -> None:
-        QueueProcessor.__init__(  # QueueProcessor first
-            self, queue_type=queue_type, queue_max_size=queue_max_size
-        )
-        QueueProcessor.__post_init__(self)
-        Handler.__init__(self, level=level)
-        self.url = url
-        self.sender = sender
-        self.timeout = timeout
-        self.callback_failure = callback_failure
-        self.callback_success = callback_success
-        self.callback_final = callback_final
-        self.sleep = sleep
-
-    @override
-    def emit(self, record: LogRecord) -> None:
-        try:
-            self.enqueue(self.format(record))
-        except Exception:  # noqa: BLE001  # pragma: no cover
-            self.handleError(record)
-
-    @override
-    async def _process_item(self, item: str, /) -> None:
-        """Process the first item."""
-        items = list(chain([item], self._get_items_nowait()))
-        text = "\n".join(items)
-        try:
-            async with timeout_dur(duration=self.timeout):
-                await self.sender(self.url, text)
-        except Exception as error:  # noqa: BLE001
-            if self.callback_failure is not None:
-                self.callback_failure(text, error)
-        else:
-            if self.callback_success is not None:
-                self.callback_success(text)
-        finally:
-            if self.callback_final is not None:
-                self.callback_final(text)
-            await sleep_dur(duration=self.sleep)
-
-
 @dataclass(init=False, unsafe_hash=True)
 class SlackHandlerIQL(Handler, InfiniteQueueLooper[None, str]):
     """Handler for sending messages to Slack."""
@@ -176,4 +110,4 @@ def _get_client(url: str, /, *, timeout: Duration = _TIMEOUT) -> AsyncWebhookCli
     return AsyncWebhookClient(url, timeout=timeout_use)
 
 
-__all__ = ["SendToSlackError", "SlackHandler", "SlackHandlerIQL", "send_to_slack"]
+__all__ = ["SendToSlackError", "SlackHandlerIQL", "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, QueueProcessor, timeout_dur
+from utilities.asyncio import InfiniteQueueLooper, timeout_dur
 from utilities.functions import (
     ensure_str,
     get_class_name,
@@ -608,48 +608,6 @@ class TablenameMixin:
 ##
 
 
-@dataclass(kw_only=True)
-class Upserter(QueueProcessor[_InsertItem]):
-    """Upsert a set of items into 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
-
-    async def _pre_upsert(self, items: Sequence[_InsertItem], /) -> None:
-        """Pre-upsert coroutine."""
-        _ = items
-
-    async def _post_upsert(self, items: Sequence[_InsertItem], /) -> None:
-        """Post-upsert coroutine."""
-        _ = items
-
-    @override
-    async def _process_item(self, item: _InsertItem, /) -> None:
-        """Process the first item."""
-        items = list(chain([item], self._get_items_nowait()))
-        await self._pre_upsert(items)
-        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,
-        )
-        await self._post_upsert(items)
-
-
 @dataclass(kw_only=True)
 class UpserterIQL(InfiniteQueueLooper[None, _InsertItem]):
     """Upsert a set of items to a database."""
@@ -1150,7 +1108,6 @@ __all__ = [
     "InsertItemsError",
     "TablenameMixin",
     "UpsertItemsError",
-    "Upserter",
     "UpserterIQL",
     "UpserterIQLError",
     "check_engine",