glow 0.15.5__tar.gz → 0.15.7__tar.gz

{glow-0.15.5 → glow-0.15.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glow
-Version: 0.15.5
+Version: 0.15.7
 Summary: Functional Python tools
 Project-URL: homepage, https://github.com/arquolo/glow
 Author-email: Paul Maevskikh <arquolo@gmail.com>
@@ -40,6 +40,7 @@ Requires-Dist: lxml
 Requires-Dist: numpy<3,>=1.21
 Requires-Dist: tqdm
 Requires-Dist: typing-extensions~=4.1; python_version < '3.11'
+Requires-Dist: typing-inspection~=0.4.1
 Requires-Dist: wrapt~=1.15
 Provides-Extra: all
 Requires-Dist: asttokens; extra == 'all'

{glow-0.15.5 → glow-0.15.7}/pyproject.toml

@@ -7,7 +7,7 @@ only-packages = true
 
 [project]
 name = "glow"
-version = "0.15.5"
+version = "0.15.7"
 description = "Functional Python tools"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -33,6 +33,7 @@ dependencies = [
     "lxml",
     "numpy >=1.21, <3",
     "typing-extensions~=4.1; python_version < '3.11'",
+    "typing-inspection~=0.4.1",
     "tqdm",
     "wrapt~=1.15",
 ]

{glow-0.15.5 → glow-0.15.7}/src/glow/__init__.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 from . import _patch_len, _patch_print, _patch_scipy
 from ._array import aceil, afloor, apack, around, pascal
-from ._async import amap, amap_dict, astarmap, astreaming, azip
+from ._async import RwLock, amap, amap_dict, astarmap, astreaming, azip
 from ._cache import cache_status, memoize
 from ._concurrency import (
     call_once,
@@ -17,6 +17,7 @@ from ._concurrency import (
 )
 from ._coro import as_actor, coroutine, summary
 from ._debug import lock_seed, trace, trace_module, whereami
+from ._dev import hide_frame
 from ._import_hook import register_post_import_hook, when_imported
 from ._logging import init_loguru
 from ._more import (
@@ -69,6 +70,7 @@ else:
 
 __all__ = [
     'Reusable',
+    'RwLock',
     'Uid',
     'aceil',
     'afloor',
@@ -91,6 +93,7 @@ __all__ = [
     'eat',
     'get_executor',
     'groupby',
+    'hide_frame',
     'ic',
     'ic_repr',
     'ichunked',

{glow-0.15.5 → glow-0.15.7}/src/glow/_async.py

@@ -1,7 +1,7 @@
-__all__ = ['amap', 'amap_dict', 'astarmap', 'azip']
+__all__ = ['RwLock', 'amap', 'amap_dict', 'astarmap', 'azip']
 
 import asyncio
-from asyncio import Queue, Task
+from asyncio import Event, Future, Lock, Queue, Task, TaskGroup
 from collections import deque
 from collections.abc import (
     AsyncIterator,
@@ -12,22 +12,13 @@ from collections.abc import (
     Mapping,
     Sequence,
 )
-from contextlib import suppress
+from contextlib import asynccontextmanager, suppress
 from functools import partial
 from typing import TypeGuard, cast, overload
 
 from ._dev import hide_frame
-from ._futures import adispatch
-from ._types import (
-    ABatchDecorator,
-    ABatchFn,
-    AnyFuture,
-    AnyIterable,
-    AnyIterator,
-    Coro,
-)
-
-type _Job[T, R] = tuple[T, AnyFuture[R]]
+from ._futures import ABatchDecorator, ABatchFn, Job, adispatch
+from ._types import AnyIterable, AnyIterator, Coro
 
 
 async def amap_dict[K, T1, T2](
@@ -93,7 +84,7 @@ async def astarmap[*Ts, R](
                 yield await func(*args)
         return
 
-    async with asyncio.TaskGroup() as tg:
+    async with TaskGroup() as tg:
         ts = (
             (tg.create_task(func(*args)) for args in iterable)
             if isinstance(iterable, Iterable)
@@ -263,10 +254,10 @@ def astreaming[T, R](
     assert batch_size is None or batch_size >= 1
     assert timeout > 0
 
-    buf: list[_Job[T, R]] = []
+    buf: list[Job[T, R]] = []
     deadline = float('-inf')
-    not_last = asyncio.Event()
-    lock = asyncio.Lock()
+    not_last = Event()
+    lock = Lock()
     ncalls = 0
 
     async def wrapper(items: Sequence[T]) -> list[R]:
@@ -279,10 +270,10 @@ def astreaming[T, R](
             not_last.set()
 
         ncalls += 1
-        fs: list[asyncio.Future[R]] = []
+        fs: list[Future[R]] = []
         try:
             for x in items:
-                f = asyncio.Future[R]()
+                f = Future[R]()
                 fs.append(f)
                 buf.append((x, f))
 
@@ -314,3 +305,45 @@ def astreaming[T, R](
             return await asyncio.gather(*fs)
 
     return wrapper
+
+
+# ----------------------------- read/write guard -----------------------------
+
+
+class RwLock:
+    """Guard code from concurrent writes.
+
+    Reads are not limited.
+    When write is issued, new reads are delayed until write is finished.
+    """
+
+    def __init__(self) -> None:
+        self._num_reads = 0
+        self._readable = Event()
+        self._readable.set()
+        self._writable = Event()
+        self._writable.set()
+
+    @asynccontextmanager
+    async def read(self) -> AsyncIterator[None]:
+        await self._readable.wait()
+        self._writable.clear()
+        try:
+            yield
+        finally:
+            self._num_reads -= 1
+            if self._num_reads == 0:
+                self._writable.set()
+
+    @asynccontextmanager
+    async def write(self) -> AsyncIterator[None]:
+        self._readable.clear()  # Stop new READs
+        try:
+            await self._writable.wait()  # Wait for all READs or single WRITE
+            self._writable.clear()  # Only single WRITE is allowed
+            try:
+                yield
+            finally:
+                self._writable.set()
+        finally:
+            self._readable.set()

{glow-0.15.5 → glow-0.15.7}/src/glow/_async.pyi

@@ -1,7 +1,9 @@
 from collections.abc import AsyncIterator, Callable, Mapping
+from contextlib import AbstractAsyncContextManager
 from typing import Any, Required, TypedDict, Unpack, overload
 
-from ._types import ABatchDecorator, ABatchFn, AnyIterable, Coro
+from ._futures import ABatchDecorator, ABatchFn
+from ._types import AnyIterable, Coro
 
 class _AmapKwargs(TypedDict, total=False):
     limit: Required[int]
@@ -106,3 +108,8 @@ def astreaming[T, R](
     batch_size: int | None = ...,
     timeout: float = ...,
 ) -> ABatchFn[T, R]: ...
+
+class RwLock:
+    def __init__(self) -> None: ...
+    def read(self) -> AbstractAsyncContextManager: ...
+    def write(self) -> AbstractAsyncContextManager: ...

{glow-0.15.5 → glow-0.15.7}/src/glow/_cache.py

@@ -21,20 +21,19 @@ from typing import Any, Final, Protocol, SupportsInt, cast
 from weakref import WeakValueDictionary
 
 from ._dev import clone_exc, hide_frame
-from ._futures import adispatch, dispatch, gather_fs
-from ._keys import make_key
-from ._repr import si_bin
-from ._sizeof import sizeof
-from ._types import (
+from ._futures import (
     ABatchFn,
     AnyFuture,
     BatchFn,
-    CachePolicy,
-    Decorator,
     Job,
-    KeyFn,
-    Some,
+    adispatch,
+    dispatch,
+    gather_fs,
 )
+from ._keys import make_key
+from ._repr import si_bin
+from ._sizeof import sizeof
+from ._types import CachePolicy, Decorator, KeyFn, Some
 
 
 class _Empty(enum.Enum):

{glow-0.15.5 → glow-0.15.7}/src/glow/_cache.pyi

@@ -1,6 +1,7 @@
 from typing import Literal, overload
 
-from ._types import AnyBatchDecorator, CachePolicy, Decorator, KeyFn
+from ._futures import AnyBatchDecorator
+from ._types import CachePolicy, Decorator, KeyFn
 
 def cache_status() -> str: ...
 

{glow-0.15.5 → glow-0.15.7}/src/glow/_concurrency.py

@@ -19,15 +19,15 @@ from warnings import warn
 
 from ._cache import memoize
 from ._dev import hide_frame
-from ._futures import dispatch, gather_fs
-from ._types import BatchDecorator, BatchFn
+from ._futures import BatchDecorator, BatchFn, Job, dispatch, gather_fs
+from ._types import Get
 
 _PATIENCE = 0.01
 
 
-def threadlocal[T](
-    fn: Callable[..., T], /, *args: object, **kwargs: object
-) -> Callable[[], T]:
+def threadlocal[**P, T](
+    fn: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs
+) -> Get[T]:
     """Create thread-local singleton factory function (functools.partial)."""
     local_ = threading.local()
 
@@ -41,7 +41,7 @@ def threadlocal[T](
     return update_wrapper(wrapper, fn)
 
 
-def call_once[T](fn: Callable[[], T], /) -> Callable[[], T]:
+def call_once[T](fn: Get[T], /) -> Get[T]:
     """Make callable a singleton.
 
     Supports async-def functions (but not async-gen functions).
@@ -81,8 +81,6 @@ def weak_memoize[**P, R](fn: Callable[P, R], /) -> Callable[P, R]:
 
 # ----------------------------- batch collation ------------------------------
 
-type _Job[T, R] = tuple[T, Future[R]]
-
 
 def _fetch_batch[T](
     q: SimpleQueue[T], batch_size: int | None, timeout: float
@@ -120,7 +118,7 @@ def _start_fetch_compute[T, R](
     workers: int,
     batch_size: int | None,
     timeout: float,
-) -> SimpleQueue[_Job[T, R]]:
+) -> SimpleQueue[Job[T, R]]:
     q = SimpleQueue()  # type: ignore[var-annotated]
     lock = Lock()
 

{glow-0.15.5 → glow-0.15.7}/src/glow/_concurrency.pyi

@@ -2,13 +2,14 @@ from collections.abc import Callable
 from contextlib import AbstractContextManager
 from typing import overload
 
-from ._types import BatchDecorator, BatchFn
+from ._futures import BatchDecorator, BatchFn
+from ._types import Get
 
 def threadlocal[T, **P](
-    fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs
-) -> Callable[[], T]: ...
+    fn: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs
+) -> Get[T]: ...
 def interpreter_lock(timeout: float = ...) -> AbstractContextManager[None]: ...
-def call_once[T](fn: Callable[[], T], /) -> Callable[[], T]: ...
+def call_once[T](fn: Get[T], /) -> Get[T]: ...
 def shared_call[**P, R](fn: Callable[P, R], /) -> Callable[P, R]: ...
 def weak_memoize[**P, R](fn: Callable[P, R], /) -> Callable[P, R]: ...
 @overload

{glow-0.15.5 → glow-0.15.7}/src/glow/_coro.py

@@ -29,7 +29,7 @@ class _Sync[Y, S, R](wrapt.ObjectProxy):  # type: ignore[misc]
         self._self_lock = Lock()
 
     def _call[**P, T](
-        self, op: Callable[P, T], *args: P.args, **kwargs: P.kwargs
+        self, op: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs
     ) -> T:
         with self._self_lock:
             return op(*args, **kwargs)

{glow-0.15.5 → glow-0.15.7}/src/glow/_debug.py

@@ -3,12 +3,11 @@ __all__ = ['lock_seed', 'trace', 'trace_module', 'whereami']
 import gc
 import os
 import random
-import types
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from contextlib import suppress
 from inspect import currentframe, getmodule, isfunction
 from itertools import islice
-from types import FrameType
+from types import FrameType, ModuleType
 
 import numpy as np
 import wrapt
@@ -74,12 +73,19 @@ def trace(fn, _, args, kwargs):
     return fn(*args, **kwargs)
 
 
-def _set_trace(obj, seen=None, prefix=None, module=None):
+def _set_trace(
+    obj: ModuleType | Callable,
+    *,
+    seen: set[str] | None = None,
+    prefix: str | None = None,
+    module: ModuleType | None = None,
+) -> None:
     # TODO: rewrite using unittest.mock
-    if isinstance(obj, types.ModuleType):
+    if isinstance(obj, ModuleType):
         if seen is None:
             seen = set()
             prefix = obj.__name__
+        assert isinstance(prefix, str)
         if not obj.__name__.startswith(prefix) or obj.__name__ in seen:
             return
         seen.add(obj.__name__)
@@ -91,6 +97,7 @@ def _set_trace(obj, seen=None, prefix=None, module=None):
     if not callable(obj):
         return
 
+    assert isinstance(module, ModuleType)
     if not hasattr(obj, '__dict__'):
         setattr(module, obj.__qualname__, trace(obj))
         print(f'wraps "{module.__name__}:{obj.__qualname__}"')
@@ -113,7 +120,7 @@ def _set_trace(obj, seen=None, prefix=None, module=None):
             print(f'wraps "{module.__name__}:{obj.__qualname__}.{name}"')
 
 
-def trace_module(name):
+def trace_module(name: str) -> None:
     """Enable call logging for each callable inside module name."""
     register_post_import_hook(_set_trace, name)
 

{glow-0.15.5 → glow-0.15.7}/src/glow/_futures.py

@@ -1,9 +1,29 @@
 import asyncio
 import concurrent.futures as cf
-from collections.abc import Hashable, Iterable, Sequence
+from collections.abc import Callable, Hashable, Iterable, Sequence
+from typing import Protocol, overload
 
 from ._dev import hide_frame
-from ._types import ABatchFn, AnyFuture, BatchFn, Job, Some
+from ._types import Coro, Some
+
+type AnyFuture[R] = cf.Future[R] | asyncio.Future[R]
+type Job[T, R] = tuple[T, AnyFuture[R]]
+
+type BatchFn[T, R] = Callable[[Sequence[T]], Sequence[R]]
+type ABatchFn[T, R] = Callable[[Sequence[T]], Coro[Sequence[R]]]
+
+
+class BatchDecorator(Protocol):
+    def __call__[T, R](self, fn: BatchFn[T, R], /) -> BatchFn[T, R]: ...
+class ABatchDecorator(Protocol):
+    def __call__[T, R](self, fn: ABatchFn[T, R], /) -> ABatchFn[T, R]: ...
+
+
+class AnyBatchDecorator(Protocol):
+    @overload
+    def __call__[T, R](self, fn: BatchFn[T, R], /) -> BatchFn[T, R]: ...
+    @overload
+    def __call__[T, R](self, fn: ABatchFn[T, R], /) -> ABatchFn[T, R]: ...
 
 
 def dispatch[T, R](fn: BatchFn[T, R], *xs: Job[T, R]) -> None:

{glow-0.15.5 → glow-0.15.7}/src/glow/_import_hook.py

@@ -7,11 +7,11 @@ from importlib.machinery import ModuleSpec
 from threading import RLock
 from types import ModuleType
 
-type _Hook = Callable[[ModuleType], object]
+from ._types import Callback
 
 _INITIALIZED = False
 _LOCK = RLock()
-_HOOKS: dict[str, list[_Hook]] = {}
+_HOOKS: dict[str, list[Callback[ModuleType]]] = {}
 
 
 class _ImportHookChainedLoader(abc.Loader):
@@ -71,7 +71,7 @@ class _ImportHookFinder(abc.MetaPathFinder, set[str]):
         return None
 
 
-def register_post_import_hook(hook: _Hook, name: str) -> None:
+def register_post_import_hook(hook: Callback[ModuleType], name: str) -> None:
     """Register a new post import hook for the target module name.
 
     This will result in a proxy callback being registered which will defer
@@ -92,7 +92,7 @@ def register_post_import_hook(hook: _Hook, name: str) -> None:
             hook(module)
 
 
-def when_imported[H: _Hook](name: str) -> Callable[[H], H]:
+def when_imported[H: Callback[ModuleType]](name: str) -> Callable[[H], H]:
     """Create decorator making a function a post import hook for a module.
 
     Simplified version of wrapt.when_imported.