dycw-utilities 0.151.4__tar.gz → 0.151.6__tar.gz

{dycw_utilities-0.151.4 → dycw_utilities-0.151.6}/PKG-INFO

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

{dycw_utilities-0.151.4 → dycw_utilities-0.151.6}/pyproject.toml

@@ -232,7 +232,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.151.4"
+version = "0.151.6"
 
 [project.entry-points.pytest11]
 pytest-randomly = "utilities.pytest_plugins.pytest_randomly"
@@ -265,7 +265,7 @@ test = [
 # bump-my-version
 [tool.bumpversion]
 allow_dirty = true
-current_version = "0.151.4"
+current_version = "0.151.6"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

dycw_utilities-0.151.6/src/tests/test_atools.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from utilities.asyncio import sleep_td
+from utilities.atools import call_memoized, memoize
+from utilities.whenever import SECOND
+
+_DELTA = 0.1 * SECOND
+
+
+class TestCallMemoized:
+    async def test_main(self) -> None:
+        counter = 0
+
+        async def increment() -> int:
+            nonlocal counter
+            counter += 1
+            return counter
+
+        for i in range(1, 11):
+            assert (await call_memoized(increment)) == i
+            assert counter == i
+
+    async def test_refresh(self) -> None:
+        counter = 0
+
+        async def increment() -> int:
+            nonlocal counter
+            counter += 1
+            return counter
+
+        for _ in range(2):
+            assert (await call_memoized(increment, _DELTA)) == 1
+            assert counter == 1
+        await sleep_td(2 * _DELTA)
+        for _ in range(2):
+            assert (await call_memoized(increment, _DELTA)) == 2
+            assert counter == 2
+
+
+class TestMemoize:
+    async def test_main(self) -> None:
+        counter = 0
+
+        @memoize
+        async def increment() -> int:
+            nonlocal counter
+            counter += 1
+            return counter
+
+        for _ in range(10):
+            assert await increment() == 1
+            assert counter == 1
+
+    async def test_with_arguments(self) -> None:
+        counter = 0
+
+        @memoize(duration=_DELTA)
+        async def increment() -> int:
+            nonlocal counter
+            counter += 1
+            return counter
+
+        assert await increment() == 1
+        assert counter == 1
+        await sleep_td(2 * _DELTA)
+        assert await increment() == 2
+        assert counter == 2

{dycw_utilities-0.151.4 → dycw_utilities-0.151.6}/src/tests/test_whenever.py

@@ -64,6 +64,7 @@ from utilities.whenever import (
     ToMonthsAndDaysError,
     ToNanosecondsError,
     ToPyTimeDeltaError,
+    ToZonedDateTimeError,
     WheneverLogRecord,
     _MinMaxDatePeriodError,
     _RoundDateOrDateTimeDateTimeIntraDayWithWeekdayError,
@@ -1183,6 +1184,12 @@ class TestToYears:
             _ = to_years(delta)
 
 
+zoned_datetimes_2000 = zoned_datetimes(
+    min_value=ZonedDateTime(2000, 1, 1, tz=UTC.key),
+    max_value=ZonedDateTime(2000, 12, 31, tz=UTC.key),
+)
+
+
 class TestToZonedDateTime:
     @given(date_time=zoned_datetimes())
     def test_date_time(self, *, date_time: ZonedDateTime) -> None:
@@ -1192,6 +1199,17 @@ class TestToZonedDateTime:
     def test_none_or_sentinel(self, *, date_time: None | Sentinel) -> None:
         assert to_zoned_date_time(date_time=date_time) is date_time
 
+    @given(date_time=zoned_datetimes_2000)
+    def test_py_date_time_zone_info(self, *, date_time: ZonedDateTime) -> None:
+        assert to_zoned_date_time(date_time=date_time.py_datetime()) == date_time
+
+    @given(date_time=zoned_datetimes_2000)
+    def test_py_date_time_dt_utc(self, *, date_time: ZonedDateTime) -> None:
+        result = to_zoned_date_time(
+            date_time=date_time.py_datetime().astimezone(dt.UTC)
+        )
+        assert result == date_time
+
     @given(date_time1=zoned_datetimes(), date_time2=zoned_datetimes())
     def test_replace_non_sentinel(
         self, *, date_time1: ZonedDateTime, date_time2: ZonedDateTime
@@ -1217,6 +1235,13 @@ class TestToZonedDateTime:
     def test_callable(self, *, date_time: ZonedDateTime) -> None:
         assert to_zoned_date_time(date_time=lambda: date_time) == date_time
 
+    def test_error_py_date_time(self) -> None:
+        with raises(
+            ToZonedDateTimeError,
+            match=r"Expected date-time to have a `ZoneInfo` or `dt\.UTC` as its timezone; got None",
+        ):
+            _ = to_zoned_date_time(date_time=NOW_UTC.py_datetime().replace(tzinfo=None))
+
 
 class TestTwoDigitYearMonth:
     def test_parse_common_iso(self) -> None:

{dycw_utilities-0.151.4 → dycw_utilities-0.151.6}/src/utilities/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.151.4"
+__version__ = "0.151.6"

dycw_utilities-0.151.6/src/utilities/atools.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from functools import partial
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast, overload
+
+import atools
+from whenever import TimeDelta
+
+from utilities.types import Coro, PathLike
+
+if TYPE_CHECKING:
+    from atools._memoize_decorator import Keygen, Pickler
+
+
+type _Key[**P, T] = tuple[Callable[P, Coro[T]], TimeDelta]
+_MEMOIZED_FUNCS: dict[_Key, Callable[..., Coro[Any]]] = {}
+
+
+async def call_memoized[**P, T](
+    func: Callable[P, Coro[T]],
+    refresh: TimeDelta | None = None,
+    /,
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> T:
+    """Call an asynchronous function, with possible memoization."""
+    if refresh is None:
+        return await func(*args, **kwargs)
+    key: _Key = (func, refresh)
+    memoized_func: Callable[P, Coro[T]]
+    try:
+        memoized_func = _MEMOIZED_FUNCS[key]
+    except KeyError:
+        memoized_func = _MEMOIZED_FUNCS[(key)] = memoize(duration=refresh.in_seconds())(
+            func
+        )
+    return await memoized_func(*args, **kwargs)
+
+
+##
+
+
+@overload
+def memoize[F: Callable[..., Coro[Any]]](
+    func: F,
+    /,
+    *,
+    db_path: PathLike | None = None,
+    duration: float | TimeDelta | None = None,
+    keygen: Keygen | None = None,
+    pickler: Pickler | None = None,
+    size: int | None = None,
+) -> F: ...
+@overload
+def memoize[F: Callable[..., Coro[Any]]](
+    func: None = None,
+    /,
+    *,
+    db_path: PathLike | None = None,
+    duration: float | TimeDelta | None = None,
+    keygen: Keygen | None = None,
+    pickler: Pickler | None = None,
+    size: int | None = None,
+) -> Callable[[F], F]: ...
+def memoize[F: Callable[..., Coro[Any]]](
+    func: F | None = None,
+    /,
+    *,
+    db_path: PathLike | None = None,
+    duration: float | TimeDelta | None = None,
+    keygen: Keygen | None = None,
+    pickler: Pickler | None = None,
+    size: int | None = None,
+) -> F | Callable[[F], F]:
+    """Memoize a function."""
+    if func is None:
+        result = partial(
+            memoize,
+            db_path=db_path,
+            duration=duration,
+            keygen=keygen,
+            pickler=pickler,
+            size=size,
+        )
+        return cast("Callable[[F], F]", result)
+    return atools.memoize(
+        db_path=None if db_path is None else Path(db_path),
+        duration=duration.py_timedelta()
+        if isinstance(duration, TimeDelta)
+        else duration,
+        keygen=keygen,
+        pickler=pickler,
+        size=size,
+    )(func)
+
+
+__all__ = ["call_memoized"]

{dycw_utilities-0.151.4 → dycw_utilities-0.151.6}/src/utilities/whenever.py

@@ -16,6 +16,7 @@ from typing import (
     overload,
     override,
 )
+from zoneinfo import ZoneInfo
 
 from whenever import (
     Date,
@@ -36,8 +37,6 @@ from utilities.tzlocal import LOCAL_TIME_ZONE, LOCAL_TIME_ZONE_NAME
 from utilities.zoneinfo import UTC, get_time_zone_name
 
 if TYPE_CHECKING:
-    from zoneinfo import ZoneInfo
-
     from utilities.types import (
         DateOrDateTimeDelta,
         DateTimeRoundMode,
@@ -1418,22 +1417,40 @@ class _ToYearsTimeError(ToYearsError):
 
 
 @overload
-def to_zoned_date_time(*, date_time: MaybeCallableZonedDateTime) -> ZonedDateTime: ...
+def to_zoned_date_time(
+    *, date_time: MaybeCallableZonedDateTime | dt.datetime
+) -> ZonedDateTime: ...
 @overload
 def to_zoned_date_time(*, date_time: None) -> None: ...
 @overload
 def to_zoned_date_time(*, date_time: Sentinel) -> Sentinel: ...
 def to_zoned_date_time(
-    *, date_time: MaybeCallableZonedDateTime | None | Sentinel = sentinel
+    *, date_time: MaybeCallableZonedDateTime | dt.datetime | None | Sentinel = sentinel
 ) -> ZonedDateTime | None | Sentinel:
     """Resolve into a zoned date_time."""
     match date_time:
         case ZonedDateTime() | None | Sentinel():
             return date_time
+        case dt.datetime():
+            if isinstance(date_time.tzinfo, ZoneInfo):
+                return ZonedDateTime.from_py_datetime(date_time)
+            if date_time.tzinfo is dt.UTC:
+                return ZonedDateTime.from_py_datetime(date_time.astimezone(UTC))
+            raise ToZonedDateTimeError(date_time=date_time)
         case Callable() as func:
             return to_zoned_date_time(date_time=func())
         case _ as never:
             assert_never(never)
+    return None
+
+
+@dataclass(kw_only=True, slots=True)
+class ToZonedDateTimeError(Exception):
+    date_time: dt.datetime
+
+    @override
+    def __str__(self) -> str:
+        return f"Expected date-time to have a `ZoneInfo` or `dt.UTC` as its timezone; got {self.date_time.tzinfo}"
 
 
 ##

dycw_utilities-0.151.4/src/tests/test_atools.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-from utilities.asyncio import sleep_td
-from utilities.atools import call_memoized
-from utilities.whenever import SECOND
-
-
-class TestCallMemoized:
-    async def test_main(self) -> None:
-        counter = 0
-
-        async def increment() -> int:
-            nonlocal counter
-            counter += 1
-            return counter
-
-        for i in range(1, 3):
-            assert (await call_memoized(increment)) == i
-            assert counter == i
-
-    async def test_refresh(self) -> None:
-        counter = 0
-        delta = 0.1 * SECOND
-
-        async def increment() -> int:
-            nonlocal counter
-            counter += 1
-            return counter
-
-        for _ in range(2):
-            assert (await call_memoized(increment, delta)) == 1
-            assert counter == 1
-        await sleep_td(2 * delta)
-        for _ in range(2):
-            assert (await call_memoized(increment, delta)) == 2
-            assert counter == 2

dycw_utilities-0.151.4/src/utilities/atools.py

@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
-
-from atools import memoize
-
-from utilities.types import Coro
-
-if TYPE_CHECKING:
-    from whenever import TimeDelta
-
-
-type _Key[**P, T] = tuple[Callable[P, Coro[T]], TimeDelta]
-_MEMOIZED_FUNCS: dict[_Key, Callable[..., Coro[Any]]] = {}
-
-
-async def call_memoized[**P, T](
-    func: Callable[P, Coro[T]],
-    refresh: TimeDelta | None = None,
-    /,
-    *args: P.args,
-    **kwargs: P.kwargs,
-) -> T:
-    """Call an asynchronous function, with possible memoization."""
-    if refresh is None:
-        return await func(*args, **kwargs)
-    key: _Key = (func, refresh)
-    memoized_func: Callable[P, Coro[T]]
-    try:
-        memoized_func = _MEMOIZED_FUNCS[key]
-    except KeyError:
-        memoized_func = _MEMOIZED_FUNCS[(key)] = memoize(duration=refresh.in_seconds())(
-            func
-        )
-    return await memoized_func(*args, **kwargs)
-
-
-__all__ = ["call_memoized"]