omdev 0.0.0.dev440__py3-none-any.whl → 0.0.0.dev495__py3-none-any.whl

omdev/scripts/pyproject.py

@@ -27,6 +27,7 @@ See:
 """
 import abc
 import argparse
+import ast
 import asyncio
 import asyncio.base_subprocess
 import asyncio.subprocess
@@ -52,6 +53,7 @@ import itertools
 import json
 import logging
 import multiprocessing as mp
+import operator
 import os
 import os.path
 import re
@@ -63,6 +65,7 @@ import subprocess
 import sys
 import tarfile
 import tempfile
+import textwrap
 import threading
 import time
 import traceback
@@ -80,6 +83,84 @@ if sys.version_info < (3, 8):
     raise OSError(f'Requires python (3, 8), got {sys.version_info} from {sys.executable}')  # noqa
 
 
+def __omlish_amalg__():  # noqa
+    return dict(
+        src_files=[
+            dict(path='../magic/magic.py', sha1='16a7598eac927e7994d78b9f851dd6cd1fce34c9'),
+            dict(path='../magic/prepare.py', sha1='a9b6bd7408d86a52fab7aae2c522032fb251cb8e'),
+            dict(path='../magic/styles.py', sha1='60fc56d089669eaad72c5c134b91bc69d4bc107e'),
+            dict(path='../packaging/versions.py', sha1='71627ad600b3529b829b0e227b0952f2c63c7271'),
+            dict(path='../packaging/wheelfile.py', sha1='2e1113819aa85ed00e1fe25c71a2b3dbc0a383f5'),
+            dict(path='../../omlish/formats/toml/parser.py', sha1='73dac82289350ab951c4bcdbfe61167fa221f26f'),
+            dict(path='../../omlish/formats/toml/writer.py', sha1='6ea41d7e724bb1dcf6bd84b88993ff4e8798e021'),
+            dict(path='../../omlish/lite/abstract.py', sha1='a2fc3f3697fa8de5247761e9d554e70176f37aac'),
+            dict(path='../../omlish/lite/asyncs.py', sha1='b3f2251c56617ce548abf9c333ac996b63edb23e'),
+            dict(path='../../omlish/lite/cached.py', sha1='0c33cf961ac8f0727284303c7a30c5ea98f714f2'),
+            dict(path='../../omlish/lite/check.py', sha1='bb6b6b63333699b84462951a854d99ae83195b94'),
+            dict(path='../../omlish/lite/json.py', sha1='57eeddc4d23a17931e00284ffa5cb6e3ce089486'),
+            dict(path='../../omlish/lite/objects.py', sha1='9566bbf3530fd71fcc56321485216b592fae21e9'),
+            dict(path='../../omlish/lite/reflect.py', sha1='c4fec44bf144e9d93293c996af06f6c65fc5e63d'),
+            dict(path='../../omlish/lite/strings.py', sha1='89831ecbc34ad80e118a865eceb390ed399dc4d6'),
+            dict(path='../../omlish/lite/typing.py', sha1='c501ff8f9ed08202e8016eaa098526d4deede834'),
+            dict(path='../../omlish/logs/levels.py', sha1='91405563d082a5eba874da82aac89d83ce7b6152'),
+            dict(path='../../omlish/logs/std/filters.py', sha1='f36aab646d84d31e295b33aaaaa6f8b67ff38b3d'),
+            dict(path='../../omlish/logs/std/proxy.py', sha1='3e7301a2aa351127f9c85f61b2f85dcc3f15aafb'),
+            dict(path='../../omlish/logs/warnings.py', sha1='c4eb694b24773351107fcc058f3620f1dbfb6799'),
+            dict(path='../cexts/magic.py', sha1='4e5ce6732454f75c9dd27352959708d8fa7b1666'),
+            dict(path='../magic/find.py', sha1='436228a9cf1d8bab6b9234d09f72913b0960382f'),
+            dict(path='../packaging/specifiers.py', sha1='a56ab4e8c9b174adb523921f6280ac41e0fce749'),
+            dict(path='../../omlish/argparse/cli.py', sha1='f4dc3cd353d14386b5da0306768700e396afd2b3'),
+            dict(path='../../omlish/lite/marshal.py', sha1='96348f5f2a26dc27d842d33cc3927e9da163436b'),
+            dict(path='../../omlish/lite/maybes.py', sha1='bdf5136654ccd14b6a072588cad228925bdfbabd'),
+            dict(path='../../omlish/lite/runtime.py', sha1='2e752a27ae2bf89b1bb79b4a2da522a3ec360c70'),
+            dict(path='../../omlish/lite/timeouts.py', sha1='a0f673033a6943f242e35848d78a41892b9c62a1'),
+            dict(path='../../omlish/logs/infos.py', sha1='4dd104bd468a8c438601dd0bbda619b47d2f1620'),
+            dict(path='../../omlish/logs/protocols.py', sha1='05ca4d1d7feb50c4e3b9f22ee371aa7bf4b3dbd1'),
+            dict(path='../../omlish/logs/std/json.py', sha1='2a75553131e4d5331bb0cedde42aa183f403fc3b'),
+            dict(path='../interp/types.py', sha1='caf068a6e81fb6e221d777b341ac5777d92b8091'),
+            dict(path='../packaging/requires.py', sha1='5818353abd45135e0e638e28fa6247b24122231b'),
+            dict(path='../../omlish/asyncs/asyncio/timeouts.py', sha1='4d31b02b3c39b8f2fa7e94db36552fde6942e36a'),
+            dict(path='../../omlish/lite/inject.py', sha1='6f097e3170019a34ff6834d36fcc9cbeed3a7ab4'),
+            dict(path='../../omlish/logs/contexts.py', sha1='1000a6d5ddfb642865ca532e34b1d50759781cf0'),
+            dict(path='../../omlish/logs/std/standard.py', sha1='5c97c1b9f7ead58d6127d047b873398f708f288d'),
+            dict(path='../../omlish/subprocesses/run.py', sha1='8200e48f0c49d164df3503cd0143038d0c4d30aa'),
+            dict(path='../../omlish/subprocesses/wrap.py', sha1='8a9b7d2255481fae15c05f5624b0cdc0766f4b3f'),
+            dict(path='../interp/providers/base.py', sha1='f5d068c21f230d742e9015b033cd6320f4c68898'),
+            dict(path='../../omlish/logs/base.py', sha1='8d06faee05fead6b1dd98c9035a5b042af4aebb1'),
+            dict(path='../../omlish/logs/std/records.py', sha1='8bbf6ef9eccb3a012c6ca416ddf3969450fd8fc9'),
+            dict(path='../../omlish/subprocesses/base.py', sha1='cb9f668be5422fecb27222caabb67daac6c1bab9'),
+            dict(path='../interp/resolvers.py', sha1='817b8e76401cd7a19eb43ca54d65272e4c8a4b0e'),
+            dict(path='../../omlish/logs/asyncs.py', sha1='ab11b70033d9f2e9a4e70254185aa1c6130c6077'),
+            dict(path='../../omlish/logs/std/loggers.py', sha1='a569179445d6a8a942b5dcfad1d1f77702868803'),
+            dict(path='../../omlish/subprocesses/asyncs.py', sha1='bba44d524c24c6ac73168aee6343488414e5bf48'),
+            dict(path='../../omlish/subprocesses/sync.py', sha1='8434919eba4da67825773d56918fdc0cb2f1883b'),
+            dict(path='../git/revisions.py', sha1='a26b5afa568313e034b6b2d3a5d2dd0b065979d4'),
+            dict(path='../../omlish/asyncs/asyncio/subprocesses.py', sha1='b6b5f9ae3fd0b9c83593bad2e04a08f726e5904d'),
+            dict(path='../../omlish/logs/modules.py', sha1='dd7d5f8e63fe8829dfb49460f3929ab64b68ee14'),
+            dict(path='../interp/inspect.py', sha1='736287b4ec8d14a8c30afa0ba23996fdc0662caa'),
+            dict(path='../interp/pyenv/pyenv.py', sha1='d1f6e657c671c1b1a5b0e627284df656fe2d10d3'),
+            dict(path='../interp/uv/uv.py', sha1='8c6515cd6755efab3972da92a285e94ccb255515'),
+            dict(path='../packaging/revisions.py', sha1='9ba90e4a93b1bfcc93f6ca65dbaaf38f79929677'),
+            dict(path='reqs.py', sha1='822e265b0d2e6d9548ee24d3ac60c81066e40ee8'),
+            dict(path='../interp/providers/running.py', sha1='85c9cc69ff6fbd6c8cf78ed6262619a30856c2f1'),
+            dict(path='../interp/providers/system.py', sha1='9638a154475ca98775159d27739563ac7fb2eb16'),
+            dict(path='../interp/pyenv/install.py', sha1='4a10a19717364b4ba9f3b8bf1d12621cf21ba8b8'),
+            dict(path='../interp/uv/provider.py', sha1='3c3980878ad2b9fd2cd02172f9424954759c7f06'),
+            dict(path='pkg.py', sha1='a7b64fcf267ba385442393b90c9711af08ba9ac3'),
+            dict(path='../interp/providers/inject.py', sha1='7cc9ebf58cf2ec09545321456bd9da9f9a3a79fb'),
+            dict(path='../interp/pyenv/provider.py', sha1='377542ce01a35849e2a5b4a4dbafedc26882f983'),
+            dict(path='../interp/uv/inject.py', sha1='e95d058c2340baa5a3155ec3440f311d1daa10a8'),
+            dict(path='../interp/pyenv/inject.py', sha1='b8fb68f5a7cae86c70fe1bad6c29a8b2dfc985c3'),
+            dict(path='../interp/inject.py', sha1='b039abbadf0b096d2724182af2e0ebda2a230852'),
+            dict(path='../interp/default.py', sha1='a799969a0d3f4b57538587b13ceb08f6334ebc16'),
+            dict(path='../interp/venvs.py', sha1='9ba8f2c3131d7d519d5cf36ca69b75f9c6fe2b27'),
+            dict(path='configs.py', sha1='7b1c1ed034ecb728d67ff15e3bb2b21a218773c9'),
+            dict(path='venvs.py', sha1='9f1935171017aeb802da56e14d7f41d632a7aa25'),
+            dict(path='cli.py', sha1='77efd5e792baa941a79adef6b363751dbd6a0d3e'),
+        ],
+    )
+
+
 ########################################
 
 
@@ -96,8 +177,10 @@ TomlParseFloat = ta.Callable[[str], ta.Any]  # ta.TypeAlias
 TomlKey = ta.Tuple[str, ...]  # ta.TypeAlias
 TomlPos = int  # ta.TypeAlias
 
-# ../../omlish/lite/cached.py
+# ../../omlish/lite/abstract.py
 T = ta.TypeVar('T')
+
+# ../../omlish/lite/cached.py
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 # ../../omlish/lite/check.py
@@ -137,6 +220,11 @@ LoggingExcInfo = ta.Union[BaseException, LoggingExcInfoTuple]  # ta.TypeAlias
 LoggingExcInfoArg = ta.Union[LoggingExcInfo, bool, None]  # ta.TypeAlias
 LoggingContextInfo = ta.Any  # ta.TypeAlias
 
+# ../packaging/requires.py
+RequiresMarkerVar = ta.Union['RequiresVariable', 'RequiresValue']  # ta.TypeAlias
+RequiresMarkerAtom = ta.Union['RequiresMarkerItem', ta.Sequence['RequiresMarkerAtom']]  # ta.TypeAlias
+RequiresMarkerList = ta.Sequence[ta.Union['RequiresMarkerList', 'RequiresMarkerAtom', str]]  # ta.TypeAlias
+
 # ../../omlish/asyncs/asyncio/timeouts.py
 AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
 
@@ -361,12 +449,12 @@ class _BaseVersion:
 
     def __lt__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key < other._key
 
     def __le__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key <= other._key
 
     def __eq__(self, other: object) -> bool:
@@ -376,12 +464,12 @@ class _BaseVersion:
 
     def __ge__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key >= other._key
 
     def __gt__(self, other: '_BaseVersion') -> bool:
         if not isinstance(other, _BaseVersion):
-            return NotImplemented  # type: ignore
+            return NotImplemented
         return self._key > other._key
 
     def __ne__(self, other: object) -> bool:
@@ -765,11 +853,13 @@ class WheelFile(zipfile.ZipFile):
     @staticmethod
     def _urlsafe_b64encode(data: bytes) -> bytes:
         """urlsafe_b64encode without padding"""
+
         return base64.urlsafe_b64encode(data).rstrip(b'=')
 
     @staticmethod
     def _urlsafe_b64decode(data: bytes) -> bytes:
         """urlsafe_b64decode without padding"""
+
         pad = b'=' * (4 - (len(data) & 3))
         return base64.urlsafe_b64decode(data + pad)
 
@@ -1959,25 +2049,49 @@ def is_abstract_method(obj: ta.Any) -> bool:
     return bool(getattr(obj, _IS_ABSTRACT_METHOD_ATTR, False))
 
 
-def update_abstracts(cls, *, force=False):
+def compute_abstract_methods(cls: type) -> ta.FrozenSet[str]:
+    # ~> https://github.com/python/cpython/blob/f3476c6507381ca860eec0989f53647b13517423/Modules/_abc.c#L358
+
+    # Stage 1: direct abstract methods
+
+    abstracts = {
+        a
+        # Get items as a list to avoid mutation issues during iteration
+        for a, v in list(cls.__dict__.items())
+        if is_abstract_method(v)
+    }
+
+    # Stage 2: inherited abstract methods
+
+    for base in cls.__bases__:
+        # Get __abstractmethods__ from base if it exists
+        if (base_abstracts := getattr(base, _ABSTRACT_METHODS_ATTR, None)) is None:
+            continue
+
+        # Iterate over abstract methods in base
+        for key in base_abstracts:
+            # Check if this class has an attribute with this name
+            try:
+                value = getattr(cls, key)
+            except AttributeError:
+                # Attribute not found in this class, skip
+                continue
+
+            # Check if it's still abstract
+            if is_abstract_method(value):
+                abstracts.add(key)
+
+    return frozenset(abstracts)
+
+
+def update_abstracts(cls: ta.Type[T], *, force: bool = False) -> ta.Type[T]:
     if not force and not hasattr(cls, _ABSTRACT_METHODS_ATTR):
         # Per stdlib: We check for __abstractmethods__ here because cls might by a C implementation or a python
         # implementation (especially during testing), and we want to handle both cases.
         return cls
 
-    abstracts: ta.Set[str] = set()
-
-    for scls in cls.__bases__:
-        for name in getattr(scls, _ABSTRACT_METHODS_ATTR, ()):
-            value = getattr(cls, name, None)
-            if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-                abstracts.add(name)
-
-    for name, value in cls.__dict__.items():
-        if getattr(value, _IS_ABSTRACT_METHOD_ATTR, False):
-            abstracts.add(name)
-
-    setattr(cls, _ABSTRACT_METHODS_ATTR, frozenset(abstracts))
+    abstracts = compute_abstract_methods(cls)
+    setattr(cls, _ABSTRACT_METHODS_ATTR, abstracts)
     return cls
 
 
@@ -2031,23 +2145,26 @@ class Abstract:
         super().__init_subclass__(**kwargs)
 
         if not (Abstract in cls.__bases__ or abc.ABC in cls.__bases__):
-            ams = {a: cls for a, o in cls.__dict__.items() if is_abstract_method(o)}
+            if ams := compute_abstract_methods(cls):
+                amd = {
+                    a: mcls
+                    for mcls in cls.__mro__[::-1]
+                    for a in ams
+                    if a in mcls.__dict__
+                }
 
-            seen = set(cls.__dict__)
-            for b in cls.__bases__:
-                ams.update({a: b for a in set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen})  # noqa
-                seen.update(dir(b))
-
-            if ams:
                 raise AbstractTypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods: ' +
                     ', '.join(sorted([
                         '.'.join([
-                            *([m] if (m := getattr(c, '__module__')) else []),
-                            getattr(c, '__qualname__', getattr(c, '__name__')),
+                            *([
+                                *([m] if (m := getattr(c, '__module__')) else []),
+                                getattr(c, '__qualname__', getattr(c, '__name__')),
+                            ] if c is not None else '?'),
                             a,
                         ])
-                        for a, c in ams.items()
+                        for a in ams
+                        for c in [amd.get(a)]
                     ])),
                 )
 
@@ -2064,6 +2181,150 @@ class Abstract:
             update_abstracts(cls, force=True)
 
 
+########################################
+# ../../../omlish/lite/asyncs.py
+
+
+##
+
+
+async def opt_await(aw: ta.Optional[ta.Awaitable[T]]) -> ta.Optional[T]:
+    return (await aw if aw is not None else None)
+
+
+async def async_list(ai: ta.AsyncIterable[T]) -> ta.List[T]:
+    return [v async for v in ai]
+
+
+async def async_enumerate(ai: ta.AsyncIterable[T]) -> ta.AsyncIterable[ta.Tuple[int, T]]:
+    i = 0
+    async for e in ai:
+        yield (i, e)
+        i += 1
+
+
+##
+
+
+def as_async(fn: ta.Callable[..., T], *, wrap: bool = False) -> ta.Callable[..., ta.Awaitable[T]]:
+    async def inner(*args, **kwargs):
+        return fn(*args, **kwargs)
+
+    return functools.wraps(fn)(inner) if wrap else inner
+
+
+##
+
+
+class SyncAwaitCoroutineNotTerminatedError(Exception):
+    pass
+
+
+def sync_await(aw: ta.Awaitable[T]) -> T:
+    """
+    Allows for the synchronous execution of async functions which will never actually *externally* await anything. These
+    functions are allowed to await any number of other functions - including contextmanagers and generators - so long as
+    nothing ever actually 'leaks' out of the function, presumably to an event loop.
+    """
+
+    ret = missing = object()
+
+    async def thunk():
+        nonlocal ret
+
+        ret = await aw
+
+    cr = thunk()
+    try:
+        try:
+            cr.send(None)
+        except StopIteration:
+            pass
+
+        if ret is missing or cr.cr_await is not None or cr.cr_running:
+            raise SyncAwaitCoroutineNotTerminatedError('Not terminated')
+
+    finally:
+        cr.close()
+
+    return ta.cast(T, ret)
+
+
+#
+
+
+def sync_aiter(ai: ta.AsyncIterator[T]) -> ta.Iterator[T]:
+    while True:
+        try:
+            o = sync_await(ai.__anext__())
+        except StopAsyncIteration:
+            break
+        yield o
+
+
+def sync_async_list(ai: ta.AsyncIterable[T]) -> ta.List[T]:
+    """
+    Uses `sync_await` to synchronously read the full contents of a function call returning an async iterator, given that
+    the function never externally awaits anything.
+    """
+
+    lst: ta.Optional[ta.List[T]] = None
+
+    async def inner():
+        nonlocal lst
+
+        lst = [v async for v in ai]
+
+    sync_await(inner())
+
+    if not isinstance(lst, list):
+        raise TypeError(lst)
+
+    return lst
+
+
+#
+
+
+@ta.final
+class SyncAwaitContextManager(ta.Generic[T]):
+    def __init__(self, acm: ta.AsyncContextManager[T]) -> None:
+        self._acm = acm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._acm!r})'
+
+    def __enter__(self) -> T:
+        return sync_await(self._acm.__aenter__())
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return sync_await(self._acm.__aexit__(exc_type, exc_val, exc_tb))
+
+
+sync_async_with = SyncAwaitContextManager
+
+
+##
+
+
+@ta.final
+class SyncToAsyncContextManager(ta.Generic[T]):
+    def __init__(self, cm: ta.ContextManager[T]) -> None:
+        self._cm = cm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._cm!r})'
+
+    async def __aenter__(self) -> T:
+        return self._cm.__enter__()
+
+    async def __aexit__(self, exc_type, exc_value, traceback, /):
+        return self._cm.__exit__(exc_type, exc_value, traceback)
+
+
+as_async_context_manager = SyncToAsyncContextManager
+
+
 ########################################
 # ../../../omlish/lite/cached.py
 
@@ -2121,6 +2382,62 @@ def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
     return _AsyncCachedNullary(fn)
 
 
+##
+
+
+cached_property = functools.cached_property
+
+
+class _cached_property:  # noqa
+    """Backported to pick up https://github.com/python/cpython/commit/056dfc71dce15f81887f0bd6da09d6099d71f979 ."""
+
+    def __init__(self, func):
+        self.func = func
+        self.attrname = None  # noqa
+        self.__doc__ = func.__doc__
+        self.__module__ = func.__module__
+
+    _NOT_FOUND = object()
+
+    def __set_name__(self, owner, name):
+        if self.attrname is None:
+            self.attrname = name  # noqa
+        elif name != self.attrname:
+            raise TypeError(
+                f'Cannot assign the same cached_property to two different names ({self.attrname!r} and {name!r}).',
+            )
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self.attrname is None:
+            raise TypeError('Cannot use cached_property instance without calling __set_name__ on it.')
+
+        try:
+            cache = instance.__dict__
+        except AttributeError:  # not all objects have __dict__ (e.g. class defines slots)
+            raise TypeError(
+                f"No '__dict__' attribute on {type(instance).__name__!r} instance to cache {self.attrname!r} property.",
+            ) from None
+
+        val = cache.get(self.attrname, self._NOT_FOUND)
+
+        if val is self._NOT_FOUND:
+            val = self.func(instance)
+            try:
+                cache[self.attrname] = val
+            except TypeError:
+                raise TypeError(
+                    f"The '__dict__' attribute on {type(instance).__name__!r} instance does not support item "
+                    f"assignment for caching {self.attrname!r} property.",
+                ) from None
+
+        return val
+
+
+globals()['cached_property'] = _cached_property
+
+
 ########################################
 # ../../../omlish/lite/check.py
 """
@@ -2909,6 +3226,12 @@ def format_num_bytes(num_bytes: int) -> str:
 
 ##
 # A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+#
+# Note that this problem doesn't happen at runtime - it happens in mypy:
+#
+#   mypy <(echo "import typing as ta; MyCallback = ta.NewType('MyCallback', ta.Callable[[], None])")
+#   /dev/fd/11:1:22: error: Argument 2 to NewType(...) must be subclassable (got "Callable[[], None]")  [valid-newtype]
+#
 
 
 @dc.dataclass(frozen=True)
@@ -2954,6 +3277,24 @@ class Func3(ta.Generic[A0, A1, A2, T]):
 ##
 
 
+@dc.dataclass(frozen=True)
+class CachedFunc0(ta.Generic[T]):
+    fn: ta.Callable[[], T]
+
+    def __call__(self) -> T:
+        try:
+            return object.__getattribute__(self, '_value')
+        except AttributeError:
+            pass
+
+        value = self.fn()
+        object.__setattr__(self, '_value', value)
+        return value
+
+
+##
+
+
 _TYPING_ANNOTATIONS_ATTR = '__annotate__' if sys.version_info >= (3, 14) else '__annotations__'
 
 
@@ -3868,7 +4209,7 @@ class SpecifierSet(BaseSpecifier):
         if isinstance(other, str):
             other = SpecifierSet(other)
         elif not isinstance(other, SpecifierSet):
-            return NotImplemented  # type: ignore
+            return NotImplemented
 
         specifier = SpecifierSet()
         specifier._specs = frozenset(self._specs | other._specs)
@@ -3888,6 +4229,7 @@ class SpecifierSet(BaseSpecifier):
         if isinstance(other, (str, Specifier)):
             other = SpecifierSet(str(other))
         elif not isinstance(other, SpecifierSet):
+
             return NotImplemented
 
         return self._specs == other._specs
@@ -3959,6 +4301,7 @@ TODO:
  - pre-run, post-run hooks
  - exitstack?
  - suggestion - difflib.get_close_matches
+ - add_argument_group - group kw on ArgparseKwarg?
 """
 
 
@@ -3969,6 +4312,7 @@ TODO:
 class ArgparseArg:
     args: ta.Sequence[ta.Any]
     kwargs: ta.Mapping[str, ta.Any]
+    group: ta.Optional[str] = None
     dest: ta.Optional[str] = None
 
     def __get__(self, instance, owner=None):
@@ -3978,7 +4322,11 @@ class ArgparseArg:
 
 
 def argparse_arg(*args, **kwargs) -> ArgparseArg:
-    return ArgparseArg(args, kwargs)
+    return ArgparseArg(
+        args=args,
+        group=kwargs.pop('group', None),
+        kwargs=kwargs,
+    )
 
 
 def argparse_arg_(*args, **kwargs) -> ta.Any:
@@ -4148,6 +4496,10 @@ class ArgparseCli:
                     subparser.set_defaults(_cmd=obj)
 
             elif isinstance(obj, ArgparseArg):
+                if obj.group is not None:
+                    # FIXME: add_argument_group
+                    raise NotImplementedError
+
                 if att in anns:
                     ann_kwargs = _get_argparse_arg_ann_kwargs(anns[att])
                     obj.kwargs = {**ann_kwargs, **obj.kwargs}
@@ -4193,7 +4545,7 @@ class ArgparseCli:
 
         if self._unknown_args and not (cmd is not None and cmd.accepts_unknown):
             msg = f'unrecognized arguments: {" ".join(self._unknown_args)}'
-            if (parser := self.get_parser()).exit_on_error:
+            if (parser := self.get_parser()).exit_on_error:  # noqa
                 parser.error(msg)
             else:
                 raise argparse.ArgumentError(None, msg)
@@ -4213,7 +4565,10 @@ class ArgparseCli:
         return fn()
 
     def cli_run_and_exit(self) -> ta.NoReturn:
-        sys.exit(rc if isinstance(rc := self.cli_run(), int) else 0)
+        rc = self.cli_run()
+        if not isinstance(rc, int):
+            rc = 0
+        raise SystemExit(rc)
 
     def __call__(self, *, exit: bool = False) -> ta.Optional[int]:  # noqa
         if exit:
@@ -5165,8 +5520,6 @@ class _JustMaybe(_Maybe[T]):
     __slots__ = ('_v', '_hash')
 
     def __init__(self, v: T) -> None:
-        super().__init__()
-
         self._v = v
 
     @property
@@ -5224,6 +5577,13 @@ class _EmptyMaybe(_Maybe[T]):
 Maybe._empty = _EmptyMaybe()  # noqa
 
 
+##
+
+
+setattr(Maybe, 'just', _JustMaybe)  # noqa
+setattr(Maybe, 'empty', functools.partial(operator.attrgetter('_empty'), Maybe))
+
+
 ########################################
 # ../../../omlish/lite/runtime.py
 
@@ -5970,9 +6330,10 @@ class InterpSpecifier:
     def parse(cls, s: str) -> 'InterpSpecifier':
         s, o = InterpOpts.parse_suffix(s)
         if not any(s.startswith(o) for o in Specifier.OPERATORS):
-            s = '~=' + s
             if s.count('.') < 2:
-                s += '.0'
+                s = '~=' + s + '.0'
+            else:
+                s = '==' + s
         return cls(
             specifier=Specifier(s),
             opts=o,
@@ -5995,62 +6356,544 @@ class Interp:
 
 
 ########################################
-# ../../../omlish/asyncs/asyncio/timeouts.py
+# ../../packaging/requires.py
+# Copyright (c) Donald Stufft and individual contributors.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+# following conditions are met:
+#
+#     1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
+#        following disclaimer.
+#
+#     2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+#        following disclaimer in the documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. This file is dual licensed under the terms of the
+# Apache License, Version 2.0, and the BSD License. See the LICENSE file in the root of this repository for complete
+# details.
+# https://github.com/pypa/packaging/blob/cf2cbe2aec28f87c6228a6fb136c27931c9af407/src/packaging/_parser.py#L65
 
 
 ##
 
 
-def asyncio_maybe_timeout(
-        fut: AwaitableT,
-        timeout: TimeoutLike = None,
-) -> AwaitableT:
-    if timeout is not None:
-        fut = asyncio.wait_for(fut, Timeout.of(timeout)())  # type: ignore
-    return fut
+@dc.dataclass()
+class RequiresToken:
+    name: str
+    text: str
+    position: int
 
 
-########################################
-# ../../../omlish/lite/inject.py
+class RequiresParserSyntaxError(Exception):
+    def __init__(
+        self,
+        message: str,
+        *,
+        source: str,
+        span: ta.Tuple[int, int],
+    ) -> None:
+        self.span = span
+        self.message = message
+        self.source = source
 
+        super().__init__()
 
-###
-# types
+    def __str__(self) -> str:
+        marker = ' ' * self.span[0] + '~' * (self.span[1] - self.span[0]) + '^'
+        return '\n    '.join([self.message, self.source, marker])
+
+
+REQUIRES_DEFAULT_RULES: ta.Dict[str, ta.Union[str, ta.Pattern[str]]] = {
+    'LEFT_PARENTHESIS': r'\(',
+    'RIGHT_PARENTHESIS': r'\)',
+    'LEFT_BRACKET': r'\[',
+    'RIGHT_BRACKET': r'\]',
+    'SEMICOLON': r';',
+    'COMMA': r',',
+    'QUOTED_STRING': re.compile(
+        r"""
+            (
+                ('[^']*')
+                |
+                ("[^"]*")
+            )
+        """,
+        re.VERBOSE,
+    ),
+    'OP': r'(===|==|~=|!=|<=|>=|<|>)',
+    'BOOLOP': r'\b(or|and)\b',
+    'IN': r'\bin\b',
+    'NOT': r'\bnot\b',
+    'VARIABLE': re.compile(
+        r"""
+            \b(
+                python_version
+                |python_full_version
+                |os[._]name
+                |sys[._]platform
+                |platform_(release|system)
+                |platform[._](version|machine|python_implementation)
+                |python_implementation
+                |implementation_(name|version)
+                |extra
+            )\b
+        """,
+        re.VERBOSE,
+    ),
+    'SPECIFIER': re.compile(
+        Specifier._operator_regex_str + Specifier._version_regex_str,  # noqa
+        re.VERBOSE | re.IGNORECASE,
+    ),
+    'AT': r'\@',
+    'URL': r'[^ \t]+',
+    'IDENTIFIER': r'\b[a-zA-Z0-9][a-zA-Z0-9._-]*\b',
+    'VERSION_PREFIX_TRAIL': r'\.\*',
+    'VERSION_LOCAL_LABEL_TRAIL': r'\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*',
+    'WS': r'[ \t]+',
+    'END': r'$',
+}
 
 
-@dc.dataclass(frozen=True)
-class InjectorKey(ta.Generic[T]):
-    # Before PEP-560 typing.Generic was a metaclass with a __new__ that takes a 'cls' arg, so instantiating a dataclass
-    # with kwargs (such as through dc.replace) causes `TypeError: __new__() got multiple values for argument 'cls'`.
-    # See:
-    #  - https://github.com/python/cpython/commit/d911e40e788fb679723d78b6ea11cabf46caed5a
-    #  - https://gist.github.com/wrmsr/4468b86efe9f373b6b114bfe85b98fd3
-    cls_: InjectorKeyCls
+class RequiresTokenizer:
+    def __init__(
+        self,
+        source: str,
+        *,
+        rules: ta.Dict[str, ta.Union[str, ta.Pattern[str]]],
+    ) -> None:
+        super().__init__()
 
-    tag: ta.Any = None
-    array: bool = False
+        self.source = source
+        self.rules: ta.Dict[str, ta.Pattern[str]] = {name: re.compile(pattern) for name, pattern in rules.items()}
+        self.next_token: ta.Optional[RequiresToken] = None
+        self.position = 0
 
+    def consume(self, name: str) -> None:
+        if self.check(name):
+            self.read()
 
-def is_valid_injector_key_cls(cls: ta.Any) -> bool:
-    return isinstance(cls, type) or is_new_type(cls)
+    def check(self, name: str, *, peek: bool = False) -> bool:
+        check.state(self.next_token is None, f'Cannot check for {name!r}, already have {self.next_token!r}')
+        check.state(name in self.rules, f'Unknown token name: {name!r}')
 
+        expression = self.rules[name]
 
-def check_valid_injector_key_cls(cls: T) -> T:
-    if not is_valid_injector_key_cls(cls):
-        raise TypeError(cls)
-    return cls
+        match = expression.match(self.source, self.position)
+        if match is None:
+            return False
+        if not peek:
+            self.next_token = RequiresToken(name, match[0], self.position)
+        return True
 
+    def expect(self, name: str, *, expected: str) -> RequiresToken:
+        if not self.check(name):
+            raise self.raise_syntax_error(f'Expected {expected}')
+        return self.read()
 
-##
+    def read(self) -> RequiresToken:
+        token = self.next_token
+        check.state(token is not None)
 
+        self.position += len(check.not_none(token).text)
+        self.next_token = None
 
-class InjectorProvider(Abstract):
-    @abc.abstractmethod
-    def provider_fn(self) -> InjectorProviderFn:
-        raise NotImplementedError
+        return check.not_none(token)
 
+    def raise_syntax_error(
+        self,
+        message: str,
+        *,
+        span_start: ta.Optional[int] = None,
+        span_end: ta.Optional[int] = None,
+    ) -> ta.NoReturn:
+        span = (
+            self.position if span_start is None else span_start,
+            self.position if span_end is None else span_end,
+        )
+        raise RequiresParserSyntaxError(
+            message,
+            source=self.source,
+            span=span,
+        )
 
-##
+    @contextlib.contextmanager
+    def enclosing_tokens(self, open_token: str, close_token: str, *, around: str) -> ta.Iterator[None]:
+        if self.check(open_token):
+            open_position = self.position
+            self.read()
+        else:
+            open_position = None
+
+        yield
+
+        if open_position is None:
+            return
+
+        if not self.check(close_token):
+            self.raise_syntax_error(
+                f'Expected matching {close_token} for {open_token}, after {around}',
+                span_start=open_position,
+            )
+
+        self.read()
+
+
+@dc.dataclass(frozen=True)
+class RequiresNode:
+    value: str
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}('{self}')>"
+
+    def serialize(self) -> str:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class RequiresVariable(RequiresNode):
+    def serialize(self) -> str:
+        return str(self)
+
+
+@dc.dataclass(frozen=True)
+class RequiresValue(RequiresNode):
+    def serialize(self) -> str:
+        return f'"{self}"'
+
+
+@dc.dataclass(frozen=True)
+class RequiresOp(RequiresNode):
+    def serialize(self) -> str:
+        return str(self)
+
+
+class RequiresMarkerItem(ta.NamedTuple):
+    l: ta.Union[RequiresVariable, RequiresValue]
+    op: RequiresOp
+    r: ta.Union[RequiresVariable, RequiresValue]
+
+
+class ParsedRequirement(ta.NamedTuple):
+    name: str
+    url: str
+    extras: ta.List[str]
+    specifier: str
+    marker: ta.Optional[RequiresMarkerList]
+
+
+def parse_requirement(source: str) -> ParsedRequirement:
+    return _parse_requirement(RequiresTokenizer(source, rules=REQUIRES_DEFAULT_RULES))
+
+
+def _parse_requirement(tokenizer: RequiresTokenizer) -> ParsedRequirement:
+    tokenizer.consume('WS')
+
+    name_token = tokenizer.expect('IDENTIFIER', expected='package name at the start of dependency specifier')
+    name = name_token.text
+    tokenizer.consume('WS')
+
+    extras = _parse_requires_extras(tokenizer)
+    tokenizer.consume('WS')
+
+    url, specifier, marker = _parse_requirement_details(tokenizer)
+    tokenizer.expect('END', expected='end of dependency specifier')
+
+    return ParsedRequirement(name, url, extras, specifier, marker)
+
+
+def _parse_requirement_details(tokenizer: RequiresTokenizer) -> ta.Tuple[str, str, ta.Optional[RequiresMarkerList]]:
+    specifier = ''
+    url = ''
+    marker = None
+
+    if tokenizer.check('AT'):
+        tokenizer.read()
+        tokenizer.consume('WS')
+
+        url_start = tokenizer.position
+        url = tokenizer.expect('URL', expected='URL after @').text
+        if tokenizer.check('END', peek=True):
+            return (url, specifier, marker)
+
+        tokenizer.expect('WS', expected='whitespace after URL')
+
+        # The input might end after whitespace.
+        if tokenizer.check('END', peek=True):
+            return (url, specifier, marker)
+
+        marker = _parse_requirement_marker(
+            tokenizer, span_start=url_start, after='URL and whitespace',
+        )
+    else:
+        specifier_start = tokenizer.position
+        specifier = _parse_requires_specifier(tokenizer)
+        tokenizer.consume('WS')
+
+        if tokenizer.check('END', peek=True):
+            return (url, specifier, marker)
+
+        marker = _parse_requirement_marker(
+            tokenizer,
+            span_start=specifier_start,
+            after=(
+                'version specifier'
+                if specifier
+                else 'name and no valid version specifier'
+            ),
+        )
+
+    return (url, specifier, marker)
+
+
+def _parse_requirement_marker(
+    tokenizer: RequiresTokenizer, *, span_start: int, after: str,
+) -> RequiresMarkerList:
+    if not tokenizer.check('SEMICOLON'):
+        tokenizer.raise_syntax_error(
+            f'Expected end or semicolon (after {after})',
+            span_start=span_start,
+        )
+    tokenizer.read()
+
+    marker = _parse_requires_marker(tokenizer)
+    tokenizer.consume('WS')
+
+    return marker
+
+
+def _parse_requires_extras(tokenizer: RequiresTokenizer) -> ta.List[str]:
+    if not tokenizer.check('LEFT_BRACKET', peek=True):
+        return []
+
+    with tokenizer.enclosing_tokens(
+        'LEFT_BRACKET',
+        'RIGHT_BRACKET',
+        around='extras',
+    ):
+        tokenizer.consume('WS')
+        extras = _parse_requires_extras_list(tokenizer)
+        tokenizer.consume('WS')
+
+    return extras
+
+
+def _parse_requires_extras_list(tokenizer: RequiresTokenizer) -> ta.List[str]:
+    extras: ta.List[str] = []
+
+    if not tokenizer.check('IDENTIFIER'):
+        return extras
+
+    extras.append(tokenizer.read().text)
+
+    while True:
+        tokenizer.consume('WS')
+        if tokenizer.check('IDENTIFIER', peek=True):
+            tokenizer.raise_syntax_error('Expected comma between extra names')
+        elif not tokenizer.check('COMMA'):
+            break
+
+        tokenizer.read()
+        tokenizer.consume('WS')
+
+        extra_token = tokenizer.expect('IDENTIFIER', expected='extra name after comma')
+        extras.append(extra_token.text)
+
+    return extras
+
+
+def _parse_requires_specifier(tokenizer: RequiresTokenizer) -> str:
+    with tokenizer.enclosing_tokens(
+        'LEFT_PARENTHESIS',
+        'RIGHT_PARENTHESIS',
+        around='version specifier',
+    ):
+        tokenizer.consume('WS')
+        parsed_specifiers = _parse_requires_version_many(tokenizer)
+        tokenizer.consume('WS')
+
+    return parsed_specifiers
+
+
+def _parse_requires_version_many(tokenizer: RequiresTokenizer) -> str:
+    parsed_specifiers = ''
+    while tokenizer.check('SPECIFIER'):
+        span_start = tokenizer.position
+        parsed_specifiers += tokenizer.read().text
+        if tokenizer.check('VERSION_PREFIX_TRAIL', peek=True):
+            tokenizer.raise_syntax_error(
+                '.* suffix can only be used with `==` or `!=` operators',
+                span_start=span_start,
+                span_end=tokenizer.position + 1,
+            )
+        if tokenizer.check('VERSION_LOCAL_LABEL_TRAIL', peek=True):
+            tokenizer.raise_syntax_error(
+                'Local version label can only be used with `==` or `!=` operators',
+                span_start=span_start,
+                span_end=tokenizer.position,
+            )
+        tokenizer.consume('WS')
+        if not tokenizer.check('COMMA'):
+            break
+        parsed_specifiers += tokenizer.read().text
+        tokenizer.consume('WS')
+
+    return parsed_specifiers
+
+
+def parse_requires_marker(source: str) -> RequiresMarkerList:
+    return _parse_requires_full_marker(RequiresTokenizer(source, rules=REQUIRES_DEFAULT_RULES))
+
+
+def _parse_requires_full_marker(tokenizer: RequiresTokenizer) -> RequiresMarkerList:
+    retval = _parse_requires_marker(tokenizer)
+    tokenizer.expect('END', expected='end of marker expression')
+    return retval
+
+
+def _parse_requires_marker(tokenizer: RequiresTokenizer) -> RequiresMarkerList:
+    expression = [_parse_requires_marker_atom(tokenizer)]
+    while tokenizer.check('BOOLOP'):
+        token = tokenizer.read()
+        expr_right = _parse_requires_marker_atom(tokenizer)
+        expression.extend((token.text, expr_right))
+    return expression
+
+
+def _parse_requires_marker_atom(tokenizer: RequiresTokenizer) -> RequiresMarkerAtom:
+    tokenizer.consume('WS')
+    if tokenizer.check('LEFT_PARENTHESIS', peek=True):
+        with tokenizer.enclosing_tokens(
+            'LEFT_PARENTHESIS',
+            'RIGHT_PARENTHESIS',
+            around='marker expression',
+        ):
+            tokenizer.consume('WS')
+            marker: RequiresMarkerAtom = _parse_requires_marker(tokenizer)
+            tokenizer.consume('WS')
+    else:
+        marker = _parse_requires_marker_item(tokenizer)
+    tokenizer.consume('WS')
+    return marker
+
+
+def _parse_requires_marker_item(tokenizer: RequiresTokenizer) -> RequiresMarkerItem:
+    tokenizer.consume('WS')
+    marker_var_left = _parse_requires_marker_var(tokenizer)
+    tokenizer.consume('WS')
+    marker_op = _parse_requires_marker_op(tokenizer)
+    tokenizer.consume('WS')
+    marker_var_right = _parse_requires_marker_var(tokenizer)
+    tokenizer.consume('WS')
+    return RequiresMarkerItem(marker_var_left, marker_op, marker_var_right)
+
+
+def _parse_requires_marker_var(tokenizer: RequiresTokenizer) -> RequiresMarkerVar:
+    if tokenizer.check('VARIABLE'):
+        return process_requires_env_var(tokenizer.read().text.replace('.', '_'))
+    elif tokenizer.check('QUOTED_STRING'):
+        return process_requires_python_str(tokenizer.read().text)
+    else:
+        tokenizer.raise_syntax_error(message='Expected a marker variable or quoted string')
+        raise RuntimeError  # noqa
+
+
+def process_requires_env_var(env_var: str) -> RequiresVariable:
+    if env_var in ('platform_python_implementation', 'python_implementation'):
+        return RequiresVariable('platform_python_implementation')
+    else:
+        return RequiresVariable(env_var)
+
+
+def process_requires_python_str(python_str: str) -> RequiresValue:
+    value = ast.literal_eval(python_str)
+    return RequiresValue(str(value))
+
+
+def _parse_requires_marker_op(tokenizer: RequiresTokenizer) -> RequiresOp:
+    if tokenizer.check('IN'):
+        tokenizer.read()
+        return RequiresOp('in')
+    elif tokenizer.check('NOT'):
+        tokenizer.read()
+        tokenizer.expect('WS', expected="whitespace after 'not'")
+        tokenizer.expect('IN', expected="'in' after 'not'")
+        return RequiresOp('not in')
+    elif tokenizer.check('OP'):
+        return RequiresOp(tokenizer.read().text)
+    else:
+        return tokenizer.raise_syntax_error(
+            'Expected marker operator, one of '
+            '<=, <, !=, ==, >=, >, ~=, ===, in, not in',
+        )
+
+
+########################################
+# ../../../omlish/asyncs/asyncio/timeouts.py
+
+
+##
+
+
+def asyncio_maybe_timeout(
+        fut: AwaitableT,
+        timeout: TimeoutLike = None,
+) -> AwaitableT:
+    if timeout is not None:
+        fut = asyncio.wait_for(fut, Timeout.of(timeout)())  # type: ignore
+    return fut
+
+
+########################################
+# ../../../omlish/lite/inject.py
+
+
+###
+# types
+
+
+@dc.dataclass(frozen=True)
+class InjectorKey(ta.Generic[T]):
+    # Before PEP-560 typing.Generic was a metaclass with a __new__ that takes a 'cls' arg, so instantiating a dataclass
+    # with kwargs (such as through dc.replace) causes `TypeError: __new__() got multiple values for argument 'cls'`.
+    # See:
+    #  - https://github.com/python/cpython/commit/d911e40e788fb679723d78b6ea11cabf46caed5a
+    #  - https://gist.github.com/wrmsr/4468b86efe9f373b6b114bfe85b98fd3
+    cls_: InjectorKeyCls
+
+    tag: ta.Any = None
+    array: bool = False
+
+
+def is_valid_injector_key_cls(cls: ta.Any) -> bool:
+    return isinstance(cls, type) or is_new_type(cls)
+
+
+def check_valid_injector_key_cls(cls: T) -> T:
+    if not is_valid_injector_key_cls(cls):
+        raise TypeError(cls)
+    return cls
+
+
+##
+
+
+class InjectorProvider(Abstract):
+    @abc.abstractmethod
+    def provider_fn(self) -> InjectorProviderFn:
+        raise NotImplementedError
+
+
+##
 
 
 @dc.dataclass(frozen=True)
@@ -7201,6 +8044,9 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
                 self._infos[type(info)] = info
         return self
 
+    def get_infos(self) -> ta.Mapping[ta.Type[LoggingContextInfo], LoggingContextInfo]:
+        return self._infos
+
     def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
         return self._infos.get(ty)
 
@@ -7223,7 +8069,7 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
     _stack_offset: int
     _stack_info: bool
 
-    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContext':
+    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContextImpl':
         if hasattr(self, '_stack_offset'):
             self._stack_offset += ofs
         return self
@@ -7255,10 +8101,9 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
 
 
 ########################################
-# ../../../omlish/logs/standard.py
+# ../../../omlish/logs/std/standard.py
 """
 TODO:
- - !! move to std !!
  - structured
  - prefixed
  - debug
@@ -7628,6 +8473,11 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     ##
 
+    # This will be 1 for [Sync]Logger and 0 for AsyncLogger - in sync loggers these methods remain present on the stack,
+    # in async loggers they return a coroutine to be awaited and thus aren't actually present when said coroutine is
+    # awaited.
+    _level_proxy_method_stack_offset: int
+
     @ta.overload
     def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
         ...
@@ -7642,7 +8492,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def log(self, level: LogLevel, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(level, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                level,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -7660,7 +8517,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def debug(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.DEBUG, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.DEBUG,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -7678,7 +8542,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def info(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.INFO, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.INFO,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -7696,7 +8567,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def warning(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.WARNING, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.WARNING,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -7714,7 +8592,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def error(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.ERROR,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -7732,7 +8617,15 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def exception(self, *args, exc_info: LoggingExcInfoArg = True, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, exc_info=exc_info, stack_offset=1), *args, **kwargs)  # noqa
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.ERROR,
+                exc_info=exc_info,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -7750,24 +8643,53 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def critical(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.CRITICAL, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.CRITICAL,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     ##
 
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> T:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> T:
         raise NotImplementedError
 
 
 class Logger(AnyLogger[None], Abstract):
+    _level_proxy_method_stack_offset: int = 1
+
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         raise NotImplementedError
 
 
 class AsyncLogger(AnyLogger[ta.Awaitable[None]], Abstract):
+    _level_proxy_method_stack_offset: int = 0
+
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[None]:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ta.Awaitable[None]:
         raise NotImplementedError
 
 
@@ -7782,13 +8704,25 @@ class AnyNopLogger(AnyLogger[T], Abstract):
 
 @ta.final
 class NopLogger(AnyNopLogger[None], Logger):
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         pass
 
 
 @ta.final
 class AsyncNopLogger(AnyNopLogger[ta.Awaitable[None]], AsyncLogger):
-    async def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         pass
 
 
@@ -8495,6 +9429,10 @@ class VerboseCalledProcessError(subprocess.CalledProcessError):
 class BaseSubprocesses(Abstract):
     DEFAULT_LOGGER: ta.ClassVar[ta.Optional[LoggerLike]] = None
 
+    PIPE: ta.ClassVar[int] = subprocess.PIPE
+    STDOUT: ta.ClassVar[int] = subprocess.STDOUT
+    DEVNULL: ta.ClassVar[int] = subprocess.DEVNULL
+
     def __init__(
             self,
             *,
@@ -8750,6 +9688,70 @@ class InterpResolver:
                     print(f'    {si}')
 
 
+########################################
+# ../../../omlish/logs/asyncs.py
+
+
+##
+
+
+class AsyncLoggerToLogger(Logger):
+    def __init__(self, u: AsyncLogger) -> None:
+        super().__init__()
+
+        self._u = u
+
+    def get_effective_level(self) -> LogLevel:
+        return self._u.get_effective_level()
+
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        # Nope out early to avoid sync_await if possible - don't bother in the LoggerToAsyncLogger.
+        if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
+            return
+
+        # Note: we hardcode the stack offset of sync_await (which is 2 - sync_await + sync_await.thunk). In non-lite
+        # code, lang.sync_await uses a cext if present to avoid being on the py stack, which would obviously complicate
+        # this, but this is lite code so we will always have the non-c version.
+        sync_await(
+            self._u._log(  # noqa
+                check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(3),
+                msg,
+                *args,
+                **kwargs,
+            ),
+        )
+
+
+class LoggerToAsyncLogger(AsyncLogger):
+    def __init__(self, u: Logger) -> None:
+        super().__init__()
+
+        self._u = u
+
+    def get_effective_level(self) -> LogLevel:
+        return self._u.get_effective_level()
+
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        return self._u._log(  # noqa
+            check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(),
+            msg,
+            *args,
+            **kwargs,
+        )
+
+
 ########################################
 # ../../../omlish/logs/std/loggers.py
 
@@ -8773,7 +9775,12 @@ class StdLogger(Logger):
     def get_effective_level(self) -> LogLevel:
         return self._std.getEffectiveLevel()
 
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any) -> None:
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+    ) -> None:
         if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
             return
 
@@ -9292,8 +10299,23 @@ asyncio_subprocesses = AsyncioSubprocesses()
 ##
 
 
+def _get_module_std_logger(mod_globals: ta.Mapping[str, ta.Any]) -> logging.Logger:
+    return logging.getLogger(mod_globals.get('__name__'))
+
+
 def get_module_logger(mod_globals: ta.Mapping[str, ta.Any]) -> Logger:
-    return StdLogger(logging.getLogger(mod_globals.get('__name__')))  # noqa
+    return StdLogger(_get_module_std_logger(mod_globals))
+
+
+def get_module_async_logger(mod_globals: ta.Mapping[str, ta.Any]) -> AsyncLogger:
+    return LoggerToAsyncLogger(get_module_logger(mod_globals))
+
+
+def get_module_loggers(mod_globals: ta.Mapping[str, ta.Any]) -> ta.Tuple[Logger, AsyncLogger]:
+    return (
+        log := get_module_logger(mod_globals),
+        LoggerToAsyncLogger(log),
+    )
 
 
 ########################################
@@ -9684,11 +10706,14 @@ log = get_module_logger(globals())  # noqa
 class RequirementsRewriter:
     def __init__(
             self,
+            *,
             venv: ta.Optional[str] = None,
+            only_pats: ta.Optional[ta.Sequence[re.Pattern]] = None,
     ) -> None:
         super().__init__()
 
         self._venv = venv
+        self._only_pats = only_pats
 
     @cached_nullary
     def _tmp_dir(self) -> str:
@@ -9704,17 +10729,32 @@ class RequirementsRewriter:
         out_lines = []
 
         for l in in_lines:
-            if self.VENV_MAGIC in l:
-                lp, _, rp = l.partition(self.VENV_MAGIC)
-                rp = rp.partition('#')[0]
+            if l.split('#')[0].strip():
                 omit = False
-                for v in rp.split():
-                    if v[0] == '!':
-                        if self._venv is not None and self._venv == v[1:]:
-                            omit = True
-                            break
+
+                if self.VENV_MAGIC in l:
+                    lp, _, rp = l.partition(self.VENV_MAGIC)
+                    rp = rp.partition('#')[0]
+                    for v in rp.split():
+                        if v[0] == '!':
+                            if self._venv is not None and self._venv == v[1:]:
+                                omit = True
+                                break
+                        else:
+                            raise NotImplementedError
+
+                if (
+                        not omit and
+                        (ops := self._only_pats) is not None and
+                        not l.strip().startswith('-')
+                ):
+                    try:
+                        pr = parse_requirement(l.split('#')[0].strip())
+                    except RequiresParserSyntaxError:
+                        pass
                     else:
-                        raise NotImplementedError
+                        if not any(op.fullmatch(pr.name) for op in ops):
+                            omit = True
 
                 if omit:
                     out_lines.append('# OMITTED:  ' + l)
@@ -10171,12 +11211,42 @@ uv run pip
 uv run --python 3.11.6 pip
 uv venv --python 3.11.6 --seed barf
 python3 -m venv barf && barf/bin/pip install uv && barf/bin/uv venv --python 3.11.6 --seed barf2
+uv python find '3.13.10'
+uv python list --output-format=json
 """
 
 
 ##
 
 
+@dc.dataclass(frozen=True)
+class UvPythonListOutput:
+    key: str
+    version: str
+
+    @dc.dataclass(frozen=True)
+    class VersionParts:
+        major: int
+        minor: int
+        patch: int
+
+    version_parts: VersionParts
+
+    path: ta.Optional[str]
+    symlink: ta.Optional[str]
+
+    url: str
+
+    os: str  # emscripten linux macos
+    variant: str  # default freethreaded
+    implementation: str  # cpython graalpy pyodide pypy
+    arch: str  # aarch64 wasm32 x86_64
+    libc: str  # gnu musl none
+
+
+##
+
+
 class UvInterpProvider(InterpProvider):
     def __init__(
             self,
@@ -10197,6 +11267,12 @@ class UvInterpProvider(InterpProvider):
     async def get_installed_version(self, version: InterpVersion) -> Interp:
         raise NotImplementedError
 
+    # async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+    #     return []
+
+    # async def install_version(self, version: InterpVersion) -> Interp:
+    #     raise TypeError
+
 
 ########################################
 # ../pkg.py
@@ -10273,7 +11349,7 @@ class BasePyprojectPackageGenerator(Abstract):
 
     def _write_git_ignore(self) -> None:
         with open(os.path.join(self._pkg_dir(), '.gitignore'), 'w') as f:
-            f.write('\n'.join(self._GIT_IGNORE))
+            f.write('\n'.join([*self._GIT_IGNORE, '']))
 
     #
 
@@ -10442,6 +11518,7 @@ class BasePyprojectPackageGenerator(Abstract):
                 )
 
         if output_dir is not None:
+            log.info(lambda: f'Copying {dist_dir} to {output_dir}')
             for fn in os.listdir(dist_dir):
                 shutil.copyfile(os.path.join(dist_dir, fn), os.path.join(output_dir, fn))
 
@@ -10497,7 +11574,11 @@ class PyprojectPackageGenerator(BasePyprojectPackageGenerator):
         st = dict(specs.setuptools)
         pyp_dct['tool.setuptools'] = st
 
-        st.pop('cexts', None)
+        for k in [
+            'cext',
+            'rs',
+        ]:
+            st.pop(k, None)
 
         #
 
@@ -10570,13 +11651,20 @@ class PyprojectPackageGenerator(BasePyprojectPackageGenerator):
     def children(self) -> ta.Sequence[BasePyprojectPackageGenerator]:
         out: ta.List[BasePyprojectPackageGenerator] = []
 
-        if self.build_specs().setuptools.get('cexts'):
+        if self.build_specs().setuptools.get('cext'):
             out.append(_PyprojectCextPackageGenerator(
                 self._dir_name,
                 self._pkgs_root,
                 pkg_suffix='-cext',
             ))
 
+        if self.build_specs().setuptools.get('rs'):
+            out.append(_PyprojectRsPackageGenerator(
+                self._dir_name,
+                self._pkgs_root,
+                pkg_suffix='-rs',
+            ))
+
         if self.build_specs().pyproject.get('cli_scripts'):
             out.append(_PyprojectCliPackageGenerator(
                 self._dir_name,
@@ -10587,10 +11675,67 @@ class PyprojectPackageGenerator(BasePyprojectPackageGenerator):
         return out
 
 
-#
+##
+
+
+class _PyprojectExtensionPackageGenerator(BasePyprojectPackageGenerator, Abstract):
+    #
+
+    def _build_project_dict(self) -> ta.Dict[str, ta.Any]:
+        prj = dict(self.build_specs().pyproject)
+
+        prj['dependencies'] = [f'{prj["name"]} == {prj["version"]}']
+        prj['name'] += self._pkg_suffix
+
+        for k in [
+            'optional_dependencies',
+            'entry_points',
+            'scripts',
+            'cli_scripts',
+        ]:
+            prj.pop(k, None)
+
+        return prj
+
+    def _build_setuptools_dict(self) -> ta.Dict[str, ta.Any]:
+        st = dict(self.build_specs().setuptools)
+
+        for k in [
+            'cext',
+            'rs',
+
+            'find_packages',
+            'package_data',
+            'manifest_in',
+        ]:
+            st.pop(k, None)
+
+        return st
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class FileContents:
+        pyproject_dct: ta.Mapping[str, ta.Any]
+        setup_py: str
+
+    @abc.abstractmethod
+    def file_contents(self) -> FileContents:
+        raise NotImplementedError
+
+    #
 
+    def _write_file_contents(self) -> None:
+        fc = self.file_contents()
 
-class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
+        with open(os.path.join(self._pkg_dir(), 'pyproject.toml'), 'w') as f:
+            TomlWriter(f).write_root(fc.pyproject_dct)
+
+        with open(os.path.join(self._pkg_dir(), 'setup.py'), 'w') as f:
+            f.write(fc.setup_py)
+
+
+class _PyprojectCextPackageGenerator(_PyprojectExtensionPackageGenerator):
     @cached_nullary
     def find_cext_srcs(self) -> ta.Sequence[str]:
         return sorted(find_magic_files(
@@ -10601,14 +11746,10 @@ class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
 
     #
 
-    @dc.dataclass(frozen=True)
-    class FileContents:
-        pyproject_dct: ta.Mapping[str, ta.Any]
-        setup_py: str
-
     @cached_nullary
-    def file_contents(self) -> FileContents:
-        specs = self.build_specs()
+    def file_contents(self) -> _PyprojectExtensionPackageGenerator.FileContents:
+        prj = self._build_project_dict()
+        st = self._build_setuptools_dict()
 
         #
 
@@ -10619,33 +11760,9 @@ class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
             'build-backend': 'setuptools.build_meta',
         }
 
-        prj = specs.pyproject
-        prj['dependencies'] = [f'{prj["name"]} == {prj["version"]}']
-        prj['name'] += self._pkg_suffix
-        for k in [
-            'optional_dependencies',
-            'entry_points',
-            'scripts',
-            'cli_scripts',
-        ]:
-            prj.pop(k, None)
-
         pyp_dct['project'] = prj
-
-        #
-
-        st = dict(specs.setuptools)
         pyp_dct['tool.setuptools'] = st
 
-        for k in [
-            'cexts',
-
-            'find_packages',
-            'package_data',
-            'manifest_in',
-        ]:
-            st.pop(k, None)
-
         pyp_dct['tool.setuptools.packages.find'] = {
             'include': [],
         }
@@ -10655,12 +11772,17 @@ class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
         ext_lines = []
 
         for ext_src in self.find_cext_srcs():
+            ext_lang = ext_src.rpartition('.')[2]
+            compile_args = {
+                'c': ['-std=c11'],
+                'cc': ['-std=c++20'],
+            }.get(ext_lang, [])
             ext_name = ext_src.rpartition('.')[0].replace(os.sep, '.')
             ext_lines.extend([
                 'st.Extension(',
                 f"    name='{ext_name}',",
                 f"    sources=['{ext_src}'],",
-                "    extra_compile_args=['-std=c++20'],",
+                f'    extra_compile_args={compile_args!r},',
                 '),',
             ])
 
@@ -10671,7 +11793,7 @@ class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
             'st.setup(',
             '    ext_modules=[',
             *['        ' + l for l in ext_lines],
-            '    ]',
+            '    ],',
             ')',
             '',
         ])
@@ -10683,14 +11805,110 @@ class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
             src,
         )
 
-    def _write_file_contents(self) -> None:
-        fc = self.file_contents()
 
-        with open(os.path.join(self._pkg_dir(), 'pyproject.toml'), 'w') as f:
-            TomlWriter(f).write_root(fc.pyproject_dct)
+class _PyprojectRsPackageGenerator(_PyprojectExtensionPackageGenerator):
+    @cached_nullary
+    def find_rs_dirs(self) -> ta.Sequence[str]:
+        return sorted(
+            dp
+            for dp, dns, fns in os.walk(self._dir_name)
+            for fn in fns
+            if fn == '.omlish-rs-ext'
+        )
 
-        with open(os.path.join(self._pkg_dir(), 'setup.py'), 'w') as f:
-            f.write(fc.setup_py)
+    #
+
+    @staticmethod
+    def _sdist_patch_body() -> None:
+        def _patch_sdist():
+            def _sdist_add_defaults(old, self):
+                import os.path
+
+                old(self)
+
+                if self.distribution.rust_extensions and len(self.distribution.rust_extensions) > 0:
+                    build_rust = self.get_finalized_command('build_rust')  # noqa
+                    for ext in build_rust.extensions:
+                        ext_dir = os.path.dirname(ext.path)
+                        for n in os.listdir(ext_dir):
+                            if n.startswith('.') or n == 'target':
+                                continue
+                            p = os.path.join(ext_dir, n)
+                            if os.path.isfile(p):
+                                self.filelist.append(p)
+                            elif os.path.isdir(p):
+                                self.filelist.extend(os.path.join(dp, f) for dp, dn, fn in os.walk(p) for f in fn)
+
+            # Sadly, we can't just subclass sdist and override it via cmdclass because manifest_maker calls
+            # `sdist.add_defaults` as an unbound function, not a bound method:
+            # https://github.com/pypa/setuptools/blob/9c4d383631d3951fcae0afd73b5d08ff5a262976/setuptools/command/egg_info.py#L581
+            from setuptools.command.sdist import sdist  # noqa
+            sdist.add_defaults = (lambda old: lambda sdist: _sdist_add_defaults(old, sdist))(sdist.add_defaults)  # noqa
+
+        _patch_sdist()
+
+    @cached_nullary
+    def sdist_patch_code(self) -> str:
+        return textwrap.dedent(''.join(inspect.getsource(self._sdist_patch_body).splitlines(keepends=True)[2:])).strip()
+
+    #
+
+    @cached_nullary
+    def file_contents(self) -> _PyprojectExtensionPackageGenerator.FileContents:
+        prj = self._build_project_dict()
+        st = self._build_setuptools_dict()
+
+        #
+
+        pyp_dct = {}
+
+        pyp_dct['build-system'] = {
+            'requires': ['setuptools', 'setuptools-rust'],
+            'build-backend': 'setuptools.build_meta',
+        }
+
+        pyp_dct['project'] = prj
+        pyp_dct['tool.setuptools'] = st
+
+        pyp_dct['tool.setuptools.packages.find'] = {
+            'include': [],
+        }
+
+        #
+
+        ext_lines: list = []
+
+        for ext_dir in self.find_rs_dirs():  # noqa
+            ext_name = ext_dir.replace(os.sep, '.')
+            ext_lines.extend([
+                'st_rs.RustExtension(',
+                f"    '{ext_name}',",
+                f"    path='{ext_dir}/Cargo.toml',",
+                '),',
+            ])
+
+        src = '\n'.join([
+            'import setuptools as st',
+            'import setuptools_rust as st_rs',
+            '',
+            '',
+            self.sdist_patch_code(),
+            '',
+            '',
+            'st.setup(',
+            '    rust_extensions=[',
+            *['        ' + l for l in ext_lines],
+            '    ],',
+            ')',
+            '',
+        ])
+
+        #
+
+        return self.FileContents(
+            pyp_dct,
+            src,
+        )
 
 
 ##
@@ -10735,7 +11953,8 @@ class _PyprojectCliPackageGenerator(BasePyprojectPackageGenerator):
         pyp_dct['tool.setuptools'] = st
 
         for k in [
-            'cexts',
+            'cext',
+            'rs',
 
             'find_packages',
             'package_data',
@@ -11020,6 +12239,7 @@ def get_default_interp_resolver() -> InterpResolver:
 class InterpVenvConfig:
     interp: ta.Optional[str] = None
     requires: ta.Optional[ta.Sequence[str]] = None
+    requires_pats: ta.Optional[ta.Sequence[str]] = None
     use_uv: ta.Optional[bool] = None
 
 
@@ -11244,7 +12464,13 @@ class Venv:
 
     @cached_nullary
     def _iv(self) -> InterpVenv:
-        rr = RequirementsRewriter(self._name)
+        rr = RequirementsRewriter(
+            venv=self._name,
+            only_pats=(
+                [re.compile(p) for p in self._cfg.requires_pats]
+                if self._cfg.requires_pats is not None else None
+            ),
+        )
 
         return InterpVenv(
             self.dir_name,