glow 0.15.3__tar.gz → 0.15.4__tar.gz

{glow-0.15.3 → glow-0.15.4}/PKG-INFO

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

{glow-0.15.3 → glow-0.15.4}/pyproject.toml

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

{glow-0.15.3 → glow-0.15.4}/src/glow/_async.py

@@ -16,7 +16,7 @@ from contextlib import suppress
 from functools import partial
 from typing import TypeGuard, cast, overload
 
-from ._dev import declutter_tb
+from ._dev import hide_frame
 from ._types import (
     ABatchDecorator,
     ABatchFn,
@@ -24,6 +24,7 @@ from ._types import (
     AnyIterable,
     AnyIterator,
     Coro,
+    Some,
 )
 
 type _Job[T, R] = tuple[T, AnyFuture[R]]
@@ -309,7 +310,8 @@ def astreaming[T, R](
                 async with lock:
                     await _adispatch(fn, *batch)
 
-        return await asyncio.gather(*fs)
+        with hide_frame:
+            return await asyncio.gather(*fs)
 
     return wrapper
 
@@ -317,20 +319,25 @@ def astreaming[T, R](
 async def _adispatch[T, R](fn: ABatchFn[T, R], *xs: _Job[T, R]) -> None:
     if not xs:
         return
-    obj: list[R] | BaseException
+    obj: Some[Sequence[R]] | BaseException
     try:
-        obj = list(await fn([x for x, _ in xs]))
-        if len(obj) != len(xs):
-            obj = RuntimeError(
-                f'Call with {len(xs)} arguments '
-                f'incorrectly returned {len(obj)} results'
-            )
+        with hide_frame:
+            obj = Some(await fn([x for x, _ in xs]))
+            if not isinstance(obj.x, Sequence):
+                obj = TypeError(
+                    f'Call returned non-sequence. Got {type(obj.x).__name__}'
+                )
+            elif len(obj.x) != len(xs):
+                obj = RuntimeError(
+                    f'Call with {len(xs)} arguments '
+                    f'incorrectly returned {len(obj.x)} results'
+                )
     except BaseException as exc:  # noqa: BLE001
-        obj = declutter_tb(exc, fn.__code__)
+        obj = exc
 
-    if isinstance(obj, BaseException):
+    if isinstance(obj, Some):
+        for (_, f), res in zip(xs, obj.x):
+            f.set_result(res)
+    else:
         for _, f in xs:
             f.set_exception(obj)
-    else:
-        for (_, f), res in zip(xs, obj):
-            f.set_result(res)

{glow-0.15.3 → glow-0.15.4}/src/glow/_cache.py

@@ -12,19 +12,27 @@ from collections.abc import (
     Iterator,
     KeysView,
     MutableMapping,
+    Sequence,
 )
 from dataclasses import dataclass, field
 from inspect import iscoroutinefunction
 from threading import RLock
-from types import CodeType
 from typing import Final, Protocol, SupportsInt, cast
 from weakref import WeakValueDictionary
 
-from ._dev import declutter_tb
+from ._dev import hide_frame
 from ._keys import make_key
 from ._repr import si_bin
 from ._sizeof import sizeof
-from ._types import ABatchFn, AnyFuture, BatchFn, CachePolicy, Decorator, KeyFn
+from ._types import (
+    ABatchFn,
+    AnyFuture,
+    BatchFn,
+    CachePolicy,
+    Decorator,
+    KeyFn,
+    Some,
+)
 
 
 class _Empty(enum.Enum):
@@ -228,7 +236,6 @@ class _StrongCache[R](_WeakCache[R]):
 @dataclass(frozen=True, slots=True)
 class _CacheState[R]:
     cache: _AbstractCache[R]
-    code: CodeType  # for short tracebacks
     key_fn: KeyFn
     futures: WeakValueDictionary[Hashable, AnyFuture[R]] = field(
         default_factory=WeakValueDictionary
@@ -261,19 +268,20 @@ def _sync_memoize[**P, R](
         if not is_owner:
             return f.result()
 
-        try:
-            ret = fn(*args, **kwargs)
-        except BaseException as exc:
-            f.set_exception(exc)
-            with lock:
-                cs.futures.pop(key)
-            raise
-        else:
-            f.set_result(ret)
-            with lock:
-                cs.cache[key] = ret
-                cs.futures.pop(key)
-            return ret
+        with hide_frame:
+            try:
+                ret = fn(*args, **kwargs)
+            except BaseException as exc:
+                f.set_exception(exc)
+                with lock:
+                    cs.futures.pop(key)
+                raise
+            else:
+                f.set_result(ret)
+                with lock:
+                    cs.cache[key] = ret
+                    cs.futures.pop(key)
+                return ret
 
     return wrapper
 
@@ -296,17 +304,18 @@ def _async_memoize[**P, R](
 
         # NOTE: fn() is not within threading.Lock, thus it's not thread safe
         # NOTE: but it's async-safe because this `await` is only one here.
-        try:
-            ret = await fn(*args, **kwargs)
-        except BaseException as exc:
-            f.set_exception(exc)
-            cs.futures.pop(key)
-            raise
-        else:
-            f.set_result(ret)
-            cs.cache[key] = ret
-            cs.futures.pop(key)
-            return ret
+        with hide_frame:
+            try:
+                ret = await fn(*args, **kwargs)
+            except BaseException as exc:
+                f.set_exception(exc)
+                cs.futures.pop(key)
+                raise
+            else:
+                f.set_result(ret)
+                cs.cache[key] = ret
+                cs.futures.pop(key)
+                return ret
 
     return wrapper
 
@@ -352,12 +361,12 @@ class _BatchedQuery[T, R]:
         return bool(self._jobs)
 
     @property
-    def result(self) -> list[R] | BaseException:
+    def result(self) -> Some[Sequence[R]] | BaseException:
         match list(self._errors):
             case []:
                 if self._default_tp:
                     return self._default_tp()
-                return [self._done[k] for k in self._keys]
+                return Some([self._done[k] for k in self._keys])
             case [e]:
                 return e
             case excs:
@@ -367,20 +376,25 @@ class _BatchedQuery[T, R]:
                 return BaseExceptionGroup(msg, excs)
 
     @result.setter
-    def result(self, obj: list[R] | BaseException) -> None:
+    def result(self, obj: Some[Sequence[R]] | BaseException) -> None:
         done_jobs = [(k, f) for k, a, f in self._jobs if a]
 
-        if not isinstance(obj, BaseException):
-            if len(obj) == len(done_jobs):
-                for (k, f), value in zip(done_jobs, obj):
-                    f.set_result(value)
-                    self._stash.append((k, value))
-                return
-
-            obj = RuntimeError(
-                f'Call with {len(done_jobs)} arguments '
-                f'incorrectly returned {len(obj)} results'
-            )
+        if isinstance(obj, Some):
+            if isinstance(obj.x, Sequence):
+                if len(obj.x) == len(done_jobs):
+                    for (k, f), value in zip(done_jobs, obj.x):
+                        f.set_result(value)
+                        self._stash.append((k, value))
+                    return
+
+                obj = RuntimeError(
+                    f'Call with {len(done_jobs)} arguments '
+                    f'incorrectly returned {len(obj.x)} results'
+                )
+            else:
+                obj = TypeError(
+                    f'Call returned non-sequence. Got {type(obj.x).__name__}'
+                )
 
         for _, f in done_jobs:
             f.set_exception(obj)
@@ -409,9 +423,6 @@ class _BatchedQuery[T, R]:
                 self._stash.append((k, f.result()))
 
     def sync(self) -> None:
-        for e in self._errors:
-            declutter_tb(e, self._cs.code)
-
         for k, r in self._stash:
             self._done[k] = self._cs.cache[k] = r
 
@@ -433,7 +444,8 @@ def _sync_memoize_batched[T, R](
             # Run tasks we are first to schedule
             if args := q.args:
                 try:
-                    q.result = list(fn(args))
+                    with hide_frame:
+                        q.result = Some(fn(args))
                 except BaseException as exc:  # noqa: BLE001
                     q.result = exc
 
@@ -446,9 +458,10 @@ def _sync_memoize_batched[T, R](
                 with lock:
                     q.sync()
 
-        if isinstance(ret := q.result, BaseException):
+        if isinstance(ret := q.result, Some):
+            return list(ret.x)
+        with hide_frame:
             raise ret
-        return ret
 
     return wrapper
 
@@ -463,7 +476,8 @@ def _async_memoize_batched[T, R](
             # Run tasks we are first to schedule
             if args := q.args:
                 try:
-                    q.result = list(await fn(args))
+                    with hide_frame:
+                        q.result = Some(await fn(args))
                 except BaseException as exc:  # noqa: BLE001
                     q.result = exc  # Raise later in `q.exception()`
 
@@ -474,9 +488,10 @@ def _async_memoize_batched[T, R](
         finally:
             q.sync()
 
-        if isinstance(ret := q.result, BaseException):
+        if isinstance(ret := q.result, Some):
+            return list(ret.x)
+        with hide_frame:
             raise ret
-        return ret
 
     return wrapper
 
@@ -491,7 +506,7 @@ def _memoize[**P, R](
     key_fn: KeyFn,
     batched: bool,
 ) -> Callable[P, R]:
-    cs = _CacheState(cache, fn.__code__, key_fn)
+    cs = _CacheState(cache, key_fn)
 
     if batched and iscoroutinefunction(fn):
         w = cast(

{glow-0.15.3 → glow-0.15.4}/src/glow/_concurrency.py

@@ -18,7 +18,8 @@ from typing import Never, cast
 from warnings import warn
 
 from ._cache import memoize
-from ._types import AnyFuture, BatchDecorator, BatchFn
+from ._dev import hide_frame
+from ._types import AnyFuture, BatchDecorator, BatchFn, Some
 
 _PATIENCE = 0.01
 
@@ -120,23 +121,28 @@ def _batch_invoke[T, R](
     if not batch:
         return
 
-    obj: list[R] | BaseException
+    obj: Some[Sequence[R]] | BaseException
     try:
-        obj = [*func([x for x, _ in batch])]
-        if len(obj) != len(batch):
-            obj = RuntimeError(
-                f'Call with {len(batch)} arguments '
-                f'incorrectly returned {len(obj)} results'
-            )
+        with hide_frame:
+            obj = Some(func([x for x, _ in batch]))
+            if not isinstance(obj.x, Sequence):
+                obj = TypeError(
+                    f'Call returned non-sequence. Got {type(obj.x).__name__}'
+                )
+            elif len(obj.x) != len(batch):
+                obj = RuntimeError(
+                    f'Call with {len(batch)} arguments '
+                    f'incorrectly returned {len(obj.x)} results'
+                )
     except BaseException as exc:  # noqa: BLE001
         obj = exc
 
-    if isinstance(obj, BaseException):
+    if isinstance(obj, Some):
+        for (_, f), r in zip(batch, obj.x):
+            f.set_result(r)
+    else:
         for _, f in batch:
             f.set_exception(obj)
-    else:
-        for (_, f), r in zip(batch, obj):
-            f.set_result(r)
 
 
 def _start_fetch_compute[T, R](
@@ -227,7 +233,8 @@ def streaming[T, R](
 
         # Cannot time out - all are done
         if isinstance(obj := _gather(fs), BaseException):
-            raise obj
+            with hide_frame:
+                raise obj
         return obj
 
     # TODO: if func is instance method - recreate wrapper per instance

glow-0.15.4/src/glow/_dev.py

@@ -0,0 +1,18 @@
+__all__ = ['hide_frame']
+
+
+class _HideFrame:
+    """Context manager to hide current frame in traceback"""
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, tp, val, tb):
+        if tp is None:
+            return True
+        if tb := val.__traceback__:
+            val.__traceback__ = tb.tb_next
+        return False
+
+
+hide_frame = _HideFrame()

{glow-0.15.3 → glow-0.15.4}/src/glow/_parallel.py

@@ -16,7 +16,6 @@ import warnings
 import weakref
 from collections.abc import Callable, Iterable, Iterator, Mapping, Sized
 from concurrent.futures import Executor, Future
-from concurrent.futures import TimeoutError as _TimeoutError
 from contextlib import ExitStack, contextmanager
 from cProfile import Profile
 from functools import partial
@@ -27,8 +26,7 @@ from operator import methodcaller
 from pstats import Stats
 from queue import Empty, SimpleQueue
 from threading import Lock
-from time import perf_counter, sleep
-from types import CodeType
+from time import monotonic, sleep
 from typing import Final, Protocol, Self, cast
 
 import loky
@@ -38,7 +36,7 @@ try:
 except ImportError:
     psutil = None
 
-from ._dev import declutter_tb
+from ._dev import hide_frame
 from ._more import chunked, ilen
 from ._reduction import move_to_shmem, reducers
 from ._thread_quota import ThreadQuota
@@ -133,18 +131,15 @@ def _retry_call[T](fn: Callable[..., T], *exc: type[BaseException]) -> T:
 if sys.platform == 'win32':
 
     def _exception[T](f: Future[T], /) -> BaseException | None:
-        return _retry_call(f.exception, _TimeoutError)
+        return _retry_call(f.exception, TimeoutError)
 
 else:
     _exception = Future.exception
 
 
-def _result[T](
-    f: Future[T], code: CodeType, cancel: bool = True
-) -> Some[T] | BaseException:
+def _result[T](f: Future[T], cancel: bool = True) -> Some[T] | BaseException:
     try:
-        exc = _exception(f)
-        return declutter_tb(exc, code) if exc else Some(f.result())
+        return exc if (exc := _exception(f)) else Some(f.result())
     finally:
         if cancel:
             f.cancel()
@@ -280,9 +275,10 @@ class buffered[T](Iterator[T]):  # noqa: N801
 
             self.close()
             # Reraise exception from source iterable if any
-            obj = _result(self._consume, _consume.__code__, cancel=False)
+            obj = _result(self._consume, cancel=False)
             if not isinstance(obj, Some):
-                raise obj
+                with hide_frame:
+                    raise obj
 
         raise StopIteration
 
@@ -298,43 +294,49 @@ class _AutoSize:
 
     def __init__(self) -> None:
         self.lock = Lock()
+        assert self.MIN_DURATION * 2 < self.MAX_DURATION, 'Range is too tight'
 
     def suggest(self) -> int:
         with self.lock:
-            if 0 < self.duration < self.MIN_DURATION:
-                self.size *= 2
-                self.duration = 0.0
-                _LOGGER.debug('Doubling batch size to %d', self.size)
-
-            elif self.duration > self.MAX_DURATION:
-                size = int(2 * self.size * self.MIN_DURATION / self.duration)
-                size = max(size, 1)
-                if self.size != size:
-                    self.duration = 0.0
-                    self.size = size
-                    _LOGGER.debug('Reducing batch size to %d', self.size)
-
             return self.size
 
-    def update(self, start_time: float, fut: Future[Sized]) -> None:
+    def update(self, n: int, start_time: float, fut: Future[Sized]) -> None:
         # Compute as soon as future became done, discard later if not needed
-        duration = perf_counter() - start_time
+        duration = monotonic() - start_time
 
-        try:
-            # Cannot time out, as future is always completed at this point.
-            # Though it's unknown whether it succeeded or not, so use EAFP
-            r = fut.result()
-        except BaseException:  # noqa: BLE001
+        if fut.cancelled():  # Job never run, zero load
             return
 
         with self.lock:
-            if len(r) != self.size:
+            if n != self.size:  # Ran with old size
                 return
+
+            # Do EMA smoothing
             self.duration = (
                 (0.8 * self.duration + 0.2 * duration)
                 if self.duration > 0
                 else duration
             )
+            if self.duration <= 0:  # Smh not initialized yet
+                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)
+
+            elif (
+                self.duration <= self.MAX_DURATION  # Range is optimal
+                or self.size == 1  # Cannot reduce already minimal batch
+            ):
+                return
+
+            else:  # Too high latency
+                size = int(2 * self.size * self.MIN_DURATION / self.duration)
+                size = max(size, 1)
+                _LOGGER.debug('Reducing batch size to %d', size)
+
+            self.size = size
+            self.duration = 0.0
 
 
 # ---------------------- map iterable through function ----------------------
@@ -355,8 +357,9 @@ def _schedule_auto[F: Future](
     size = _AutoSize()
     while tuples := [*islice(args_zip, size.suggest() * max_workers)]:
         chunksize = len(tuples) // max_workers or 1
-        for f in starmap(make_future, chunked(tuples, chunksize)):
-            f.add_done_callback(partial(size.update, perf_counter()))
+        for args in chunked(tuples, chunksize):
+            f = make_future(*args)
+            f.add_done_callback(partial(size.update, len(args), monotonic()))
             yield f
 
 
@@ -367,7 +370,7 @@ def _schedule_auto_v2[F: Future](
     size = _AutoSize()
     while args := [*islice(args_zip, size.suggest())]:
         f = make_future(*args)
-        f.add_done_callback(partial(size.update, perf_counter()))
+        f.add_done_callback(partial(size.update, len(args), monotonic()))
         yield f
 
 
@@ -376,19 +379,20 @@ def _get_unwrap_iter[T](
     qsize: int,
     get_done_f: Callable[[], Future[T]],
     fs_scheduler: Iterator,
-    code: CodeType,
 ) -> Iterator[T]:
     with s:
         if not qsize:  # No tasks to do
             return
 
         # Unwrap 1st / schedule `N-qsize` / unwrap `qsize-1`
-        for _ in chain([None], fs_scheduler, range(qsize - 1)):
-            # Retrieve done task, exactly `N` calls
-            obj = _result(get_done_f(), code)
-            if not isinstance(obj, Some):
-                raise obj
-            yield obj.x
+        with hide_frame:
+            for _ in chain([None], fs_scheduler, range(qsize - 1)):
+                # Retrieve done task, exactly `N` calls
+                obj = _result(get_done_f())
+                if not isinstance(obj, Some):
+                    with hide_frame:
+                        raise obj
+                yield obj.x
 
 
 def _unwrap[T](
@@ -397,7 +401,6 @@ def _unwrap[T](
     *,
     qsize: int | None,
     order: bool,
-    code: CodeType,
 ) -> Iterator[T]:
     q = SimpleQueue[Future[T]]()
 
@@ -421,7 +424,7 @@ def _unwrap[T](
         raise
 
     else:
-        return _get_unwrap_iter(s, qsize, _q_get_fn(q), fs_scheduler, code)
+        return _get_unwrap_iter(s, qsize, _q_get_fn(q), fs_scheduler)
 
 
 def _batch_invoke[*Ts, R](
@@ -489,7 +492,6 @@ def starmap_n[T](
     s = ExitStack()
     submit = s.enter_context(get_executor(max_workers, mp=mp)).submit
 
-    code = func.__code__
     if mp:
         func = move_to_shmem(func)
     else:
@@ -498,7 +500,7 @@ def starmap_n[T](
     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, code=code)
+        return _unwrap(s, f1s, qsize=prefetch, order=order)
 
     submit_many = cast(
         'Callable[..., Future[list[T]]]', partial(submit, _batch_invoke, func)
@@ -513,7 +515,7 @@ def starmap_n[T](
         # Dynamic chunksize scaling
         fs = _schedule_auto_v2(submit_many, it)
 
-    chunks = _unwrap(s, fs, qsize=prefetch, order=order, code=code)
+    chunks = _unwrap(s, fs, qsize=prefetch, order=order)
     return chain.from_iterable(chunks)
 
 

{glow-0.15.3 → glow-0.15.4}/src/glow/cli.py

@@ -43,16 +43,25 @@ Reasons not to use alternatives:
 __all__ = ['arg', 'parse_args']
 
 import argparse
+import importlib
+import sys
 import types
 from argparse import ArgumentParser, BooleanOptionalAction, _ArgumentGroup
-from collections.abc import Callable, Collection, Iterator, Sequence
+from collections.abc import Callable, Iterable, Iterator, Sequence
 from dataclasses import MISSING, Field, field, fields, is_dataclass
 from inspect import getmodule, signature, stack
-from typing import Any, Literal, Union, get_args, get_origin, get_type_hints
+from typing import (
+    Any,
+    Literal,
+    Required,
+    TypedDict,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
 type _Node = str | tuple[str, type, list['_Node']]
-_NoneType = type(None)
-_UNION_TYPES: list = [Union, types.UnionType]
 
 
 def arg(
@@ -84,41 +93,46 @@ def arg(
     )
 
 
-def _unwrap_type(tp: type) -> tuple[type, dict[str, Any]]:
-    if tp is list:
-        msg = 'Type list should be parametrized'
-        raise ValueError(msg)
+class _Opts(TypedDict, total=False):
+    type: Required[Callable]
+    nargs: str
+    choices: Iterable
+
 
+def _unwrap_type(tp: type) -> tuple[type, _Opts]:
     origin = get_origin(tp)
-    args = [*get_args(tp)]
+    args = get_args(tp)
     if not origin or not args:  # Not a generic type
         return tp, {'type': tp}
 
     if origin is list:  # `List[T]`
         cls, opts = _unwrap_type(args[0])
-        return cls, opts | {'nargs': argparse.ZERO_OR_MORE}
-
-    # `Optional[T]` or `T | None`
-    if origin in _UNION_TYPES and len(args) == 2 and _NoneType in args:
-        args.remove(_NoneType)
-        cls, opts = _unwrap_type(args[0])
+        return cls, {**opts, 'nargs': argparse.ZERO_OR_MORE}
+
+    if (  # `Optional[T]` or `T | None`
+        origin in {Union, types.UnionType}
+        and len(args) == 2
+        and types.NoneType in args
+    ):
+        [tp_] = set(args) - {types.NoneType}
+        cls, opts = _unwrap_type(tp_)
         if opts.get('nargs') == argparse.ZERO_OR_MORE:
             return cls, opts
-        return cls, opts | {'nargs': argparse.OPTIONAL}
+        return cls, {**opts, 'nargs': argparse.OPTIONAL}
 
     if origin is Literal:  # `Literal[x, y]`
         choices = get_args(tp)
         if len(tps := {type(c) for c in choices}) != 1:
             msg = f'Literal parameters should have the same type. Got: {tps}'
-            raise ValueError(msg)
-        (cls,) = tps
+            raise TypeError(msg)
+        [cls] = tps
         return cls, {'type': cls, 'choices': choices}
 
     msg = (
         'Only list, Optional and Literal are supported as generic types. '
         f'Got: {tp}'
     )
-    raise ValueError(msg)
+    raise TypeError(msg)
 
 
 def _get_fields(fn: Callable) -> Iterator[Field]:
@@ -132,7 +146,7 @@ def _get_fields(fn: Callable) -> Iterator[Field]:
             raise ValueError(msg)
         if p.kind in {p.POSITIONAL_ONLY, p.VAR_POSITIONAL, p.VAR_KEYWORD}:
             msg = f'Unsupported parameter type: {p.kind}'
-            raise ValueError(msg)
+            raise TypeError(msg)
 
         if isinstance(p.default, Field):
             fd = p.default
@@ -192,6 +206,13 @@ 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}:
+        msg = (
+            'Only bool, int, float and str are supported as value types. '
+            f'Got: {vtp}'
+        )
+        raise TypeError(msg)
+
     snake = fd.name.replace('_', '-')
     flags = [f] if (f := fd.metadata.get('flag')) else []
 
@@ -236,7 +257,7 @@ def _visit_field(
 
 
 def _construct[T](
-    src: dict[str, Any], fn: Callable[..., T], args: Collection[_Node]
+    src: dict[str, Any], fn: Callable[..., T], args: Iterable[_Node]
 ) -> T:
     kwargs = {}
     for a in args:
@@ -249,17 +270,55 @@ def _construct[T](
 
 def parse_args[T](
     fn: Callable[..., T],
+    /,
     args: Sequence[str] | None = None,
     prog: str | None = None,
 ) -> tuple[T, ArgumentParser]:
     """Create parser from type hints of callable, parse args and do call."""
     # TODO: Rename to `run`
+    if not callable(fn):
+        raise TypeError(f'Expectet callable. Got: {type(fn).__qualname__}')
+
     parser = ArgumentParser(prog)
     nodes = _visit_nested(parser, fn, {})
 
-    if args is not None:  # fool's protection
-        args = line.split(' ') if (line := ' '.join(args).strip()) else []
+    assert args is None or (
+        isinstance(args, Sequence) and not isinstance(args, str)
+    )
 
     namespace = parser.parse_args(args)
     obj = _construct(vars(namespace), fn, nodes)
     return obj, parser
+
+
+def _import_from_string(qualname: str):
+    modname, _, attrname = qualname.partition(":")
+    if not modname or not attrname:
+        msg = (
+            f'Import string "{qualname}" must be '
+            'in format "<module>:<attribute>".'
+        )
+        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
+
+    obj: Any = mod
+    try:
+        for a in attrname.split('.'):
+            obj = getattr(obj, a)
+    except AttributeError:
+        msg = f'Attribute "{attrname}" not found in module "{modname}".'
+        raise AttributeError(msg)
+    return obj
+
+
+if __name__ == '__main__':
+    qualname, *argv = sys.argv
+    obj = _import_from_string(qualname)
+    parse_args(obj, argv)

{glow-0.15.3 → glow-0.15.4}/test/test_cli.py

@@ -8,18 +8,23 @@ from glow.cli import parse_args
 
 
 @dataclass
-class Arg:
+class Positional:
     arg: str
 
 
+@dataclass
+class UntypedList:  # Forbidden, as list field should always be typed
+    args: list
+
+
 @dataclass
 class List_:  # noqa: N801
     args: list[str]
 
 
 @dataclass
-class UntypedList:  # Forbidden, as list field should always be typed
-    args: list
+class UnsupportedTuple:
+    args: tuple[str, int]
 
 
 @dataclass
@@ -54,9 +59,9 @@ class Nested:
 
 
 @dataclass
-class NestedArg:  # Forbidden, as only top level args can be positional
+class NestedPositional:  # Forbidden, as only top level args can be positional
     arg2: str
-    nested: Arg
+    nested: Positional
 
 
 @dataclass
@@ -73,7 +78,7 @@ class NestedAliased:  # Forbidden as all field names must be unique
 @pytest.mark.parametrize(
     ('argv', 'expected'),
     [
-        (['value'], Arg('value')),
+        (['value'], Positional('value')),
         ([], List_([])),
         (['a'], List_(['a'])),
         (['a', 'b'], List_(['a', 'b'])),
@@ -98,12 +103,13 @@ def test_good_class(argv: list[str], expected: Any):
 @pytest.mark.parametrize(
     ('cls', 'exc_type'),
     [
-        (Arg, SystemExit),
+        (Positional, SystemExit),
         (BadBoolean, ValueError),
-        (UnsupportedSet, ValueError),
-        (UntypedList, ValueError),
+        (UnsupportedTuple, TypeError),
+        (UnsupportedSet, TypeError),
+        (UntypedList, TypeError),
         (Nested, SystemExit),
-        (NestedArg, ValueError),
+        (NestedPositional, ValueError),
         (NestedAliased, ValueError),
     ],
 )
@@ -116,15 +122,15 @@ def _no_op():
     return ()
 
 
-def _arg(a: int):
+def _positional(a: int):
     return a
 
 
-def _kwarg(a: int = 4):
+def _keyword(a: int = 4):
     return a
 
 
-def _kwarg_opt(a: int = None):  # type: ignore[assignment]  # noqa: RUF013
+def _kw_nullable(a: int = None):  # type: ignore[assignment]  # noqa: RUF013
     return a
 
 
@@ -140,7 +146,7 @@ def _kwarg_list(a: list[int] = []):  # noqa: B006
     return a
 
 
-def _kwarg_opt_list(a: list[int] | None = None):  # type: ignore[assignment]
+def _kwarg_opt_list(a: list[int] | None = None):
     return a
 
 
@@ -152,11 +158,11 @@ def _arg_kwarg(a: int, b: str = 'hello'):
     ('argv', 'func', 'expected'),
     [
         ([], _no_op, ()),
-        (['42'], _arg, 42),
-        ([], _kwarg, 4),
-        (['--a', '58'], _kwarg, 58),
-        ([], _kwarg_opt, None),
-        (['--a', '73'], _kwarg_opt, 73),
+        (['42'], _positional, 42),
+        ([], _keyword, 4),
+        (['--a', '58'], _keyword, 58),
+        ([], _kw_nullable, None),
+        (['--a', '73'], _kw_nullable, 73),
         ([], _kwarg_literal, 1),
         (['--a', '2'], _kwarg_literal, 2),
         ([], _kwarg_bool, False),

glow-0.15.3/src/glow/_dev.py

@@ -1,16 +0,0 @@
-__all__ = ['declutter_tb']
-
-from types import CodeType
-
-
-def declutter_tb[E: BaseException](e: E, code: CodeType) -> E:
-    tb = e.__traceback__
-
-    # Drop outer to `code` frames
-    while tb:
-        if tb.tb_frame.f_code is code:  # Has reached target frame
-            e.__traceback__ = tb
-            return e
-
-        tb = tb.tb_next
-    return e