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

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

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

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

@@ -232,7 +232,7 @@ dependencies = [
 name = "dycw-utilities"
 readme = "README.md"
 requires-python = ">= 3.12"
-version = "0.151.4"
+version = "0.151.5"
 
 [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.5"
 
 [[tool.bumpversion.files]]
 filename = "src/utilities/__init__.py"

dycw_utilities-0.151.5/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.5}/src/utilities/__init__.py

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

dycw_utilities-0.151.5/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/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"]