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

{dycw_utilities-0.131.16.dist-info → dycw_utilities-0.131.17.dist-info}/METADATA

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

{dycw_utilities-0.131.16.dist-info → dycw_utilities-0.131.17.dist-info}/RECORD

@@ -1,7 +1,7 @@
-utilities/__init__.py,sha256=I-o_EPHIejt3ggoklYx3Vx_Wi2XLiPZ3YlzjyX4JBKI,61
+utilities/__init__.py,sha256=VaWub7ik43R7i6IUMJibr6EG62sAZ7zSqzl9IaPeNEs,61
 utilities/aiolimiter.py,sha256=mD0wEiqMgwpty4XTbawFpnkkmJS6R4JRsVXFUaoitSU,628
 utilities/altair.py,sha256=HeZBVUocjkrTNwwKrClppsIqgNFF-ykv05HfZSoHYno,9104
-utilities/asyncio.py,sha256=yfKvAIDCRrWdyQMVZMo4DJQx4nVrXoAcqwhNuF95Ryo,38186
+utilities/asyncio.py,sha256=mHnlSA4KPeDaBRts8Rn4sNA_4urodj7gQzs-_8Z-F7A,37587
 utilities/atomicwrites.py,sha256=geFjn9Pwn-tTrtoGjDDxWli9NqbYfy3gGL6ZBctiqSo,5393
 utilities/atools.py,sha256=-bFGIrwYMFR7xl39j02DZMsO_u5x5_Ph7bRlBUFVYyw,1048
 utilities/cachetools.py,sha256=uBtEv4hD-TuCPX_cQy1lOpLF-QqfwnYGSf0o4Soqydc,2826
@@ -50,9 +50,9 @@ utilities/pickle.py,sha256=MBT2xZCsv0pH868IXLGKnlcqNx2IRVKYNpRcqiQQqxw,653
 utilities/platform.py,sha256=48IOKx1IC6ZJXWG-b56ZQptITcNFhWRjELW72o2dGTA,2398
 utilities/polars.py,sha256=QlmUpYTqHNkcLnWOQh1TW22W2QyLzvifCvBcbsqhpdE,63272
 utilities/polars_ols.py,sha256=Uc9V5kvlWZ5cU93lKZ-cfAKdVFFw81tqwLW9PxtUvMs,5618
-utilities/pottery.py,sha256=-YikdIQFqhFXifyMq5R5z6V6N8y639gAnVVXR4jXxdc,3568
+utilities/pottery.py,sha256=2w3YuoH1KmLaCVqkwSghHTOT8S4xiUskwRHSRqrUEQY,3430
 utilities/pqdm.py,sha256=foRytQybmOQ05pjt5LF7ANyzrIa--4ScDE3T2wd31a4,3118
-utilities/psutil.py,sha256=RtbLKOoIJhqrJmEoHDBVeSD-KPzshtS0FtRXBP9_w2s,3751
+utilities/psutil.py,sha256=ZkwBGfTqAv8hxCyJVVJFctIVQvxhYuB28re3mIPBodc,3761
 utilities/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 utilities/pydantic.py,sha256=aP6OKowg2Md4rgQuQ5qTSF4bTbBuq7WtRb7zS3JSRGY,1841
 utilities/pyinstrument.py,sha256=3MPNDbZW_1Aj1aA1_f-yqPStgmjIFxPwIafYq2dsaTs,853
@@ -62,20 +62,19 @@ utilities/pytest_regressions.py,sha256=YI55B7EtLjhz7zPJZ6NK9bWrxrKCKabWZJe1cwcbA
 utilities/python_dotenv.py,sha256=edXsvHZhZnYeqfMfrsRRpj7_9eJI6uizh3xLx8Q9B3w,3228
 utilities/random.py,sha256=lYdjgxB7GCfU_fwFVl5U-BIM_HV3q6_urL9byjrwDM8,4157
 utilities/re.py,sha256=6qxeV0rQZaBDKWcB7apSBmxtg_XzoGY-EdegTkMn-ZY,4578
-utilities/redis.py,sha256=IceT5EjgrebVkGL8X3M35xlqjI2c7zFbyV1P4dExN4M,36037
+utilities/redis.py,sha256=oA70YoFnSaSqTBzMHrbHkkGIBWU69-97MQEwH_0iX3g,35762
 utilities/reprlib.py,sha256=ssYTcBW-TeRh3fhCJv57sopTZHF5FrPyyUg9yp5XBlo,3953
 utilities/scipy.py,sha256=wZJM7fEgBAkLSYYvSmsg5ac-QuwAI0BGqHVetw1_Hb0,947
 utilities/sentinel.py,sha256=3jIwgpMekWgDAxPDA_hXMP2St43cPhciKN3LWiZ7kv0,1248
 utilities/shelve.py,sha256=HZsMwK4tcIfg3sh0gApx4-yjQnrY4o3V3ZRimvRhoW0,738
-utilities/slack_sdk.py,sha256=ltmzv68aa73CJGqTDvt8L9vDm22YU9iOCo3NCiNd3vA,4347
+utilities/slack_sdk.py,sha256=ZpPzV_oHpSJbontGo2_YVVjKH08PjLjsx5Me-nLy918,4246
 utilities/socket.py,sha256=K77vfREvzoVTrpYKo6MZakol0EYu2q1sWJnnZqL0So0,118
-utilities/sqlalchemy.py,sha256=IuQ7CIVNl29TG6i81K6fam8NmTmPjtA6OiIN4nIM9W8,37935
-utilities/sqlalchemy_polars.py,sha256=hApbjQUY-XgKfAXcun8gDP2lGh5LxrudnCpbG_hrYa0,14968
+utilities/sqlalchemy.py,sha256=sTlxK-Is-XCj7srTRh3Nz68axzIdDYZWLQdTeXnOdkQ,38015
+utilities/sqlalchemy_polars.py,sha256=bDiKqHxOWu0Dj4ZDuGcVgR7ulm7sB90iVNINAKaeaKc,14290
 utilities/statsmodels.py,sha256=koyiBHvpMcSiBfh99wFUfSggLNx7cuAw3rwyfAhoKpQ,3410
 utilities/streamlit.py,sha256=U9PJBaKP1IdSykKhPZhIzSPTZsmLsnwbEPZWzNhJPKk,2955
 utilities/string.py,sha256=XmU-s04qIV_tODnKl2pQiwmHaxzgOqRKU-RyzdrfvSE,620
 utilities/tempfile.py,sha256=VqmZJAhTJ1OaVywFzk5eqROV8iJbW9XQ_QYAV0bpdRo,1384
-utilities/tenacity.py,sha256=1PUvODiBVgeqIh7G5TRt5WWMSqjLYkEqP53itT97WQc,4914
 utilities/text.py,sha256=ymBFlP_cA8OgNnZRVNs7FAh7OG8HxE6YkiLEMZv5g_A,11297
 utilities/threading.py,sha256=GvBOp4CyhHfN90wGXZuA2VKe9fGzMaEa7oCl4f3nnPU,1009
 utilities/timer.py,sha256=VeSl3ot8-f4D1d3HjjSsgKvjxHJGXd_sW4KcTExOR64,2475
@@ -92,7 +91,7 @@ utilities/whenever.py,sha256=oO0sgIIv4tvhIYmlZ4RFFfY6P54CPeyJCY9A4XHuyqo,11916
 utilities/whenever2.py,sha256=Jd_fEavXCWTdMj29L7j-HbeMvrl8e3Ah_nxcLEFAwOU,12026
 utilities/zipfile.py,sha256=24lQc9ATcJxHXBPc_tBDiJk48pWyRrlxO2fIsFxU0A8,699
 utilities/zoneinfo.py,sha256=gJPr9l7V8s3Y7TXpCGYEM1S81Rplb9e4MoV9Nvy2VU8,1852
-dycw_utilities-0.131.16.dist-info/METADATA,sha256=X0Yt3BUVE7Y7W884VYvx_9CVhE4c9ENSxbhD4ghFoKU,1585
-dycw_utilities-0.131.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dycw_utilities-0.131.16.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
-dycw_utilities-0.131.16.dist-info/RECORD,,
+dycw_utilities-0.131.17.dist-info/METADATA,sha256=H8TXOjXCrBtmH2V30ZUSMr1mz56J-27FJYHgaoof7Oc,1585
+dycw_utilities-0.131.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dycw_utilities-0.131.17.dist-info/licenses/LICENSE,sha256=gppZp16M6nSVpBbUBrNL6JuYfvKwZiKgV7XoKKsHzqo,1066
+dycw_utilities-0.131.17.dist-info/RECORD,,

utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.131.16"
+__version__ = "0.131.17"

utilities/asyncio.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 from asyncio import (
     Event,
     Lock,
@@ -14,7 +15,6 @@ from asyncio import (
     create_subprocess_shell,
     create_task,
     sleep,
-    timeout,
 )
 from collections.abc import Callable, Iterable, Iterator
 from contextlib import (
@@ -43,28 +43,22 @@ from typing import (
 )
 
 from typing_extensions import deprecated
-from whenever import TimeDelta
 
 from utilities.dataclasses import replace_non_sentinel
-from utilities.datetime import (
-    SECOND,
-    datetime_duration_to_float,
-    get_now,
-    round_datetime,
-)
 from utilities.errors import repr_error
 from utilities.functions import ensure_int, ensure_not_none
 from utilities.random import SYSTEM_RANDOM
 from utilities.sentinel import Sentinel, sentinel
 from utilities.types import (
+    DateTimeRoundUnit,
     MaybeCallableEvent,
     MaybeType,
     THashable,
     TSupportsRichComparison,
 )
+from utilities.whenever2 import SECOND, get_now
 
 if TYPE_CHECKING:
-    import datetime as dt
     from asyncio import _CoroutineLike
     from asyncio.subprocess import Process
     from collections import deque
@@ -73,7 +67,7 @@ if TYPE_CHECKING:
     from random import Random
     from types import TracebackType
 
-    from utilities.types import Duration
+    from whenever import TimeDelta, ZonedDateTime
 
 
 _T = TypeVar("_T")
@@ -244,7 +238,7 @@ class EnhancedTaskGroup(TaskGroup):
     """Task group with enhanced features."""
 
     _semaphore: Semaphore | None
-    _timeout: Duration | None
+    _timeout: TimeDelta | None
     _error: MaybeType[BaseException]
     _stack: AsyncExitStack
     _timeout_cm: _AsyncGeneratorContextManager[None] | None
@@ -254,7 +248,7 @@ class EnhancedTaskGroup(TaskGroup):
         self,
         *,
         max_tasks: int | None = None,
-        timeout: Duration | None = None,
+        timeout: TimeDelta | None = None,
         error: MaybeType[BaseException] = TimeoutError,
     ) -> None:
         super().__init__()
@@ -306,7 +300,7 @@ class EnhancedTaskGroup(TaskGroup):
             return await coroutine
 
     async def _wrap_with_timeout(self, coroutine: _CoroutineLike[_T], /) -> _T:
-        async with timeout_dur(duration=self._timeout, error=self._error):
+        async with timeout_td(self._timeout, error=self._error):
             return await coroutine
 
 
@@ -331,15 +325,13 @@ class Looper(Generic[_T]):
     """A looper of a core coroutine, handling errors."""
 
     auto_start: bool = field(default=False, repr=False)
-    freq: Duration = field(default=SECOND, repr=False)
-    backoff: Duration = field(default=10 * SECOND, repr=False)
+    freq: TimeDelta = field(default=SECOND, repr=False)
+    backoff: TimeDelta = field(default=10 * SECOND, repr=False)
     empty_upon_exit: bool = field(default=False, repr=False)
     logger: str | None = field(default=None, repr=False)
-    timeout: Duration | None = field(default=None, repr=False)
+    timeout: TimeDelta | None = field(default=None, repr=False)
     # settings
-    _backoff: float = field(init=False, repr=False)
     _debug: bool = field(default=False, repr=False)
-    _freq: float = field(init=False, repr=False)
     # counts
     _entries: int = field(default=0, init=False, repr=False)
     _core_attempts: int = field(default=0, init=False, repr=False)
@@ -379,8 +371,6 @@ class Looper(Generic[_T]):
     _task: Task[None] | None = field(default=None, init=False, repr=False, hash=False)
 
     def __post_init__(self) -> None:
-        self._backoff = datetime_duration_to_float(self.backoff)
-        self._freq = datetime_duration_to_float(self.freq)
         self._logger = getLogger(name=self.logger)
         self._logger.setLevel(DEBUG)
 
@@ -448,7 +438,7 @@ class Looper(Generic[_T]):
 
     async def _apply_back_off(self) -> None:
         """Apply a back off period."""
-        await sleep(self._backoff)
+        await sleep_td(self.backoff)
         self._is_pending_back_off.clear()
 
     async def core(self) -> None:
@@ -541,10 +531,10 @@ class Looper(Generic[_T]):
         *,
         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:
@@ -670,7 +660,7 @@ class Looper(Generic[_T]):
     async def run_looper(self) -> None:
         """Run the looper."""
         try:
-            async with timeout_dur(duration=self.timeout):
+            async with timeout_td(self.timeout):
                 while True:
                     if self._is_stopped.is_set():
                         _ = self._debug and self._logger.debug("%s: stopped", self)
@@ -705,7 +695,7 @@ class Looper(Generic[_T]):
                         else:
                             async with self._lock:
                                 self._core_successes += 1
-                            await sleep(self._freq)
+                            await sleep_td(self.freq)
         except RuntimeError as error:  # pragma: no cover
             if error.args[0] == "generator didn't stop after athrow()":
                 return
@@ -718,7 +708,7 @@ class Looper(Generic[_T]):
         while not self.empty():
             await self.core()
             if not self.empty():
-                await sleep(self._freq)
+                await sleep_td(self.freq)
 
     @property
     def stats(self) -> _LooperStats:
@@ -962,47 +952,41 @@ def put_items_nowait(items: Iterable[_T], queue: Queue[_T], /) -> None:
 ##
 
 
-async def sleep_dur(*, duration: Duration | TimeDelta | None = None) -> None:
-    """Sleep which accepts durations."""
-    if duration is None:
+async def sleep_max(
+    sleep: TimeDelta | None = None, /, *, random: Random = SYSTEM_RANDOM
+) -> None:
+    """Sleep which accepts deltas."""
+    if sleep is None:
         return
-    if isinstance(duration, TimeDelta):
-        await sleep(duration.in_seconds())
-    else:
-        await sleep(datetime_duration_to_float(duration))
+    await asyncio.sleep(random.uniform(0.0, sleep.in_seconds()))
 
 
 ##
 
 
-async def sleep_max_dur(
-    *, duration: Duration | None = None, random: Random = SYSTEM_RANDOM
+async def sleep_rounded(
+    *, unit: DateTimeRoundUnit = "second", increment: int = 1
 ) -> None:
-    """Sleep which accepts max durations."""
-    if duration is None:
-        return
-    await sleep(random.uniform(0.0, datetime_duration_to_float(duration)))
+    """Sleep until a rounded time."""
+    await sleep_until(get_now().round(unit, increment=increment, mode="ceil"))
 
 
 ##
 
 
-async def sleep_until(datetime: dt.datetime, /) -> None:
-    """Sleep until a given time."""
-    await sleep_dur(duration=datetime - get_now())
+async def sleep_td(delta: TimeDelta | None = None, /) -> None:
+    """Sleep which accepts deltas."""
+    if delta is None:
+        return
+    await sleep(delta.in_seconds())
 
 
 ##
 
 
-async def sleep_until_rounded(
-    duration: Duration, /, *, rel_tol: float | None = None, abs_tol: float | None = None
-) -> None:
-    """Sleep until a rounded time; accepts durations."""
-    datetime = round_datetime(
-        get_now(), duration, mode="ceil", rel_tol=rel_tol, abs_tol=abs_tol
-    )
-    await sleep_until(datetime)
+async def sleep_until(datetime: ZonedDateTime, /) -> None:
+    """Sleep until a given time."""
+    await sleep_td(datetime - get_now())
 
 
 ##
@@ -1059,13 +1043,16 @@ async def _stream_one(
 
 
 @asynccontextmanager
-async def timeout_dur(
-    *, duration: Duration | None = None, error: MaybeType[BaseException] = TimeoutError
+async def timeout_td(
+    timeout: TimeDelta | None = None,
+    /,
+    *,
+    error: MaybeType[BaseException] = TimeoutError,
 ) -> AsyncIterator[None]:
-    """Timeout context manager which accepts durations."""
-    delay = None if duration is None else datetime_duration_to_float(duration)
+    """Timeout context manager which accepts deltas."""
+    timeout_use = None if timeout is None else timeout.in_seconds()
     try:
-        async with timeout(delay):
+        async with asyncio.timeout(timeout_use):
             yield
     except TimeoutError:
         raise error from None
@@ -1084,10 +1071,10 @@ __all__ = [
     "get_items_nowait",
     "put_items",
     "put_items_nowait",
-    "sleep_dur",
-    "sleep_max_dur",
+    "sleep_max",
+    "sleep_rounded",
+    "sleep_td",
     "sleep_until",
-    "sleep_until_rounded",
     "stream_command",
-    "timeout_dur",
+    "timeout_td",
 ]

utilities/pottery.py

@@ -8,14 +8,16 @@ from pottery import AIORedlock
 from pottery.exceptions import ReleaseUnlockedLock
 from redis.asyncio import Redis
 
-from utilities.asyncio import sleep_dur, timeout_dur
-from utilities.datetime import MILLISECOND, SECOND, datetime_duration_to_float
+from utilities.asyncio import sleep_td, timeout_td
 from utilities.iterables import always_iterable
+from utilities.whenever2 import MILLISECOND, SECOND
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterable
 
-    from utilities.types import Duration, MaybeIterable
+    from whenever import TimeDelta
+
+    from utilities.types import MaybeIterable
 
 
 @asynccontextmanager
@@ -25,10 +27,10 @@ async def yield_access(
     /,
     *,
     num: int = 1,
-    timeout_acquire: Duration | None = None,
-    timeout_release: Duration = 10 * SECOND,
-    sleep: Duration = MILLISECOND,
-    throttle: Duration | None = None,
+    timeout_acquire: TimeDelta | None = None,
+    timeout_release: TimeDelta = 10 * SECOND,
+    sleep: TimeDelta = MILLISECOND,
+    throttle: TimeDelta | None = None,
 ) -> AsyncIterator[None]:
     """Acquire access to a locked resource, amongst 1 of multiple connections."""
     if num <= 0:
@@ -36,14 +38,11 @@ async def yield_access(
     masters = (  # skipif-ci-and-not-linux
         {redis} if isinstance(redis, Redis) else set(always_iterable(redis))
     )
-    auto_release_time = datetime_duration_to_float(  # skipif-ci-and-not-linux
-        timeout_release
-    )
     locks = [  # skipif-ci-and-not-linux
         AIORedlock(
             key=f"{key}_{i}_of_{num}",
             masters=masters,
-            auto_release_time=auto_release_time,
+            auto_release_time=timeout_release.in_seconds(),
         )
         for i in range(1, num + 1)
     ]
@@ -54,7 +53,7 @@ async def yield_access(
         )
         yield
     finally:  # skipif-ci-and-not-linux
-        await sleep_dur(duration=throttle)
+        await sleep_td(throttle)
         if lock is not None:
             with suppress(ReleaseUnlockedLock):
                 await lock.release()
@@ -66,20 +65,18 @@ async def _get_first_available_lock(
     /,
     *,
     num: int = 1,
-    timeout: Duration | None = None,
-    sleep: Duration | None = None,
+    timeout: TimeDelta | None = None,
+    sleep: TimeDelta | None = None,
 ) -> AIORedlock:
     locks = list(locks)  # skipif-ci-and-not-linux
     error = _YieldAccessUnableToAcquireLockError(  # skipif-ci-and-not-linux
         key=key, num=num, timeout=timeout
     )
-    async with timeout_dur(  # skipif-ci-and-not-linux
-        duration=timeout, error=error
-    ):
+    async with timeout_td(timeout, error=error):  # skipif-ci-and-not-linux
         while True:
             if (result := await _get_first_available_lock_if_any(locks)) is not None:
                 return result
-            await sleep_dur(duration=sleep)
+            await sleep_td(sleep)
 
 
 async def _get_first_available_lock_if_any(
@@ -106,7 +103,7 @@ class _YieldAccessNumLocksError(YieldAccessError):
 
 @dataclass(kw_only=True, slots=True)
 class _YieldAccessUnableToAcquireLockError(YieldAccessError):
-    timeout: Duration | None
+    timeout: TimeDelta | None
 
     @override
     def __str__(self) -> str:

utilities/psutil.py

@@ -11,13 +11,14 @@ from psutil import swap_memory, virtual_memory
 
 from utilities.asyncio import Looper
 from utilities.contextlib import suppress_super_object_attribute_error
-from utilities.datetime import SECOND, get_now
+from utilities.whenever2 import SECOND, get_now
 
 if TYPE_CHECKING:
-    import datetime as dt
     from logging import Logger
 
-    from utilities.types import Duration, PathLike
+    from whenever import TimeDelta, ZonedDateTime
+
+    from utilities.types import PathLike
 
 
 @dataclass(kw_only=True)
@@ -25,8 +26,8 @@ class MemoryMonitorService(Looper[None]):
     """Service to monitor memory usage."""
 
     # base
-    freq: Duration = field(default=10 * SECOND, repr=False)
-    backoff: Duration = field(default=10 * SECOND, repr=False)
+    freq: TimeDelta = field(default=10 * SECOND, repr=False)
+    backoff: TimeDelta = field(default=10 * SECOND, repr=False)
     # self
     console: str | None = field(default=None, repr=False)
     path: PathLike = "memory.txt"
@@ -46,7 +47,7 @@ class MemoryMonitorService(Looper[None]):
         await super().core()
         memory = MemoryUsage.new()
         mapping = {
-            "datetime": memory.datetime.strftime("%Y-%m-%d %H:%M:%S"),
+            "datetime": memory.datetime.format_common_iso(),
             "virtual used (mb)": memory.virtual_used_mb,
             "virtual total (mb)": memory.virtual_total_mb,
             "virtual (%)": memory.virtual_pct,
@@ -68,7 +69,7 @@ class MemoryMonitorService(Looper[None]):
 class MemoryUsage:
     """A memory usage."""
 
-    datetime: dt.datetime = field(default_factory=get_now)
+    datetime: ZonedDateTime = field(default_factory=get_now)
     virtual_used: int = field(repr=False)
     virtual_used_mb: int = field(init=False)
     virtual_total: int = field(repr=False)