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

utilities/orjson.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 import re
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from contextlib import suppress
@@ -23,7 +22,15 @@ from orjson import (
     dumps,
     loads,
 )
-from whenever import ZonedDateTime
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
 
 from utilities.concurrent import concurrent_map
 from utilities.dataclasses import dataclass_to_dict
@@ -39,27 +46,13 @@ from utilities.logging import get_logging_level_number
 from utilities.math import MAX_INT64, MIN_INT64
 from utilities.types import Dataclass, LogLevel, MaybeIterable, PathLike, StrMapping
 from utilities.tzlocal import LOCAL_TIME_ZONE
-from utilities.uuid import UUID_PATTERN
 from utilities.version import Version, parse_version
-from utilities.whenever import (
-    parse_date,
-    parse_plain_datetime,
-    parse_time,
-    parse_timedelta,
-    parse_zoned_datetime,
-    serialize_date,
-    serialize_datetime,
-    serialize_time,
-    serialize_timedelta,
-)
 from utilities.whenever2 import from_timestamp
 
 if TYPE_CHECKING:
     from collections.abc import Set as AbstractSet
     from logging import _FormatStyle
 
-    from whenever import Date
-
     from utilities.types import Parallelism
 
 
@@ -70,26 +63,25 @@ if TYPE_CHECKING:
 class _Prefixes(Enum):
     dataclass = "dc"
     date = "d"
-    datetime = "dt"
+    date_delta = "dd"
+    date_time_delta = "D"
     enum = "e"
-    exception_class = "exc"
-    exception_instance = "exi"
+    exception_class = "Ex"
+    exception_instance = "ex"
     float_ = "fl"
     frozenset_ = "fr"
     list_ = "l"
-    nan = "nan"
     none = "none"
     path = "p"
-    pos_inf = "pos_inf"
-    neg_inf = "neg_inf"
+    plain_date_time = "pd"
     set_ = "s"
-    timedelta = "td"
-    time = "tm"
+    time = "ti"
+    time_delta = "td"
     tuple_ = "tu"
     unserializable = "un"
     uuid = "uu"
     version = "v"
-    zoned_datetime = "zd"
+    zoned_date_time = "zd"
 
 
 type _DataclassHook = Callable[[type[Dataclass], StrMapping], StrMapping]
@@ -160,14 +152,12 @@ def _pre_process(
         # singletons
         case None:
             return f"[{_Prefixes.none.value}]"
-        case dt.datetime() as datetime:
-            return f"[{_Prefixes.datetime.value}]{serialize_datetime(datetime)}"
-        case dt.date() as date:  # after datetime
-            return f"[{_Prefixes.date.value}]{serialize_date(date)}"
-        case dt.time() as time:
-            return f"[{_Prefixes.time.value}]{serialize_time(time)}"
-        case dt.timedelta() as timedelta:
-            return f"[{_Prefixes.timedelta.value}]{serialize_timedelta(timedelta)}"
+        case Date() as date:
+            return f"[{_Prefixes.date.value}]{date}"
+        case DateDelta() as date:
+            return f"[{_Prefixes.date_delta.value}]{date}"
+        case DateTimeDelta() as date:
+            return f"[{_Prefixes.date_time_delta.value}]{date}"
         case Exception() as error_:
             return {
                 f"[{_Prefixes.exception_instance.value}|{type(error_).__qualname__}]": pre(
@@ -182,18 +172,24 @@ def _pre_process(
             if MIN_INT64 <= int_ <= MAX_INT64:
                 return int_
             raise _SerializeIntegerError(obj=int_)
-        case UUID() as uuid:
-            return f"[{_Prefixes.uuid.value}]{uuid}"
         case Path() as path:
             return f"[{_Prefixes.path.value}]{path!s}"
+        case PlainDateTime() as datetime:
+            return f"[{_Prefixes.plain_date_time.value}]{datetime}"
         case str() as str_:
             return str_
+        case Time() as time:
+            return f"[{_Prefixes.time.value}]{time}"
+        case TimeDelta() as time_delta:
+            return f"[{_Prefixes.time_delta.value}]{time_delta}"
         case type() as error_cls if issubclass(error_cls, Exception):
             return f"[{_Prefixes.exception_class.value}|{error_cls.__qualname__}]"
+        case UUID() as uuid:
+            return f"[{_Prefixes.uuid.value}]{uuid}"
         case Version() as version:
             return f"[{_Prefixes.version.value}]{version!s}"
         case ZonedDateTime() as datetime:
-            return f"[{_Prefixes.zoned_datetime.value}]{datetime}"
+            return f"[{_Prefixes.zoned_date_time.value}]{datetime}"
         # contains
         case Dataclass() as dataclass:
             asdict = dataclass_to_dict(
@@ -338,51 +334,36 @@ def deserialize(
     )
 
 
-_NONE_PATTERN = re.compile(r"^\[" + _Prefixes.none.value + r"\]$")
-_LOCAL_DATETIME_PATTERN = re.compile(
-    r"^\["
-    + _Prefixes.datetime.value
-    + r"\](\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?)$"
-)
-_UUID_PATTERN = re.compile(r"^\[" + _Prefixes.uuid.value + r"\](" + UUID_PATTERN + ")$")
-_ZONED_DATETIME_PATTERN = re.compile(
-    r"^\["
-    + _Prefixes.datetime.value
-    + r"\](\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?[\+\-]\d{2}:\d{2}(?::\d{2})?\[(?!(?:dt\.)).+?\])$"
-)
-_ZONED_DATETIME_PATTERN2 = re.compile(
-    r"^\["
-    + _Prefixes.zoned_datetime.value
-    + r"\](\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?[\+\-]\d{2}:\d{2}(?::\d{2})?\[(?!(?:dt\.)).+?\])$"
-)
-
-
-def _make_unit_pattern(prefix: _Prefixes, /) -> Pattern[str]:
-    return re.compile(r"^\[" + prefix.value + r"\](.+)$")
-
-
 (
     _DATE_PATTERN,
+    _DATE_DELTA_PATTERN,
+    _DATE_TIME_DELTA_PATTERN,
     _FLOAT_PATTERN,
+    _NONE_PATTERN,
     _PATH_PATTERN,
+    _PLAIN_DATE_TIME_PATTERN,
     _TIME_PATTERN,
-    _TIMEDELTA_PATTERN,
+    _TIME_DELTA_PATTERN,
+    _UUID_PATTERN,
     _VERSION_PATTERN,
-) = map(
-    _make_unit_pattern,
-    [
+    _ZONED_DATE_TIME_PATTERN,
+) = [
+    re.compile(r"^\[" + p.value + r"\](" + ".*" + ")$")
+    for p in [
         _Prefixes.date,
+        _Prefixes.date_delta,
+        _Prefixes.date_time_delta,
         _Prefixes.float_,
+        _Prefixes.none,
         _Prefixes.path,
+        _Prefixes.plain_date_time,
         _Prefixes.time,
-        _Prefixes.timedelta,
+        _Prefixes.time_delta,
+        _Prefixes.uuid,
         _Prefixes.version,
-    ],
-)
-
-
-def _make_container_pattern(prefix: _Prefixes, /) -> Pattern[str]:
-    return re.compile(r"^\[" + prefix.value + r"(?:\|(.+))?\]$")
+        _Prefixes.zoned_date_time,
+    ]
+]
 
 
 (
@@ -394,9 +375,9 @@ def _make_container_pattern(prefix: _Prefixes, /) -> Pattern[str]:
     _LIST_PATTERN,
     _SET_PATTERN,
     _TUPLE_PATTERN,
-) = map(
-    _make_container_pattern,
-    [
+) = [
+    re.compile(r"^\[" + p.value + r"(?:\|(.+))?\]$")
+    for p in [
         _Prefixes.dataclass,
         _Prefixes.enum,
         _Prefixes.exception_class,
@@ -405,8 +386,8 @@ def _make_container_pattern(prefix: _Prefixes, /) -> Pattern[str]:
         _Prefixes.list_,
         _Prefixes.set_,
         _Prefixes.tuple_,
-    ],
-)
+    ]
+]
 
 
 def _object_hook(
@@ -425,24 +406,26 @@ def _object_hook(
             if match := _NONE_PATTERN.search(text):
                 return None
             if match := _DATE_PATTERN.search(text):
-                return parse_date(match.group(1))
+                return Date.parse_common_iso(match.group(1))
+            if match := _DATE_DELTA_PATTERN.search(text):
+                return DateDelta.parse_common_iso(match.group(1))
+            if match := _DATE_TIME_DELTA_PATTERN.search(text):
+                return DateTimeDelta.parse_common_iso(match.group(1))
             if match := _FLOAT_PATTERN.search(text):
                 return float(match.group(1))
-            if match := _LOCAL_DATETIME_PATTERN.search(text):
-                return parse_plain_datetime(match.group(1))
             if match := _PATH_PATTERN.search(text):
                 return Path(match.group(1))
+            if match := _PLAIN_DATE_TIME_PATTERN.search(text):
+                return PlainDateTime.parse_common_iso(match.group(1))
             if match := _TIME_PATTERN.search(text):
-                return parse_time(match.group(1))
-            if match := _TIMEDELTA_PATTERN.search(text):
-                return parse_timedelta(match.group(1))
+                return Time.parse_common_iso(match.group(1))
+            if match := _TIME_DELTA_PATTERN.search(text):
+                return TimeDelta.parse_common_iso(match.group(1))
             if match := _UUID_PATTERN.search(text):
                 return UUID(match.group(1))
             if match := _VERSION_PATTERN.search(text):
                 return parse_version(match.group(1))
-            if match := _ZONED_DATETIME_PATTERN.search(text):
-                return parse_zoned_datetime(match.group(1))
-            if match := _ZONED_DATETIME_PATTERN2.search(text):
+            if match := _ZONED_DATE_TIME_PATTERN.search(text):
                 return ZonedDateTime.parse_common_iso(match.group(1))
             if (
                 exc_class := _object_hook_exception_class(

utilities/parse.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime as dt
 from contextlib import suppress
 from dataclasses import dataclass
 from enum import Enum
@@ -9,6 +8,16 @@ from re import DOTALL
 from types import NoneType
 from typing import TYPE_CHECKING, Any, override
 
+from whenever import (
+    Date,
+    DateDelta,
+    DateTimeDelta,
+    PlainDateTime,
+    Time,
+    TimeDelta,
+    ZonedDateTime,
+)
+
 from utilities.enum import ParseEnumError, parse_enum
 from utilities.iterables import OneEmptyError, OneNonUniqueError, one, one_str
 from utilities.math import ParseNumberError, parse_number
@@ -26,7 +35,7 @@ from utilities.text import (
     split_key_value_pairs,
     split_str,
 )
-from utilities.types import Duration, Number, ParseObjectExtra, SerializeObjectExtra
+from utilities.types import Number, ParseObjectExtra, SerializeObjectExtra
 from utilities.typing import (
     get_args,
     is_dict_type,
@@ -182,6 +191,14 @@ def _parse_object_type(
             return parse_enum(text, cls, case_sensitive=case_sensitive)
         except ParseEnumError:
             raise _ParseObjectParseError(type_=cls, text=text) from None
+    if issubclass(
+        cls,
+        (Date, DateDelta, DateTimeDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime),
+    ):
+        try:
+            return cls.parse_common_iso(text)
+        except ValueError:
+            raise _ParseObjectParseError(type_=cls, text=text) from None
     if issubclass(cls, Path):
         return Path(text).expanduser()
     if issubclass(cls, Sentinel):
@@ -194,34 +211,6 @@ def _parse_object_type(
             return parse_version(text)
         except ParseVersionError:
             raise _ParseObjectParseError(type_=cls, text=text) from None
-    if is_subclass_gen(cls, dt.date):
-        from utilities.whenever import ParseDateError, parse_date
-
-        try:
-            return parse_date(text)
-        except ParseDateError:
-            raise _ParseObjectParseError(type_=cls, text=text) from None
-    if is_subclass_gen(cls, dt.datetime):
-        from utilities.whenever import ParseDateTimeError, parse_datetime
-
-        try:
-            return parse_datetime(text)
-        except ParseDateTimeError:
-            raise _ParseObjectParseError(type_=cls, text=text) from None
-    if issubclass(cls, dt.time):
-        from utilities.whenever import ParseTimeError, parse_time
-
-        try:
-            return parse_time(text)
-        except ParseTimeError:
-            raise _ParseObjectParseError(type_=cls, text=text) from None
-    if issubclass(cls, dt.timedelta):
-        from utilities.whenever import ParseTimedeltaError, parse_timedelta
-
-        try:
-            return parse_timedelta(text)
-        except ParseTimedeltaError:
-            raise _ParseObjectParseError(type_=cls, text=text) from None
     raise _ParseObjectParseError(type_=cls, text=text)
 
 
@@ -374,13 +363,6 @@ def _parse_object_union_type(type_: Any, text: str, /) -> Any:
             return parse_number(text)
         except ParseNumberError:
             raise _ParseObjectParseError(type_=type_, text=text) from None
-    if type_ is Duration:
-        from utilities.whenever import ParseDurationError, parse_duration
-
-        try:
-            return parse_duration(text)
-        except ParseDurationError:
-            raise _ParseObjectParseError(type_=type_, text=text) from None
     raise _ParseObjectParseError(type_=type_, text=text) from None
 
 
@@ -464,22 +446,11 @@ def serialize_object(
         obj, bool | int | float | str | Path | Sentinel | Version
     ):
         return str(obj)
-    if is_instance_gen(obj, dt.date):
-        from utilities.whenever import serialize_date
-
-        return serialize_date(obj)
-    if is_instance_gen(obj, dt.datetime):
-        from utilities.whenever import serialize_datetime
-
-        return serialize_datetime(obj)
-    if isinstance(obj, dt.time):
-        from utilities.whenever import serialize_time
-
-        return serialize_time(obj)
-    if isinstance(obj, dt.timedelta):
-        from utilities.whenever import serialize_timedelta
-
-        return serialize_timedelta(obj)
+    if isinstance(
+        obj,
+        (Date, DateDelta, DateTimeDelta, PlainDateTime, Time, TimeDelta, ZonedDateTime),
+    ):
+        return obj.format_common_iso()
     if isinstance(obj, Enum):
         return obj.name
     if isinstance(obj, dict):

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)