glow 0.15.5__tar.gz → 0.15.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glow
-Version: 0.15.5
+Version: 0.15.6
 Summary: Functional Python tools
 Project-URL: homepage, https://github.com/arquolo/glow
 Author-email: Paul Maevskikh <arquolo@gmail.com>

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

@@ -7,7 +7,7 @@ only-packages = true
 
 [project]
 name = "glow"
-version = "0.15.5"
+version = "0.15.6"
 description = "Functional Python tools"
 readme = "README.md"
 requires-python = ">=3.12"

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

@@ -17,17 +17,8 @@ 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](
@@ -263,7 +254,7 @@ 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()

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

@@ -1,7 +1,8 @@
 from collections.abc import AsyncIterator, Callable, Mapping
 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]

{glow-0.15.5 → glow-0.15.6}/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.6}/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.6}/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.6}/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.6}/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.6}/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.6}/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.6}/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.

{glow-0.15.5 → glow-0.15.6}/src/glow/_parallel.py

@@ -40,7 +40,7 @@ from ._dev import hide_frame
 from ._more import chunked, ilen
 from ._reduction import move_to_shmem, reducers
 from ._thread_quota import ThreadQuota
-from ._types import Some
+from ._types import Get, Some
 
 _TOTAL_CPUS = (
     os.process_cpu_count() if sys.version_info >= (3, 13) else os.cpu_count()
@@ -115,12 +115,16 @@ def max_cpu_count(upper_bound: int = sys.maxsize, *, mp: bool = False) -> int:
 _PATIENCE = 0.01
 
 
-def _retry_call[T](fn: Callable[..., T], *exc: type[BaseException]) -> T:
+class _TimeoutCallable[T](Protocol):
+    def __call__(self, *, timeout: float) -> T: ...
+
+
+def _retry_call[T](fn: _TimeoutCallable[T], *exc: type[BaseException]) -> T:
     # See issues
-    # https://bugs.python.org/issue29971
-    # https://github.com/python/cpython/issues/74157
     # https://github.com/dask/dask/pull/2144#issuecomment-290556996
     # https://github.com/dask/dask/pull/2144/files
+    # https://github.com/python/cpython/issues/74157
+    # FIXED in py3.15+
     while True:
         try:
             return fn(timeout=_PATIENCE)
@@ -146,7 +150,7 @@ def _result[T](f: Future[T], cancel: bool = True) -> Some[T] | BaseException:
         del f
 
 
-def _q_get_fn[T](q: _Queue[T]) -> Callable[[], T]:
+def _q_get_fn[T](q: _Queue[T]) -> Get[T]:
     if sys.platform != 'win32':
         return q.get
     return partial(_retry_call, q.get, Empty)
@@ -377,7 +381,7 @@ def _schedule_auto_v2[F: Future](
 def _get_unwrap_iter[T](
     s: ExitStack,
     qsize: int,
-    get_done_f: Callable[[], Future[T]],
+    get_done_f: Get[Future[T]],
     fs_scheduler: Iterator,
 ) -> Iterator[T]:
     with s:

{glow-0.15.5 → glow-0.15.6}/src/glow/_profile.py

@@ -13,6 +13,8 @@ from typing import TYPE_CHECKING
 from ._debug import whereami
 from ._repr import si, si_bin
 from ._streams import Stream, cumsum, maximum_cumsum
+from ._types import Callback, Get
+
 from ._wrap import wrap
 
 if TYPE_CHECKING:
@@ -25,7 +27,7 @@ _THIS = None
 
 @contextmanager
 def memprof(
-    name_or_callback: str | Callable[[float], object] | None = None, /
+    name_or_callback: str | Callback[float] | None = None, /
 ) -> Iterator[None]:
     global _THIS  # noqa: PLW0603
     if _THIS is None:
@@ -50,9 +52,7 @@ def memprof(
 
 @contextmanager
 def _timer_callback(
-    callback: Callable[[int], object],
-    time: Callable[[], int] = perf_counter_ns,
-    /,
+    callback: Callback[int], time: Get[int] = perf_counter_ns, /
 ) -> Iterator[None]:
     begin = time()
     try:
@@ -63,7 +63,7 @@ def _timer_callback(
 
 @contextmanager
 def _timer_print(
-    name: str | None = None, time: Callable[[], int] = perf_counter_ns, /
+    name: str | None = None, time: Get[int] = perf_counter_ns, /
 ) -> Iterator[None]:
     begin = time()
     try:
@@ -75,8 +75,8 @@ def _timer_print(
 
 
 def timer(
-    name_or_callback: str | Callable[[int], object] | None = None,
-    time: Callable[[], int] = perf_counter_ns,
+    name_or_callback: str | Callback[int] | None = None,
+    time: Get[int] = perf_counter_ns,
     /,
     *,
     disable: bool = False,
@@ -109,7 +109,7 @@ class _Profiler:
     # Idle time - elapsed I/O time (like time.sleep, lock.acquire, e.t.c.).
     idle_ns: Stream[int, int] = field(default_factory=cumsum)
 
-    def suspend(self) -> Callable[[], None]:
+    def suspend(self) -> Get[None]:
         self.idle_ns.send(-perf_counter_ns())
         return self.resume
 

{glow-0.15.5 → glow-0.15.6}/src/glow/_profile.pyi

@@ -2,21 +2,23 @@ from collections.abc import Callable
 from contextlib import AbstractContextManager
 from typing import overload
 
+from ._types import Callback, Decorator, Get
+
 def memprof(
-    name_or_callback: str | Callable[[float], object] | None = ..., /
+    name_or_callback: str | Callback[float] | None = ..., /
 ) -> AbstractContextManager[None]: ...
 @overload
 def timer(
     name: str | None = ...,
-    time: Callable[[], int] = ...,
+    time: Get[int] = ...,
     /,
     *,
     disable: bool = ...,
 ) -> AbstractContextManager[None]: ...
 @overload
 def timer(
-    callback: Callable[[int], object] | None,
-    time: Callable[[], int] = ...,
+    callback: Callback[int] | None,
+    time: Get[int] = ...,
     /,
     *,
     disable: bool = ...,
@@ -26,6 +28,4 @@ def time_this[**P, R](
     fn: Callable[P, R], /, *, name: str | None = ..., disable: bool = ...
 ) -> Callable[P, R]: ...
 @overload
-def time_this[**P, R](
-    *, name: str | None = ..., disable: bool = ...
-) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
+def time_this(*, name: str | None = ..., disable: bool = ...) -> Decorator: ...

{glow-0.15.5 → glow-0.15.6}/src/glow/_reduction.py

@@ -16,6 +16,7 @@ from pathlib import Path
 import loky
 
 from ._import_hook import when_imported
+from ._types import Callback
 
 _SYSTEM_SHM_MIN_SIZE = int(2e9)
 _SYSTEM_SHM = Path('/dev/shm')
@@ -109,7 +110,7 @@ def _torch_hook(torch) -> None:
 
 def _dumps(
     obj: object,
-    callback: Callable[[pickle.PickleBuffer], object] | None = None,
+    callback: Callback[pickle.PickleBuffer] | None = None,
 ) -> bytes:
     fp = io.BytesIO()
     p = pickle.Pickler(fp, -1, buffer_callback=callback)

{glow-0.15.5 → glow-0.15.6}/src/glow/_streams.py

@@ -1,16 +1,17 @@
 __all__ = ['Stream', 'cumsum', 'maximum_cumsum']
 
 from collections import deque
-from collections.abc import Callable
 from dataclasses import dataclass
 from itertools import accumulate
 
+from ._types import Callback, Get
+
 
 @dataclass(frozen=True, slots=True, repr=False)
 class Stream[Y, S]:
     init: S
-    push: Callable[[S], None]
-    pop: Callable[[], Y]
+    push: Callback[S]
+    pop: Get[Y]
 
     def send(self, value: S) -> Y:
         self.push(value)

glow-0.15.6/src/glow/_types.py

@@ -0,0 +1,31 @@
+from collections.abc import (
+    AsyncIterable,
+    AsyncIterator,
+    Callable,
+    Coroutine,
+    Hashable,
+    Iterable,
+    Iterator,
+)
+from dataclasses import dataclass
+from typing import Any, Literal, Protocol
+
+type KeyFn[H: Hashable] = Callable[..., H]
+
+type Coro[T] = Coroutine[Any, Any, T]
+type AnyIterable[T] = AsyncIterable[T] | Iterable[T]
+type AnyIterator[T] = AsyncIterator[T] | Iterator[T]
+
+type Get[T] = Callable[[], T]
+type Callback[T] = Callable[[T], object]
+
+type CachePolicy = Literal['lru', 'mru'] | None
+
+
+@dataclass(frozen=True, slots=True)
+class Some[T]:
+    x: T
+
+
+class Decorator(Protocol):
+    def __call__[**P, R](self, fn: Callable[P, R], /) -> Callable[P, R]: ...

{glow-0.15.5 → glow-0.15.6}/src/glow/_uuid.py

@@ -7,6 +7,11 @@ from functools import lru_cache
 from typing import Self, SupportsInt
 from uuid import UUID, uuid4
 
+try:
+    from pydantic_core import core_schema
+except ImportError:
+    core_schema = None  # type: ignore[assignment]
+
 ALPHABET = string.digits + string.ascii_letters
 ALPHABET = ''.join(sorted({*ALPHABET} - {*'0O1Il'}))
 
@@ -84,7 +89,8 @@ class Uid(UUID):
 
     @classmethod  # Pydantic 2.x requirement
     def __get_pydantic_core_schema__(cls, _, handler):
-        from pydantic_core import core_schema
+        if core_schema is None:
+            raise ImportError('Cannot import `pydantic_core` module')
 
         return core_schema.no_info_after_validator_function(
             cls,

{glow-0.15.5 → glow-0.15.6}/src/glow/_wrap.py

@@ -6,6 +6,8 @@ from typing import Any, Protocol, Self
 
 from wrapt import ObjectProxy
 
+from ._types import Get
+
 
 def wrap[**P, R](func: Callable[P, R], wrapper: '_Wrapper') -> Callable[P, R]:
     return _Callable(func, wrapper)
@@ -23,7 +25,7 @@ class _Wrapper(Protocol):
     #   ...
     #   resume()
     #   fn(*args, **kwargs)
-    def suspend(self) -> Callable[[], None]: ...
+    def suspend(self) -> Get[None]: ...
 
     # This one start right before function was called,
     # and stops right after it returned.

{glow-0.15.5 → glow-0.15.6}/src/glow/cli.py

@@ -206,9 +206,14 @@ def _visit_field(
         arg_group = parser.add_argument_group(fd.name)
         return fd.name, cls, _visit_nested(arg_group, cls, seen)
 
-    if (vtp := opts['type']) not in {int, float, str, bool}:
+    vtp = opts['type']
+    if (
+        isinstance(vtp, type)
+        and issubclass(vtp, Iterable)
+        and not issubclass(vtp, str)
+    ):
         msg = (
-            'Only bool, int, float and str are supported as value types. '
+            'Iterable value types are supported only as generics. '
             f'Got: {vtp}'
         )
         raise TypeError(msg)
@@ -292,7 +297,7 @@ def parse_args[T](
 
 
 def _import_from_string(qualname: str):
-    modname, _, attrname = qualname.partition(":")
+    modname, _, attrname = qualname.partition(':')
     if not modname or not attrname:
         msg = (
             f'Import string "{qualname}" must be '
@@ -300,13 +305,7 @@ def _import_from_string(qualname: str):
         )
         raise ImportError(msg)
 
-    try:
-        mod = importlib.import_module(modname)
-    except ModuleNotFoundError as exc:
-        if exc.name != modname:
-            raise
-        msg = f'Could not import module "{modname}".'
-        raise ImportError(msg) from None
+    mod = importlib.import_module(modname)
 
     obj: Any = mod
     try:
@@ -314,7 +313,7 @@ def _import_from_string(qualname: str):
             obj = getattr(obj, a)
     except AttributeError:
         msg = f'Attribute "{attrname}" not found in module "{modname}".'
-        raise AttributeError(msg)
+        raise AttributeError(msg) from None
     return obj
 
 

{glow-0.15.5 → glow-0.15.6}/src/glow/cli.pyi

@@ -2,6 +2,8 @@ from argparse import ArgumentParser
 from collections.abc import Callable, Mapping, Sequence
 from typing import Any, overload
 
+from ._types import Get
+
 @overload
 def arg[T](
     default: T,
@@ -18,7 +20,7 @@ def arg[T](
 @overload
 def arg[T](
     *,
-    factory: Callable[[], T],
+    factory: Get[T],
     flag: str = ...,
     init: bool = ...,
     repr: bool = ...,

{glow-0.15.5 → glow-0.15.6}/src/glow/io/_sound.py

@@ -13,27 +13,39 @@ from tqdm.auto import tqdm
 
 from .. import chunked
 
+try:
+    from sounddevice import CallbackAbort, CallbackStop, OutputStream
+except ImportError:
+    OutputStream = None
+    CallbackAbort = CallbackStop = Exception
+
+try:
+    import soundfile
+except ImportError:
+    soundfile = None
+
 
 def _play(
     arr: np.ndarray, rate: int, blocksize: int = 1024, bufsize: int = 20
 ) -> None:
     """Play audio from array. Crtl-C to interrupt."""
-    import sounddevice as sd
+    if OutputStream is None:
+        raise ImportError('Cannot import `sounddevice` module')
 
     q: Queue[np.ndarray | None] = Queue(bufsize)
     ev = Event()
 
     def callback(out: np.ndarray, *_) -> None:
         if (data := q.get()) is None:
-            raise sd.CallbackAbort
+            raise CallbackAbort
 
         size = len(data)
         out[:size] = data
         if size < len(out):
             out[size:] = 0
-            raise sd.CallbackStop
+            raise CallbackStop
 
-    stream = sd.OutputStream(
+    stream = OutputStream(
         rate, blocksize, callback=callback, finished_callback=ev.set
     )
 
@@ -127,16 +139,16 @@ class Sound[S: np.number]:
 
     @classmethod
     def load(cls, path: Path | str) -> 'Sound':
+        if soundfile is None:
+            raise ImportError('Cannot import `soundfile` module')
         _check_fmt(path)
-        import soundfile
-
         data, rate = soundfile.read(path)
         return cls(data.astype('f'), rate)
 
     def save(self, path: Path | str) -> None:
+        if soundfile is None:
+            raise ImportError('Cannot import `soundfile` module')
         _check_fmt(path)
-        import soundfile
-
         soundfile.write(path, self.data, self.rate)
 
 

{glow-0.15.5 → glow-0.15.6}/test/test_cli.py

@@ -1,5 +1,6 @@
 from collections.abc import Callable
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Literal
 
 import pytest
@@ -75,6 +76,11 @@ class NestedAliased:  # Forbidden as all field names must be unique
     nested: Aliased
 
 
+@dataclass
+class Custom:
+    arg: Path
+
+
 @pytest.mark.parametrize(
     ('argv', 'expected'),
     [
@@ -91,6 +97,7 @@ class NestedAliased:  # Forbidden as all field names must be unique
         (['--param', 'world'], Optional_('world')),
         (['value'], Nested('value', Optional_())),
         (['value', '--param', 'pvalue'], Nested('value', Optional_('pvalue'))),
+        (['test.txt'], Custom(Path('test.txt'))),
     ],
 )
 def test_good_class(argv: list[str], expected: Any):

glow-0.15.5/src/glow/_types.py

@@ -1,53 +0,0 @@
-import asyncio
-import concurrent.futures as cf
-from collections.abc import (
-    AsyncIterable,
-    AsyncIterator,
-    Callable,
-    Coroutine,
-    Hashable,
-    Iterable,
-    Iterator,
-    Sequence,
-)
-from dataclasses import dataclass
-from typing import Any, Literal, Protocol, overload
-
-type KeyFn[H: Hashable] = Callable[..., H]
-
-type Coro[T] = Coroutine[Any, Any, T]
-type AnyIterable[T] = AsyncIterable[T] | Iterable[T]
-type AnyIterator[T] = AsyncIterator[T] | Iterator[T]
-
-type BatchFn[T, R] = Callable[[Sequence[T]], Sequence[R]]
-type ABatchFn[T, R] = Callable[[Sequence[T]], Coro[Sequence[R]]]
-
-type AnyFuture[R] = cf.Future[R] | asyncio.Future[R]
-type Job[T, R] = tuple[T, AnyFuture[R]]
-
-type Get[T] = Callable[[], T]
-type Callback[T] = Callable[[T], object]
-
-type CachePolicy = Literal['lru', 'mru'] | None
-
-
-@dataclass(frozen=True, slots=True)
-class Some[T]:
-    x: T
-
-
-class Decorator(Protocol):
-    def __call__[**P, R](self, fn: Callable[P, R], /) -> Callable[P, 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]: ...