glow 0.15.6__tar.gz → 0.15.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: glow
-Version: 0.15.6
+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.6 → glow-0.15.7}/pyproject.toml

@@ -7,7 +7,7 @@ only-packages = true
 
 [project]
 name = "glow"
-version = "0.15.6"
+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.6 → 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.6 → 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,7 +12,7 @@ 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
 
@@ -84,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)
@@ -256,8 +256,8 @@ def astreaming[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]:
@@ -270,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))
 
@@ -305,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.6 → glow-0.15.7}/src/glow/_async.pyi

@@ -1,4 +1,5 @@
 from collections.abc import AsyncIterator, Callable, Mapping
+from contextlib import AbstractAsyncContextManager
 from typing import Any, Required, TypedDict, Unpack, overload
 
 from ._futures import ABatchDecorator, ABatchFn
@@ -107,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.6 → glow-0.15.7}/src/glow/_parallel.py

@@ -9,6 +9,7 @@ __all__ = [
 
 import atexit
 import enum
+import logging
 import os
 import signal
 import sys
@@ -20,7 +21,6 @@ from contextlib import ExitStack, contextmanager
 from cProfile import Profile
 from functools import partial
 from itertools import chain, islice, starmap
-from logging import getLogger
 from multiprocessing.managers import BaseManager
 from operator import methodcaller
 from pstats import Stats
@@ -42,6 +42,8 @@ from ._reduction import move_to_shmem, reducers
 from ._thread_quota import ThreadQuota
 from ._types import Get, Some
 
+_LOGGER = logging.getLogger(__name__)
+
 _TOTAL_CPUS = (
     os.process_cpu_count() if sys.version_info >= (3, 13) else os.cpu_count()
 )
@@ -50,9 +52,11 @@ _NUM_CPUS = _TOTAL_CPUS or 0
 if (_env_cpus := os.getenv('GLOW_CPUS')) is not None:
     _NUM_CPUS = min(_NUM_CPUS, int(_env_cpus))
     _NUM_CPUS = max(_NUM_CPUS, 0)
+
 _IDLE_WORKER_TIMEOUT = 10
-_GRANULAR_SCHEDULING = False  # TODO: investigate whether this improves load
-_LOGGER = getLogger(__name__)
+# TODO: investigate whether this improves load
+_FAST_GROW = False
+_GRANULAR_SCHEDULING = False
 
 
 class _Empty(enum.Enum):
@@ -79,19 +83,16 @@ class _Manager(Protocol):
     def Queue(self, /, maxsize: int) -> _Queue: ...  # noqa: N802
 
 
-def _get_cpu_count_limits(
-    upper_bound: int = sys.maxsize, *, mp: bool = False
-) -> Iterator[int]:
-    yield from (upper_bound, _TOTAL_CPUS or 1)
-
+def _torch_limit() -> int | None:
     # Windows platform lacks memory overcommit, so it's sensitive to VMS growth
-    if not mp or sys.platform != 'win32' or 'torch' not in sys.modules:
-        return
+    if sys.platform != 'win32':
+        return None
 
-    if (sys.modules['torch'].version.cuda or '') >= '11.7.0':
+    torch = sys.modules.get('torch')
+    if torch is None or (torch.version.cuda or '') >= '11.7.0':
         # It's expected that torch will fix .nv_fatb readonly flag in its DLLs
         # See https://stackoverflow.com/a/69489193/9868257
-        return
+        return None
 
     if psutil is None:
         warnings.warn(
@@ -100,16 +101,24 @@ def _get_cpu_count_limits(
             'Install psutil to avoid that',
             stacklevel=3,
         )
-        return
+        return None
 
-    # Overcommit on Windows is forbidden, thus VMS planning is necessary
+    # Windows has no overcommit, checking how much processes fit into VMS
     vms: int = psutil.Process().memory_info().vms
     free_vms: int = psutil.virtual_memory().free + psutil.swap_memory().free
-    yield free_vms // vms
+    return free_vms // vms
+
 
+def max_cpu_count(limit: int | None = None, *, mp: bool = False) -> int:
+    limits = [_TOTAL_CPUS or 1]
 
-def max_cpu_count(upper_bound: int = sys.maxsize, *, mp: bool = False) -> int:
-    return min(_get_cpu_count_limits(upper_bound, mp=mp))
+    if limit is not None:
+        limits.append(limit)
+
+    if mp and (torch_limit := _torch_limit()) is not None:
+        limits.append(torch_limit)
+
+    return min(limits)
 
 
 _PATIENCE = 0.01
@@ -119,7 +128,7 @@ class _TimeoutCallable[T](Protocol):
     def __call__(self, *, timeout: float) -> T: ...
 
 
-def _retry_call[T](fn: _TimeoutCallable[T], *exc: type[BaseException]) -> T:
+def _retrying[T](f: _TimeoutCallable[T], *exc: type[BaseException]) -> T:
     # See issues
     # https://github.com/dask/dask/pull/2144#issuecomment-290556996
     # https://github.com/dask/dask/pull/2144/files
@@ -127,7 +136,7 @@ def _retry_call[T](fn: _TimeoutCallable[T], *exc: type[BaseException]) -> T:
     # FIXED in py3.15+
     while True:
         try:
-            return fn(timeout=_PATIENCE)
+            return f(timeout=_PATIENCE)
         except exc:
             sleep(0)  # Force switch to another thread to proceed
 
@@ -135,7 +144,7 @@ def _retry_call[T](fn: _TimeoutCallable[T], *exc: type[BaseException]) -> T:
 if sys.platform == 'win32':
 
     def _exception[T](f: Future[T], /) -> BaseException | None:
-        return _retry_call(f.exception, TimeoutError)
+        return _retrying(f.exception, TimeoutError)
 
 else:
     _exception = Future.exception
@@ -153,7 +162,7 @@ def _result[T](f: Future[T], cancel: bool = True) -> Some[T] | BaseException:
 def _q_get_fn[T](q: _Queue[T]) -> Get[T]:
     if sys.platform != 'win32':
         return q.get
-    return partial(_retry_call, q.get, Empty)
+    return partial(_retrying, q.get, Empty)
 
 
 # ---------------------------- pool initialization ----------------------------
@@ -325,8 +334,8 @@ class _AutoSize:
                 return  # Or duration is less then `monotonic()` precision
 
             if self.duration < self.MIN_DURATION:  # Too high IPC overhead
-                size = self.size * 2
-                _LOGGER.debug('Doubling batch size to %d', size)
+                size = self._new_scale() if _FAST_GROW else self.size * 2
+                _LOGGER.debug('Increasing batch size to %d', size)
 
             elif (
                 self.duration <= self.MAX_DURATION  # Range is optimal
@@ -335,25 +344,35 @@ class _AutoSize:
                 return
 
             else:  # Too high latency
-                size = int(2 * self.size * self.MIN_DURATION / self.duration)
-                size = max(size, 1)
+                size = self._new_scale()
                 _LOGGER.debug('Reducing batch size to %d', size)
 
             self.size = size
             self.duration = 0.0
 
+    def _new_scale(self) -> int:
+        factor = 2 * self.MIN_DURATION / self.duration
+        factor = min(factor, 32)
+        size = int(self.size * factor)
+        return max(size, 1)
+
 
 # ---------------------- map iterable through function ----------------------
 
 
 def _schedule[F: Future](
-    make_future: Callable[..., F], args_zip: Iterable[Iterable], chunksize: int
+    submit_chunk: Callable[..., F],
+    args_zip: Iterable[Iterable],
+    chunksize: int,
 ) -> Iterator[F]:
-    return starmap(make_future, chunked(args_zip, chunksize))
+    for chunk in chunked(args_zip, chunksize):
+        f = submit_chunk(*chunk)
+        _LOGGER.debug('Submit %d', len(chunk))
+        yield f
 
 
 def _schedule_auto[F: Future](
-    make_future: Callable[..., F],
+    submit_chunk: Callable[..., F],
     args_zip: Iterator[Iterable],
     max_workers: int,
 ) -> Iterator[F]:
@@ -361,28 +380,30 @@ def _schedule_auto[F: Future](
     size = _AutoSize()
     while tuples := [*islice(args_zip, size.suggest() * max_workers)]:
         chunksize = len(tuples) // max_workers or 1
-        for args in chunked(tuples, chunksize):
-            f = make_future(*args)
-            f.add_done_callback(partial(size.update, len(args), monotonic()))
+        for chunk in chunked(tuples, chunksize):
+            f = submit_chunk(*chunk)
+            _LOGGER.debug('Submit %d', len(chunk))
+            f.add_done_callback(partial(size.update, len(chunk), monotonic()))
             yield f
 
 
 def _schedule_auto_v2[F: Future](
-    make_future: Callable[..., F], args_zip: Iterator[Iterable]
+    submit_chunk: Callable[..., F], args_zip: Iterator[Iterable]
 ) -> Iterator[F]:
     # Vary job size from future to future
     size = _AutoSize()
-    while args := [*islice(args_zip, size.suggest())]:
-        f = make_future(*args)
-        f.add_done_callback(partial(size.update, len(args), monotonic()))
+    while chunk := [*islice(args_zip, size.suggest())]:
+        f = submit_chunk(*chunk)
+        _LOGGER.debug('Submit %d', len(chunk))
+        f.add_done_callback(partial(size.update, len(chunk), monotonic()))
         yield f
 
 
 def _get_unwrap_iter[T](
     s: ExitStack,
     qsize: int,
-    get_done_f: Get[Future[T]],
-    fs_scheduler: Iterator,
+    get_f: Get[Future[T]],
+    sched_iter: Iterator,
 ) -> Iterator[T]:
     with s:
         if not qsize:  # No tasks to do
@@ -390,45 +411,47 @@ def _get_unwrap_iter[T](
 
         # Unwrap 1st / schedule `N-qsize` / unwrap `qsize-1`
         with hide_frame:
-            for _ in chain([None], fs_scheduler, range(qsize - 1)):
+            for _ in chain([None], sched_iter, range(qsize - 1)):
                 # Retrieve done task, exactly `N` calls
-                obj = _result(get_done_f())
+                obj = _result(get_f())
                 if not isinstance(obj, Some):
                     with hide_frame:
                         raise obj
                 yield obj.x
 
 
-def _unwrap[T](
-    s: ExitStack,
+def _enqueue[T](
     fs: Iterable[Future[T]],
-    *,
-    qsize: int | None,
-    order: bool,
-) -> Iterator[T]:
+    unordered: bool,
+) -> tuple[Iterator, Get[Future[T]]]:
     q = SimpleQueue[Future[T]]()
 
-    # If `order`, then `q` has "PENDING"/"RUNNING"/"DONE" tasks,
-    # otherwise it only has "DONE" tasks.
-    # FIXME: order=False -> random freezes (in q.get -> Empty)
+    # In `unordered` mode `q` contains only "DONE" tasks,
+    # else there are also "PENDING" and "RUNNING" tasks.
+    # FIXME: unordered=True -> random freezes (in q.get -> Empty)
     q_put = cast(
         'Callable[[Future[T]], None]',
-        q.put if order else methodcaller('add_done_callback', q.put),
+        methodcaller('add_done_callback', q.put) if unordered else q.put,
     )
+    q_get = _q_get_fn(q)
 
     # On each `next()` schedules new task
-    fs_scheduler = map(q_put, fs)
-    try:
-        # Fetch up to `qsize` tasks to pre-fill `q`
-        qsize = ilen(islice(fs_scheduler, qsize))
+    sched_iter = map(q_put, fs)
+
+    return sched_iter, q_get
 
+
+def _prefetch(s: ExitStack, sched_iter: Iterator, prefetch: int | None) -> int:
+    try:
+        # Fetch up to `prefetch` tasks to pre-fill `q`
+        qsize = ilen(islice(sched_iter, prefetch))
     except BaseException:
         # Unwind stack here on an error
         s.close()
         raise
-
     else:
-        return _get_unwrap_iter(s, qsize, _q_get_fn(q), fs_scheduler)
+        _LOGGER.debug('Prefetched %d jobs', qsize)
+        return qsize
 
 
 def _batch_invoke[*Ts, R](
@@ -477,7 +500,7 @@ def starmap_n[T](
       prefetch=None and order=False, so choose wisely.
     - Setting order to False makes no use of prefetch more than 0.
 
-    TODO: replace `order=True` with `heap=False`
+    TODO: replace `order=True` with `unordered=False`
     """
     if max_workers is None:
         max_workers = max_cpu_count(_NUM_CPUS, mp=mp)
@@ -492,6 +515,8 @@ def starmap_n[T](
     if prefetch is not None:
         prefetch = max(prefetch + max_workers, 1)
 
+    unordered = not order
+
     it = iter(iterable)
     s = ExitStack()
     submit = s.enter_context(get_executor(max_workers, mp=mp)).submit
@@ -502,24 +527,28 @@ def starmap_n[T](
         chunksize = chunksize or 1
 
     if chunksize == 1:
-        submit_one = cast('Callable[..., Future[T]]', partial(submit, func))
-        f1s = starmap(submit_one, it)
-        return _unwrap(s, f1s, qsize=prefetch, order=order)
+        submit_1 = cast('Callable[..., Future[T]]', partial(submit, func))
+        f1s = starmap(submit_1, it)
+        sched1_iter, get_f = _enqueue(f1s, unordered)
+        qsize = _prefetch(s, sched1_iter, prefetch)
+        return _get_unwrap_iter(s, qsize, get_f, sched1_iter)
 
-    submit_many = cast(
+    submit_n = cast(
         'Callable[..., Future[list[T]]]', partial(submit, _batch_invoke, func)
     )
     if chunksize is not None:
         # Fixed chunksize
-        fs = _schedule(submit_many, it, chunksize)
+        fs = _schedule(submit_n, it, chunksize)
     elif not _GRANULAR_SCHEDULING:
         # Dynamic chunksize scaling, submit tasks in waves
-        fs = _schedule_auto(submit_many, it, max_workers)
+        fs = _schedule_auto(submit_n, it, max_workers)
     else:
         # Dynamic chunksize scaling
-        fs = _schedule_auto_v2(submit_many, it)
+        fs = _schedule_auto_v2(submit_n, it)
 
-    chunks = _unwrap(s, fs, qsize=prefetch, order=order)
+    sched_iter, get_fs = _enqueue(fs, unordered)
+    qsize = _prefetch(s, sched_iter, prefetch)
+    chunks = _get_unwrap_iter(s, qsize, get_fs, sched_iter)
     return chain.from_iterable(chunks)
 
 

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

@@ -2,7 +2,6 @@ __all__ = ['move_to_shmem']
 
 import copyreg
 import io
-import logging
 import mmap
 import os
 import pickle
@@ -25,10 +24,6 @@ _SYSTEM_TEMP = Path(tempfile.gettempdir())
 reducers: dict[type, Callable] = {}
 loky.set_loky_pickler('pickle')
 
-logger = logging.getLogger(__name__)
-# logger.setLevel(logging.DEBUG)
-# logger.addHandler(logging.StreamHandler())
-
 
 def _get_shm_dir() -> Path:
     if sys.platform != 'win32':

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

@@ -48,7 +48,7 @@ import sys
 import types
 from argparse import ArgumentParser, BooleanOptionalAction, _ArgumentGroup
 from collections.abc import Callable, Iterable, Iterator, Sequence
-from dataclasses import MISSING, Field, field, fields, is_dataclass
+from dataclasses import MISSING, Field, dataclass, field, fields, is_dataclass
 from inspect import getmodule, signature, stack
 from typing import (
     Any,
@@ -61,9 +61,26 @@ from typing import (
     get_type_hints,
 )
 
+from typing_inspection.introspection import (
+    UNKNOWN,
+    AnnotationSource,
+    inspect_annotation,
+)
+
 type _Node = str | tuple[str, type, list['_Node']]
 
 
+@dataclass(kw_only=True)
+class Meta:
+    help: str = ''
+    flag: str | None = None
+
+
+@dataclass(kw_only=True)
+class _Meta(Meta):
+    name: str
+
+
 def arg(
     default=MISSING,
     /,
@@ -156,19 +173,36 @@ def _get_fields(fn: Callable) -> Iterator[Field]:
         yield fd
 
 
+def _get_metadata(tp: type, fd: Field) -> tuple[type, _Meta]:
+    info = inspect_annotation(tp, annotation_source=AnnotationSource.CLASS)
+
+    flag = fd.metadata.get('flag')
+    name = fd.name.replace('_', '-')
+    help_ = fd.metadata.get('help') or ''
+
+    if info.type is not UNKNOWN:
+        tp = info.type
+        for m in info.metadata:
+            if isinstance(m, Meta):
+                help_ = m.help
+                flag = m.flag
+
+    return tp, _Meta(help=help_, flag=flag, name=name)
+
+
 def _visit_nested(
     parser: ArgumentParser | _ArgumentGroup,
     fn: Callable,
     seen: dict[str, list],
 ) -> list[_Node]:
     try:
-        hints = get_type_hints(fn)
+        hints = get_type_hints(fn, include_extras=True)
     except NameError:
         if fn.__module__ != '__main__':
             raise
         for finfo in stack():
-            if not getmodule(finfo.frame):
-                hints = get_type_hints(fn, finfo.frame.f_globals)
+            if not getmodule(f := finfo.frame):
+                hints = get_type_hints(fn, f.f_globals, include_extras=True)
                 break
         else:
             raise
@@ -196,11 +230,11 @@ def _visit_field(
     fd: Field,
     seen: dict[str, list],
 ) -> _Node:
+    tp, meta = _get_metadata(tp, fd)
     cls, opts = _unwrap_type(tp)
 
-    help_ = fd.metadata.get('help') or ''
     if cls is not bool and fd.default is not MISSING:
-        help_ += f' (default: {fd.default})'
+        meta.help += f' (default: {fd.default})'
 
     if is_dataclass(cls):  # Nested dataclass
         arg_group = parser.add_argument_group(fd.name)
@@ -218,9 +252,7 @@ def _visit_field(
         )
         raise TypeError(msg)
 
-    snake = fd.name.replace('_', '-')
-    flags = [f] if (f := fd.metadata.get('flag')) else []
-
+    flags = [meta.flag] if meta.flag else []
     default = (
         fd.default if fd.default_factory is MISSING else fd.default_factory()
     )
@@ -230,11 +262,11 @@ def _visit_field(
             msg = f'Boolean field "{fd.name}" should have default'
             raise ValueError(msg)
         parser.add_argument(
-            f'--{snake}',
+            f'--{meta.name}',
             *flags,
             action=BooleanOptionalAction,
             default=default,
-            help=help_,
+            help=meta.help,
         )
 
     # Generic optional
@@ -242,14 +274,14 @@ def _visit_field(
         if opts.get('nargs') == argparse.OPTIONAL:
             del opts['nargs']
         parser.add_argument(
-            f'--{snake}', *flags, **opts, default=default, help=help_
+            f'--{meta.name}', *flags, **opts, default=default, help=meta.help
         )
 
     elif isinstance(parser, ArgumentParser):  # Allow only for root parser
-        if flags:
+        if meta.flag:
             msg = f'Positional-only field "{fd.name}" should not have flag'
             raise ValueError(msg)
-        parser.add_argument(snake, **opts, help=help_)
+        parser.add_argument(meta.name, **opts, help=meta.help)
 
     else:
         msg = (

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

@@ -1,9 +1,15 @@
 from argparse import ArgumentParser
 from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
 from typing import Any, overload
 
 from ._types import Get
 
+@dataclass
+class Meta:
+    help: str = ...
+    flag: str | None = ...
+
 @overload
 def arg[T](
     default: T,

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

@@ -1,11 +1,11 @@
 from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Literal
+from typing import Annotated, Any, Literal
 
 import pytest
 
-from glow.cli import parse_args
+from glow.cli import Meta, parse_args
 
 
 @dataclass
@@ -81,6 +81,21 @@ class Custom:
     arg: Path
 
 
+@dataclass
+class AnnotatedPositional:
+    arg: Annotated[int, Meta(help='help')]
+
+
+@dataclass
+class FlagKeyword:
+    param: Annotated[int, Meta(help='help', flag='-p')] = 42
+
+
+@dataclass
+class AnnotatedKeyword:
+    param: Annotated[int, Meta(help='help')] = 42
+
+
 @pytest.mark.parametrize(
     ('argv', 'expected'),
     [
@@ -98,6 +113,10 @@ class Custom:
         (['value'], Nested('value', Optional_())),
         (['value', '--param', 'pvalue'], Nested('value', Optional_('pvalue'))),
         (['test.txt'], Custom(Path('test.txt'))),
+        (['5'], AnnotatedPositional(5)),
+        (['--param', '5'], AnnotatedKeyword(5)),
+        ([], AnnotatedKeyword(42)),
+        (['-p', '42'], FlagKeyword(42)),
     ],
 )
 def test_good_class(argv: list[str], expected: Any):