omdev 0.0.0.dev147__py3-none-any.whl → 0.0.0.dev149__py3-none-any.whl

omdev/scripts/pyproject.py

@@ -25,6 +25,9 @@ See:
 """
 import abc
 import argparse
+import asyncio
+import asyncio.base_subprocess
+import asyncio.subprocess
 import base64
 import collections
 import collections.abc
@@ -89,6 +92,9 @@ TomlParseFloat = ta.Callable[[str], ta.Any]
 TomlKey = ta.Tuple[str, ...]
 TomlPos = int  # ta.TypeAlias
 
+# ../../omlish/lite/asyncio/asyncio.py
+AwaitableT = ta.TypeVar('AwaitableT', bound=ta.Awaitable)
+
 # ../../omlish/lite/cached.py
 T = ta.TypeVar('T')
 CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
@@ -1764,11 +1770,74 @@ class WheelFile(zipfile.ZipFile):
         super().close()
 
 
+########################################
+# ../../../omlish/lite/asyncio/asyncio.py
+
+
+##
+
+
+ASYNCIO_DEFAULT_BUFFER_LIMIT = 2 ** 16
+
+
+async def asyncio_open_stream_reader(
+        f: ta.IO,
+        loop: ta.Any = None,
+        *,
+        limit: int = ASYNCIO_DEFAULT_BUFFER_LIMIT,
+) -> asyncio.StreamReader:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    reader = asyncio.StreamReader(limit=limit, loop=loop)
+    await loop.connect_read_pipe(
+        lambda: asyncio.StreamReaderProtocol(reader, loop=loop),
+        f,
+    )
+
+    return reader
+
+
+async def asyncio_open_stream_writer(
+        f: ta.IO,
+        loop: ta.Any = None,
+) -> asyncio.StreamWriter:
+    if loop is None:
+        loop = asyncio.get_running_loop()
+
+    writer_transport, writer_protocol = await loop.connect_write_pipe(
+        lambda: asyncio.streams.FlowControlMixin(loop=loop),
+        f,
+    )
+
+    return asyncio.streams.StreamWriter(
+        writer_transport,
+        writer_protocol,
+        None,
+        loop,
+    )
+
+
+##
+
+
+def asyncio_maybe_timeout(
+        fut: AwaitableT,
+        timeout: ta.Optional[float] = None,
+) -> AwaitableT:
+    if timeout is not None:
+        fut = asyncio.wait_for(fut, timeout)  # type: ignore
+    return fut
+
+
 ########################################
 # ../../../omlish/lite/cached.py
 
 
-class _cached_nullary:  # noqa
+##
+
+
+class _AbstractCachedNullary:
     def __init__(self, fn):
         super().__init__()
         self._fn = fn
@@ -1776,17 +1845,25 @@ class _cached_nullary:  # noqa
         functools.update_wrapper(self, fn)
 
     def __call__(self, *args, **kwargs):  # noqa
-        if self._value is self._missing:
-            self._value = self._fn()
-        return self._value
+        raise TypeError
 
     def __get__(self, instance, owner):  # noqa
         bound = instance.__dict__[self._fn.__name__] = self.__class__(self._fn.__get__(instance, owner))
         return bound
 
 
+##
+
+
+class _CachedNullary(_AbstractCachedNullary):
+    def __call__(self, *args, **kwargs):  # noqa
+        if self._value is self._missing:
+            self._value = self._fn()
+        return self._value
+
+
 def cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
-    return _cached_nullary(fn)
+    return _CachedNullary(fn)
 
 
 def static_init(fn: CallableT) -> CallableT:
@@ -1795,6 +1872,20 @@ def static_init(fn: CallableT) -> CallableT:
     return fn
 
 
+##
+
+
+class _AsyncCachedNullary(_AbstractCachedNullary):
+    async def __call__(self, *args, **kwargs):
+        if self._value is self._missing:
+            self._value = await self._fn()
+        return self._value
+
+
+def async_cached_nullary(fn):  # ta.Callable[..., T]) -> ta.Callable[..., T]:
+    return _AsyncCachedNullary(fn)
+
+
 ########################################
 # ../../../omlish/lite/check.py
 
@@ -1834,6 +1925,11 @@ def check_non_empty_str(v: ta.Optional[str]) -> str:
     return v
 
 
+def check_arg(v: bool, msg: str = 'Illegal argument') -> None:
+    if not v:
+        raise ValueError(msg)
+
+
 def check_state(v: bool, msg: str = 'Illegal state') -> None:
     if not v:
         raise ValueError(msg)
@@ -1886,7 +1982,7 @@ def check_empty(v: SizedT) -> SizedT:
     return v
 
 
-def check_non_empty(v: SizedT) -> SizedT:
+def check_not_empty(v: SizedT) -> SizedT:
     if not len(v):
         raise ValueError(v)
     return v
@@ -3601,6 +3697,8 @@ class 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'
         return cls(
             specifier=Specifier(s),
             opts=o,
@@ -3825,7 +3923,7 @@ def subprocess_maybe_shell_wrap_exec(*args: str) -> ta.Tuple[str, ...]:
         return args
 
 
-def _prepare_subprocess_invocation(
+def prepare_subprocess_invocation(
         *args: str,
         env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
         extra_env: ta.Optional[ta.Mapping[str, ta.Any]] = None,
@@ -3833,9 +3931,9 @@ def _prepare_subprocess_invocation(
         shell: bool = False,
         **kwargs: ta.Any,
 ) -> ta.Tuple[ta.Tuple[ta.Any, ...], ta.Dict[str, ta.Any]]:
-    log.debug(args)
+    log.debug('prepare_subprocess_invocation: args=%r', args)
     if extra_env:
-        log.debug(extra_env)
+        log.debug('prepare_subprocess_invocation: extra_env=%r', extra_env)
 
     if extra_env:
         env = {**(env if env is not None else os.environ), **extra_env}
@@ -3854,14 +3952,46 @@ def _prepare_subprocess_invocation(
     )
 
 
-def subprocess_check_call(*args: str, stdout=sys.stderr, **kwargs: ta.Any) -> None:
-    args, kwargs = _prepare_subprocess_invocation(*args, stdout=stdout, **kwargs)
-    return subprocess.check_call(args, **kwargs)  # type: ignore
+##
+
+
+@contextlib.contextmanager
+def subprocess_common_context(*args: ta.Any, **kwargs: ta.Any) -> ta.Iterator[None]:
+    start_time = time.time()
+    try:
+        log.debug('subprocess_common_context.try: args=%r', args)
+        yield
+
+    except Exception as exc:  # noqa
+        log.debug('subprocess_common_context.except: exc=%r', exc)
+        raise
+
+    finally:
+        end_time = time.time()
+        elapsed_s = end_time - start_time
+        log.debug('subprocess_common_context.finally: elapsed_s=%f args=%r', elapsed_s, args)
+
+
+##
+
+
+def subprocess_check_call(
+        *args: str,
+        stdout: ta.Any = sys.stderr,
+        **kwargs: ta.Any,
+) -> None:
+    args, kwargs = prepare_subprocess_invocation(*args, stdout=stdout, **kwargs)
+    with subprocess_common_context(*args, **kwargs):
+        return subprocess.check_call(args, **kwargs)  # type: ignore
 
 
-def subprocess_check_output(*args: str, **kwargs: ta.Any) -> bytes:
-    args, kwargs = _prepare_subprocess_invocation(*args, **kwargs)
-    return subprocess.check_output(args, **kwargs)
+def subprocess_check_output(
+        *args: str,
+        **kwargs: ta.Any,
+) -> bytes:
+    args, kwargs = prepare_subprocess_invocation(*args, **kwargs)
+    with subprocess_common_context(*args, **kwargs):
+        return subprocess.check_output(args, **kwargs)
 
 
 def subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
@@ -3877,16 +4007,31 @@ DEFAULT_SUBPROCESS_TRY_EXCEPTIONS: ta.Tuple[ta.Type[Exception], ...] = (
 )
 
 
-def subprocess_try_call(
-        *args: str,
+def _subprocess_try_run(
+        fn: ta.Callable[..., T],
+        *args: ta.Any,
         try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
         **kwargs: ta.Any,
-) -> bool:
+) -> ta.Union[T, Exception]:
     try:
-        subprocess_check_call(*args, **kwargs)
+        return fn(*args, **kwargs)
     except try_exceptions as e:  # noqa
         if log.isEnabledFor(logging.DEBUG):
             log.exception('command failed')
+        return e
+
+
+def subprocess_try_call(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> bool:
+    if isinstance(_subprocess_try_run(
+            subprocess_check_call,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
         return False
     else:
         return True
@@ -3897,12 +4042,15 @@ def subprocess_try_output(
         try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
         **kwargs: ta.Any,
 ) -> ta.Optional[bytes]:
-    try:
-        return subprocess_check_output(*args, **kwargs)
-    except try_exceptions as e:  # noqa
-        if log.isEnabledFor(logging.DEBUG):
-            log.exception('command failed')
+    if isinstance(ret := _subprocess_try_run(
+            subprocess_check_output,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
         return None
+    else:
+        return ret
 
 
 def subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:
@@ -4329,6 +4477,285 @@ def get_git_status(
     return parse_git_status(proc.stdout.decode())  # noqa
 
 
+########################################
+# ../../../omlish/lite/asyncio/subprocesses.py
+
+
+##
+
+
+@contextlib.asynccontextmanager
+async def asyncio_subprocess_popen(
+        *cmd: str,
+        shell: bool = False,
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> ta.AsyncGenerator[asyncio.subprocess.Process, None]:
+    fac: ta.Any
+    if shell:
+        fac = functools.partial(
+            asyncio.create_subprocess_shell,
+            check_single(cmd),
+        )
+    else:
+        fac = functools.partial(
+            asyncio.create_subprocess_exec,
+            *cmd,
+        )
+
+    with subprocess_common_context(
+            *cmd,
+            shell=shell,
+            timeout=timeout,
+            **kwargs,
+    ):
+        proc: asyncio.subprocess.Process
+        proc = await fac(**kwargs)
+        try:
+            yield proc
+
+        finally:
+            await asyncio_maybe_timeout(proc.wait(), timeout)
+
+
+##
+
+
+class AsyncioProcessCommunicator:
+    def __init__(
+            self,
+            proc: asyncio.subprocess.Process,
+            loop: ta.Optional[ta.Any] = None,
+    ) -> None:
+        super().__init__()
+
+        if loop is None:
+            loop = asyncio.get_running_loop()
+
+        self._proc = proc
+        self._loop = loop
+
+        self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check_isinstance(
+            proc._transport,  # type: ignore  # noqa
+            asyncio.base_subprocess.BaseSubprocessTransport,
+        )
+
+    @property
+    def _debug(self) -> bool:
+        return self._loop.get_debug()
+
+    async def _feed_stdin(self, input: bytes) -> None:  # noqa
+        stdin = check_not_none(self._proc.stdin)
+        try:
+            if input is not None:
+                stdin.write(input)
+                if self._debug:
+                    log.debug('%r communicate: feed stdin (%s bytes)', self, len(input))
+
+            await stdin.drain()
+
+        except (BrokenPipeError, ConnectionResetError) as exc:
+            # communicate() ignores BrokenPipeError and ConnectionResetError. write() and drain() can raise these
+            # exceptions.
+            if self._debug:
+                log.debug('%r communicate: stdin got %r', self, exc)
+
+        if self._debug:
+            log.debug('%r communicate: close stdin', self)
+
+        stdin.close()
+
+    async def _noop(self) -> None:
+        return None
+
+    async def _read_stream(self, fd: int) -> bytes:
+        transport: ta.Any = check_not_none(self._transport.get_pipe_transport(fd))
+
+        if fd == 2:
+            stream = check_not_none(self._proc.stderr)
+        else:
+            check_equal(fd, 1)
+            stream = check_not_none(self._proc.stdout)
+
+        if self._debug:
+            name = 'stdout' if fd == 1 else 'stderr'
+            log.debug('%r communicate: read %s', self, name)
+
+        output = await stream.read()
+
+        if self._debug:
+            name = 'stdout' if fd == 1 else 'stderr'
+            log.debug('%r communicate: close %s', self, name)
+
+        transport.close()
+
+        return output
+
+    class Communication(ta.NamedTuple):
+        stdout: ta.Optional[bytes]
+        stderr: ta.Optional[bytes]
+
+    async def _communicate(
+            self,
+            input: ta.Any = None,  # noqa
+    ) -> Communication:
+        stdin_fut: ta.Any
+        if self._proc.stdin is not None:
+            stdin_fut = self._feed_stdin(input)
+        else:
+            stdin_fut = self._noop()
+
+        stdout_fut: ta.Any
+        if self._proc.stdout is not None:
+            stdout_fut = self._read_stream(1)
+        else:
+            stdout_fut = self._noop()
+
+        stderr_fut: ta.Any
+        if self._proc.stderr is not None:
+            stderr_fut = self._read_stream(2)
+        else:
+            stderr_fut = self._noop()
+
+        stdin_res, stdout_res, stderr_res = await asyncio.gather(stdin_fut, stdout_fut, stderr_fut)
+
+        await self._proc.wait()
+
+        return AsyncioProcessCommunicator.Communication(stdout_res, stderr_res)
+
+    async def communicate(
+            self,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+    ) -> Communication:
+        return await asyncio_maybe_timeout(self._communicate(input), timeout)
+
+
+async def asyncio_subprocess_communicate(
+        proc: asyncio.subprocess.Process,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
+    return await AsyncioProcessCommunicator(proc).communicate(input, timeout)  # noqa
+
+
+##
+
+
+async def _asyncio_subprocess_check_run(
+        *args: str,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> ta.Tuple[ta.Optional[bytes], ta.Optional[bytes]]:
+    args, kwargs = prepare_subprocess_invocation(*args, **kwargs)
+
+    proc: asyncio.subprocess.Process
+    async with asyncio_subprocess_popen(*args, **kwargs) as proc:
+        stdout, stderr = await asyncio_subprocess_communicate(proc, input, timeout)
+
+    if proc.returncode:
+        raise subprocess.CalledProcessError(
+            proc.returncode,
+            args,
+            output=stdout,
+            stderr=stderr,
+        )
+
+    return stdout, stderr
+
+
+async def asyncio_subprocess_check_call(
+        *args: str,
+        stdout: ta.Any = sys.stderr,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> None:
+    _, _ = await _asyncio_subprocess_check_run(
+        *args,
+        stdout=stdout,
+        input=input,
+        timeout=timeout,
+        **kwargs,
+    )
+
+
+async def asyncio_subprocess_check_output(
+        *args: str,
+        input: ta.Any = None,  # noqa
+        timeout: ta.Optional[float] = None,
+        **kwargs: ta.Any,
+) -> bytes:
+    stdout, stderr = await _asyncio_subprocess_check_run(
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        input=input,
+        timeout=timeout,
+        **kwargs,
+    )
+
+    return check_not_none(stdout)
+
+
+async def asyncio_subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str:
+    return (await asyncio_subprocess_check_output(*args, **kwargs)).decode().strip()
+
+
+##
+
+
+async def _asyncio_subprocess_try_run(
+        fn: ta.Callable[..., ta.Awaitable[T]],
+        *args: ta.Any,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> ta.Union[T, Exception]:
+    try:
+        return await fn(*args, **kwargs)
+    except try_exceptions as e:  # noqa
+        if log.isEnabledFor(logging.DEBUG):
+            log.exception('command failed')
+        return e
+
+
+async def asyncio_subprocess_try_call(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> bool:
+    if isinstance(await _asyncio_subprocess_try_run(
+            asyncio_subprocess_check_call,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
+        return False
+    else:
+        return True
+
+
+async def asyncio_subprocess_try_output(
+        *args: str,
+        try_exceptions: ta.Tuple[ta.Type[Exception], ...] = DEFAULT_SUBPROCESS_TRY_EXCEPTIONS,
+        **kwargs: ta.Any,
+) -> ta.Optional[bytes]:
+    if isinstance(ret := await _asyncio_subprocess_try_run(
+            asyncio_subprocess_check_output,
+            *args,
+            try_exceptions=try_exceptions,
+            **kwargs,
+    ), Exception):
+        return None
+    else:
+        return ret
+
+
+async def asyncio_subprocess_try_output_str(*args: str, **kwargs: ta.Any) -> ta.Optional[str]:
+    out = await asyncio_subprocess_try_output(*args, **kwargs)
+    return out.decode().strip() if out is not None else None
+
+
 ########################################
 # ../../interp/inspect.py
 
@@ -4363,7 +4790,6 @@ class InterpInspection:
 
 
 class InterpInspector:
-
     def __init__(self) -> None:
         super().__init__()
 
@@ -4403,17 +4829,17 @@ class InterpInspector:
     def running(cls) -> 'InterpInspection':
         return cls._build_inspection(sys.executable, eval(cls._INSPECTION_CODE))  # noqa
 
-    def _inspect(self, exe: str) -> InterpInspection:
-        output = subprocess_check_output(exe, '-c', f'print({self._INSPECTION_CODE})', quiet=True)
+    async def _inspect(self, exe: str) -> InterpInspection:
+        output = await asyncio_subprocess_check_output(exe, '-c', f'print({self._INSPECTION_CODE})', quiet=True)
         return self._build_inspection(exe, output.decode())
 
-    def inspect(self, exe: str) -> ta.Optional[InterpInspection]:
+    async def inspect(self, exe: str) -> ta.Optional[InterpInspection]:
         try:
             return self._cache[exe]
         except KeyError:
             ret: ta.Optional[InterpInspection]
             try:
-                ret = self._inspect(exe)
+                ret = await self._inspect(exe)
             except Exception as e:  # noqa
                 if log.isEnabledFor(logging.DEBUG):
                     log.exception('Failed to inspect interp: %s', exe)
@@ -4426,95 +4852,34 @@ INTERP_INSPECTOR = InterpInspector()
 
 
 ########################################
-# ../../interp/providers.py
+# ../../revisions.py
 """
 TODO:
- - backends
-  - local builds
-  - deadsnakes?
-  - uv
- - loose versions
+ - omlish-lite, move to pyproject/
+  - vendor-lite wheel.wheelfile
 """
 
 
 ##
 
 
-class InterpProvider(abc.ABC):
-    name: ta.ClassVar[str]
-
-    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
-        super().__init_subclass__(**kwargs)
-        if abc.ABC not in cls.__bases__ and 'name' not in cls.__dict__:
-            sfx = 'InterpProvider'
-            if not cls.__name__.endswith(sfx):
-                raise NameError(cls)
-            setattr(cls, 'name', snake_case(cls.__name__[:-len(sfx)]))
-
-    @abc.abstractmethod
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def get_installed_version(self, version: InterpVersion) -> Interp:
-        raise NotImplementedError
+class GitRevisionAdder:
+    def __init__(
+            self,
+            revision: ta.Optional[str] = None,
+            output_suffix: ta.Optional[str] = None,
+    ) -> None:
+        super().__init__()
+        self._given_revision = revision
+        self._output_suffix = output_suffix
 
-    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return []
+    @cached_nullary
+    def revision(self) -> str:
+        if self._given_revision is not None:
+            return self._given_revision
+        return check_non_empty_str(get_git_revision())
 
-    def install_version(self, version: InterpVersion) -> Interp:
-        raise TypeError
-
-
-##
-
-
-class RunningInterpProvider(InterpProvider):
-    @cached_nullary
-    def version(self) -> InterpVersion:
-        return InterpInspector.running().iv
-
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [self.version()]
-
-    def get_installed_version(self, version: InterpVersion) -> Interp:
-        if version != self.version():
-            raise KeyError(version)
-        return Interp(
-            exe=sys.executable,
-            version=self.version(),
-        )
-
-
-########################################
-# ../../revisions.py
-"""
-TODO:
- - omlish-lite, move to pyproject/
-  - vendor-lite wheel.wheelfile
-"""
-
-
-##
-
-
-class GitRevisionAdder:
-    def __init__(
-            self,
-            revision: ta.Optional[str] = None,
-            output_suffix: ta.Optional[str] = None,
-    ) -> None:
-        super().__init__()
-        self._given_revision = revision
-        self._output_suffix = output_suffix
-
-    @cached_nullary
-    def revision(self) -> str:
-        if self._given_revision is not None:
-            return self._given_revision
-        return check_non_empty_str(get_git_revision())
-
-    REVISION_ATTR = '__revision__'
+    REVISION_ATTR = '__revision__'
 
     def add_to_contents(self, dct: ta.Dict[str, bytes]) -> bool:
         changed = False
@@ -4607,1120 +4972,1179 @@ class GitRevisionAdder:
 
 
 ########################################
-# ../../interp/pyenv.py
+# ../../interp/providers.py
 """
 TODO:
- - custom tags
-  - 'aliases'
-  - https://github.com/pyenv/pyenv/pull/2966
-  - https://github.com/pyenv/pyenv/issues/218 (lol)
-  - probably need custom (temp?) definition file
-  - *or* python-build directly just into the versions dir?
- - optionally install / upgrade pyenv itself
- - new vers dont need these custom mac opts, only run on old vers
+ - backends
+  - local builds
+  - deadsnakes?
+  - uv
+ - loose versions
 """
 
 
 ##
 
 
-class Pyenv:
+class InterpProvider(abc.ABC):
+    name: ta.ClassVar[str]
 
-    def __init__(
-            self,
-            *,
-            root: ta.Optional[str] = None,
-    ) -> None:
-        if root is not None and not (isinstance(root, str) and root):
-            raise ValueError(f'pyenv_root: {root!r}')
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+        if abc.ABC not in cls.__bases__ and 'name' not in cls.__dict__:
+            sfx = 'InterpProvider'
+            if not cls.__name__.endswith(sfx):
+                raise NameError(cls)
+            setattr(cls, 'name', snake_case(cls.__name__[:-len(sfx)]))
 
-        super().__init__()
+    @abc.abstractmethod
+    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Awaitable[ta.Sequence[InterpVersion]]:
+        raise NotImplementedError
 
-        self._root_kw = root
+    @abc.abstractmethod
+    def get_installed_version(self, version: InterpVersion) -> ta.Awaitable[Interp]:
+        raise NotImplementedError
 
-    @cached_nullary
-    def root(self) -> ta.Optional[str]:
-        if self._root_kw is not None:
-            return self._root_kw
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return []
 
-        if shutil.which('pyenv'):
-            return subprocess_check_output_str('pyenv', 'root')
+    async def install_version(self, version: InterpVersion) -> Interp:
+        raise TypeError
 
-        d = os.path.expanduser('~/.pyenv')
-        if os.path.isdir(d) and os.path.isfile(os.path.join(d, 'bin', 'pyenv')):
-            return d
 
-        return None
+##
 
+
+class RunningInterpProvider(InterpProvider):
     @cached_nullary
-    def exe(self) -> str:
-        return os.path.join(check_not_none(self.root()), 'bin', 'pyenv')
+    def version(self) -> InterpVersion:
+        return InterpInspector.running().iv
 
-    def version_exes(self) -> ta.List[ta.Tuple[str, str]]:
-        if (root := self.root()) is None:
-            return []
-        ret = []
-        vp = os.path.join(root, 'versions')
-        if os.path.isdir(vp):
-            for dn in os.listdir(vp):
-                ep = os.path.join(vp, dn, 'bin', 'python')
-                if not os.path.isfile(ep):
-                    continue
-                ret.append((dn, ep))
-        return ret
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [self.version()]
 
-    def installable_versions(self) -> ta.List[str]:
-        if self.root() is None:
-            return []
-        ret = []
-        s = subprocess_check_output_str(self.exe(), 'install', '--list')
-        for l in s.splitlines():
-            if not l.startswith('  '):
-                continue
-            l = l.strip()
-            if not l:
-                continue
-            ret.append(l)
-        return ret
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        if version != self.version():
+            raise KeyError(version)
+        return Interp(
+            exe=sys.executable,
+            version=self.version(),
+        )
 
-    def update(self) -> bool:
-        if (root := self.root()) is None:
-            return False
-        if not os.path.isdir(os.path.join(root, '.git')):
-            return False
-        subprocess_check_call('git', 'pull', cwd=root)
-        return True
 
+########################################
+# ../pkg.py
+"""
+TODO:
+ - ext scanning
+ - __revision__
+ - entry_points
 
-##
+** NOTE **
+setuptools now (2024/09/02) has experimental support for extensions in pure pyproject.toml - but we still want a
+separate '-cext' package
+  https://setuptools.pypa.io/en/latest/userguide/ext_modules.html
+  https://github.com/pypa/setuptools/commit/1a9d87308dc0d8aabeaae0dce989b35dfb7699f0#diff-61d113525e9cc93565799a4bb8b34a68e2945b8a3f7d90c81380614a4ea39542R7-R8
 
+--
 
-@dc.dataclass(frozen=True)
-class PyenvInstallOpts:
-    opts: ta.Sequence[str] = ()
-    conf_opts: ta.Sequence[str] = ()
-    cflags: ta.Sequence[str] = ()
-    ldflags: ta.Sequence[str] = ()
-    env: ta.Mapping[str, str] = dc.field(default_factory=dict)
+https://setuptools.pypa.io/en/latest/references/keywords.html
+https://packaging.python.org/en/latest/specifications/pyproject-toml
 
-    def merge(self, *others: 'PyenvInstallOpts') -> 'PyenvInstallOpts':
-        return PyenvInstallOpts(
-            opts=list(itertools.chain.from_iterable(o.opts for o in [self, *others])),
-            conf_opts=list(itertools.chain.from_iterable(o.conf_opts for o in [self, *others])),
-            cflags=list(itertools.chain.from_iterable(o.cflags for o in [self, *others])),
-            ldflags=list(itertools.chain.from_iterable(o.ldflags for o in [self, *others])),
-            env=dict(itertools.chain.from_iterable(o.env.items() for o in [self, *others])),
-        )
+How to build a C extension in keeping with PEP 517, i.e. with pyproject.toml instead of setup.py?
+https://stackoverflow.com/a/66479252
 
+https://github.com/pypa/sampleproject/blob/db5806e0a3204034c51b1c00dde7d5eb3fa2532e/setup.py
 
-# TODO: https://github.com/pyenv/pyenv/blob/master/plugins/python-build/README.md#building-for-maximum-performance
-DEFAULT_PYENV_INSTALL_OPTS = PyenvInstallOpts(
-    opts=[
-        '-s',
-        '-v',
-        '-k',
-    ],
-    conf_opts=[
-        # FIXME: breaks on mac for older py's
-        '--enable-loadable-sqlite-extensions',
+https://pip.pypa.io/en/stable/cli/pip_install/#vcs-support
+vcs+protocol://repo_url/#egg=pkg&subdirectory=pkg_dir
+'git+https://github.com/wrmsr/omlish@master#subdirectory=.pip/omlish'
+"""  # noqa
 
-        # '--enable-shared',
 
-        '--enable-optimizations',
-        '--with-lto',
+#
 
-        # '--enable-profiling', # ?
 
-        # '--enable-ipv6', # ?
-    ],
-    cflags=[
-        # '-march=native',
-        # '-mtune=native',
-    ],
-)
+class BasePyprojectPackageGenerator(abc.ABC):
+    def __init__(
+            self,
+            dir_name: str,
+            pkgs_root: str,
+            *,
+            pkg_suffix: str = '',
+    ) -> None:
+        super().__init__()
+        self._dir_name = dir_name
+        self._pkgs_root = pkgs_root
+        self._pkg_suffix = pkg_suffix
 
-DEBUG_PYENV_INSTALL_OPTS = PyenvInstallOpts(opts=['-g'])
+    #
 
-THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
+    @cached_nullary
+    def about(self) -> types.ModuleType:
+        return importlib.import_module(f'{self._dir_name}.__about__')
 
+    #
 
-#
+    @cached_nullary
+    def _pkg_dir(self) -> str:
+        pkg_dir: str = os.path.join(self._pkgs_root, self._dir_name + self._pkg_suffix)
+        if os.path.isdir(pkg_dir):
+            shutil.rmtree(pkg_dir)
+        os.makedirs(pkg_dir)
+        return pkg_dir
 
+    #
 
-class PyenvInstallOptsProvider(abc.ABC):
-    @abc.abstractmethod
-    def opts(self) -> PyenvInstallOpts:
-        raise NotImplementedError
+    _GIT_IGNORE: ta.Sequence[str] = [
+        '/*.egg-info/',
+        '/dist',
+    ]
 
+    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))
 
-class LinuxPyenvInstallOpts(PyenvInstallOptsProvider):
-    def opts(self) -> PyenvInstallOpts:
-        return PyenvInstallOpts()
+    #
 
+    def _symlink_source_dir(self) -> None:
+        os.symlink(
+            os.path.relpath(self._dir_name, self._pkg_dir()),
+            os.path.join(self._pkg_dir(), self._dir_name),
+        )
 
-class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
+    #
 
     @cached_nullary
-    def framework_opts(self) -> PyenvInstallOpts:
-        return PyenvInstallOpts(conf_opts=['--enable-framework'])
+    def project_cls(self) -> type:
+        return self.about().Project
 
     @cached_nullary
-    def has_brew(self) -> bool:
-        return shutil.which('brew') is not None
+    def setuptools_cls(self) -> type:
+        return self.about().Setuptools
 
-    BREW_DEPS: ta.Sequence[str] = [
-        'openssl',
-        'readline',
-        'sqlite3',
-        'zlib',
-    ]
+    @staticmethod
+    def _build_cls_dct(cls: type) -> ta.Dict[str, ta.Any]:  # noqa
+        dct = {}
+        for b in reversed(cls.__mro__):
+            for k, v in b.__dict__.items():
+                if k.startswith('_'):
+                    continue
+                dct[k] = v
+        return dct
 
-    @cached_nullary
-    def brew_deps_opts(self) -> PyenvInstallOpts:
-        cflags = []
-        ldflags = []
-        for dep in self.BREW_DEPS:
-            dep_prefix = subprocess_check_output_str('brew', '--prefix', dep)
-            cflags.append(f'-I{dep_prefix}/include')
-            ldflags.append(f'-L{dep_prefix}/lib')
-        return PyenvInstallOpts(
-            cflags=cflags,
-            ldflags=ldflags,
+    @staticmethod
+    def _move_dict_key(
+            sd: ta.Dict[str, ta.Any],
+            sk: str,
+            dd: ta.Dict[str, ta.Any],
+            dk: str,
+    ) -> None:
+        if sk in sd:
+            dd[dk] = sd.pop(sk)
+
+    @dc.dataclass(frozen=True)
+    class Specs:
+        pyproject: ta.Dict[str, ta.Any]
+        setuptools: ta.Dict[str, ta.Any]
+
+    def build_specs(self) -> Specs:
+        return self.Specs(
+            self._build_cls_dct(self.project_cls()),
+            self._build_cls_dct(self.setuptools_cls()),
         )
 
+    #
+
+    class _PkgData(ta.NamedTuple):
+        inc: ta.List[str]
+        exc: ta.List[str]
+
     @cached_nullary
-    def brew_tcl_opts(self) -> PyenvInstallOpts:
-        if subprocess_try_output('brew', '--prefix', 'tcl-tk') is None:
-            return PyenvInstallOpts()
+    def _collect_pkg_data(self) -> _PkgData:
+        inc: ta.List[str] = []
+        exc: ta.List[str] = []
 
-        tcl_tk_prefix = subprocess_check_output_str('brew', '--prefix', 'tcl-tk')
-        tcl_tk_ver_str = subprocess_check_output_str('brew', 'ls', '--versions', 'tcl-tk')
-        tcl_tk_ver = '.'.join(tcl_tk_ver_str.split()[1].split('.')[:2])
+        for p, ds, fs in os.walk(self._dir_name):  # noqa
+            for f in fs:
+                if f != '.pkgdata':
+                    continue
+                rp = os.path.relpath(p, self._dir_name)
+                log.info('Found pkgdata %s for pkg %s', rp, self._dir_name)
+                with open(os.path.join(p, f)) as fo:
+                    src = fo.read()
+                for l in src.splitlines():
+                    if not (l := l.strip()):
+                        continue
+                    if l.startswith('!'):
+                        exc.append(os.path.join(rp, l[1:]))
+                    else:
+                        inc.append(os.path.join(rp, l))
 
-        return PyenvInstallOpts(conf_opts=[
-            f"--with-tcltk-includes='-I{tcl_tk_prefix}/include'",
-            f"--with-tcltk-libs='-L{tcl_tk_prefix}/lib -ltcl{tcl_tk_ver} -ltk{tcl_tk_ver}'",
-        ])
+        return self._PkgData(inc, exc)
 
-    # @cached_nullary
-    # def brew_ssl_opts(self) -> PyenvInstallOpts:
-    #     pkg_config_path = subprocess_check_output_str('brew', '--prefix', 'openssl')
-    #     if 'PKG_CONFIG_PATH' in os.environ:
-    #         pkg_config_path += ':' + os.environ['PKG_CONFIG_PATH']
-    #     return PyenvInstallOpts(env={'PKG_CONFIG_PATH': pkg_config_path})
+    #
 
-    def opts(self) -> PyenvInstallOpts:
-        return PyenvInstallOpts().merge(
-            self.framework_opts(),
-            self.brew_deps_opts(),
-            self.brew_tcl_opts(),
-            # self.brew_ssl_opts(),
-        )
+    @abc.abstractmethod
+    def _write_file_contents(self) -> None:
+        raise NotImplementedError
 
+    #
 
-PLATFORM_PYENV_INSTALL_OPTS: ta.Dict[str, PyenvInstallOptsProvider] = {
-    'darwin': DarwinPyenvInstallOpts(),
-    'linux': LinuxPyenvInstallOpts(),
-}
+    _STANDARD_FILES: ta.Sequence[str] = [
+        'LICENSE',
+        'README.rst',
+    ]
 
+    def _symlink_standard_files(self) -> None:
+        for fn in self._STANDARD_FILES:
+            if os.path.exists(fn):
+                os.symlink(os.path.relpath(fn, self._pkg_dir()), os.path.join(self._pkg_dir(), fn))
 
-##
+    #
 
+    def children(self) -> ta.Sequence['BasePyprojectPackageGenerator']:
+        return []
 
-class PyenvVersionInstaller:
-    """
-    Messy: can install freethreaded build with a 't' suffixed version str _or_ by THREADED_PYENV_INSTALL_OPTS - need
-    latter to build custom interp with ft, need former to use canned / blessed interps. Muh.
-    """
+    #
 
-    def __init__(
+    def gen(self) -> str:
+        log.info('Generating pyproject package: %s -> %s (%s)', self._dir_name, self._pkgs_root, self._pkg_suffix)
+
+        self._pkg_dir()
+        self._write_git_ignore()
+        self._symlink_source_dir()
+        self._write_file_contents()
+        self._symlink_standard_files()
+
+        return self._pkg_dir()
+
+    #
+
+    @dc.dataclass(frozen=True)
+    class BuildOpts:
+        add_revision: bool = False
+        test: bool = False
+
+    def build(
             self,
-            version: str,
-            opts: ta.Optional[PyenvInstallOpts] = None,
-            interp_opts: InterpOpts = InterpOpts(),
-            *,
-            install_name: ta.Optional[str] = None,
-            no_default_opts: bool = False,
-            pyenv: Pyenv = Pyenv(),
+            output_dir: ta.Optional[str] = None,
+            opts: BuildOpts = BuildOpts(),
     ) -> None:
-        super().__init__()
+        subprocess_check_call(
+            sys.executable,
+            '-m',
+            'build',
+            cwd=self._pkg_dir(),
+        )
 
-        if no_default_opts:
-            if opts is None:
-                opts = PyenvInstallOpts()
-        else:
-            lst = [opts if opts is not None else DEFAULT_PYENV_INSTALL_OPTS]
-            if interp_opts.debug:
-                lst.append(DEBUG_PYENV_INSTALL_OPTS)
-            if interp_opts.threaded:
-                lst.append(THREADED_PYENV_INSTALL_OPTS)
-            lst.append(PLATFORM_PYENV_INSTALL_OPTS[sys.platform].opts())
-            opts = PyenvInstallOpts().merge(*lst)
+        dist_dir = os.path.join(self._pkg_dir(), 'dist')
 
-        self._version = version
-        self._opts = opts
-        self._interp_opts = interp_opts
-        self._given_install_name = install_name
+        if opts.add_revision:
+            GitRevisionAdder().add_to(dist_dir)
 
-        self._no_default_opts = no_default_opts
-        self._pyenv = pyenv
+        if opts.test:
+            for fn in os.listdir(dist_dir):
+                tmp_dir = tempfile.mkdtemp()
 
-    @property
-    def version(self) -> str:
-        return self._version
+                subprocess_check_call(
+                    sys.executable,
+                    '-m', 'venv',
+                    'test-install',
+                    cwd=tmp_dir,
+                )
 
-    @property
-    def opts(self) -> PyenvInstallOpts:
-        return self._opts
+                subprocess_check_call(
+                    os.path.join(tmp_dir, 'test-install', 'bin', 'python3'),
+                    '-m', 'pip',
+                    'install',
+                    os.path.abspath(os.path.join(dist_dir, fn)),
+                    cwd=tmp_dir,
+                )
 
-    @cached_nullary
-    def install_name(self) -> str:
-        if self._given_install_name is not None:
-            return self._given_install_name
-        return self._version + ('-debug' if self._interp_opts.debug else '')
+        if output_dir is not None:
+            for fn in os.listdir(dist_dir):
+                shutil.copyfile(os.path.join(dist_dir, fn), os.path.join(output_dir, fn))
 
-    @cached_nullary
-    def install_dir(self) -> str:
-        return str(os.path.join(check_not_none(self._pyenv.root()), 'versions', self.install_name()))
 
-    @cached_nullary
-    def install(self) -> str:
-        env = {**os.environ, **self._opts.env}
-        for k, l in [
-            ('CFLAGS', self._opts.cflags),
-            ('LDFLAGS', self._opts.ldflags),
-            ('PYTHON_CONFIGURE_OPTS', self._opts.conf_opts),
-        ]:
-            v = ' '.join(l)
-            if k in os.environ:
-                v += ' ' + os.environ[k]
-            env[k] = v
+#
 
-        conf_args = [
-            *self._opts.opts,
-            self._version,
-        ]
 
-        if self._given_install_name is not None:
-            full_args = [
-                os.path.join(check_not_none(self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),
-                *conf_args,
-                self.install_dir(),
-            ]
-        else:
-            full_args = [
-                self._pyenv.exe(),
-                'install',
-                *conf_args,
-            ]
+class PyprojectPackageGenerator(BasePyprojectPackageGenerator):
 
-        subprocess_check_call(
-            *full_args,
-            env=env,
-        )
+    #
 
-        exe = os.path.join(self.install_dir(), 'bin', 'python')
-        if not os.path.isfile(exe):
-            raise RuntimeError(f'Interpreter not found: {exe}')
-        return exe
+    @dc.dataclass(frozen=True)
+    class FileContents:
+        pyproject_dct: ta.Mapping[str, ta.Any]
+        manifest_in: ta.Optional[ta.Sequence[str]]
 
+    @cached_nullary
+    def file_contents(self) -> FileContents:
+        specs = self.build_specs()
 
-##
+        #
 
+        pyp_dct = {}
 
-class PyenvInterpProvider(InterpProvider):
+        pyp_dct['build-system'] = {
+            'requires': ['setuptools'],
+            'build-backend': 'setuptools.build_meta',
+        }
 
-    def __init__(
-            self,
-            pyenv: Pyenv = Pyenv(),
+        prj = specs.pyproject
+        prj['name'] += self._pkg_suffix
 
-            inspect: bool = False,
-            inspector: InterpInspector = INTERP_INSPECTOR,
+        pyp_dct['project'] = prj
 
-            *,
+        self._move_dict_key(prj, 'optional_dependencies', pyp_dct, extrask := 'project.optional-dependencies')
+        if (extras := pyp_dct.get(extrask)):
+            pyp_dct[extrask] = {
+                'all': [
+                    e
+                    for lst in extras.values()
+                    for e in lst
+                ],
+                **extras,
+            }
 
-            try_update: bool = False,
-    ) -> None:
-        super().__init__()
+        if (eps := prj.pop('entry_points', None)):
+            pyp_dct['project.entry-points'] = {TomlWriter.Literal(f"'{k}'"): v for k, v in eps.items()}  # type: ignore  # noqa
 
-        self._pyenv = pyenv
+        if (scs := prj.pop('scripts', None)):
+            pyp_dct['project.scripts'] = scs
 
-        self._inspect = inspect
-        self._inspector = inspector
+        prj.pop('cli_scripts', None)
 
-        self._try_update = try_update
+        ##
 
-    #
+        st = dict(specs.setuptools)
+        pyp_dct['tool.setuptools'] = st
 
-    @staticmethod
-    def guess_version(s: str) -> ta.Optional[InterpVersion]:
-        def strip_sfx(s: str, sfx: str) -> ta.Tuple[str, bool]:
-            if s.endswith(sfx):
-                return s[:-len(sfx)], True
-            return s, False
-        ok = {}
-        s, ok['debug'] = strip_sfx(s, '-debug')
-        s, ok['threaded'] = strip_sfx(s, 't')
-        try:
-            v = Version(s)
-        except InvalidVersion:
-            return None
-        return InterpVersion(v, InterpOpts(**ok))
+        st.pop('cexts', None)
 
-    class Installed(ta.NamedTuple):
-        name: str
-        exe: str
-        version: InterpVersion
+        #
 
-    def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
-        iv: ta.Optional[InterpVersion]
-        if self._inspect:
-            try:
-                iv = check_not_none(self._inspector.inspect(ep)).iv
-            except Exception as e:  # noqa
-                return None
-        else:
-            iv = self.guess_version(vn)
-        if iv is None:
-            return None
-        return PyenvInterpProvider.Installed(
-            name=vn,
-            exe=ep,
-            version=iv,
-        )
+        # TODO: default
+        # find_packages = {
+        #     'include': [Project.name, f'{Project.name}.*'],
+        #     'exclude': [*SetuptoolsBase.find_packages['exclude']],
+        # }
 
-    def installed(self) -> ta.Sequence[Installed]:
-        ret: ta.List[PyenvInterpProvider.Installed] = []
-        for vn, ep in self._pyenv.version_exes():
-            if (i := self._make_installed(vn, ep)) is None:
-                log.debug('Invalid pyenv version: %s', vn)
-                continue
-            ret.append(i)
-        return ret
+        fp = dict(st.pop('find_packages', {}))
 
-    #
+        pyp_dct['tool.setuptools.packages.find'] = fp
 
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [i.version for i in self.installed()]
+        #
 
-    def get_installed_version(self, version: InterpVersion) -> Interp:
-        for i in self.installed():
-            if i.version == version:
-                return Interp(
-                    exe=i.exe,
-                    version=i.version,
-                )
-        raise KeyError(version)
+        # TODO: default
+        # package_data = {
+        #     '*': [
+        #         '*.c',
+        #         '*.cc',
+        #         '*.h',
+        #         '.manifests.json',
+        #         'LICENSE',
+        #     ],
+        # }
 
-    #
+        pd = dict(st.pop('package_data', {}))
+        epd = dict(st.pop('exclude_package_data', {}))
 
-    def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = []
+        cpd = self._collect_pkg_data()
+        if cpd.inc:
+            pd['*'] = [*pd.get('*', []), *sorted(set(cpd.inc))]
+        if cpd.exc:
+            epd['*'] = [*epd.get('*', []), *sorted(set(cpd.exc))]
 
-        for vs in self._pyenv.installable_versions():
-            if (iv := self.guess_version(vs)) is None:
-                continue
-            if iv.opts.debug:
-                raise Exception('Pyenv installable versions not expected to have debug suffix')
-            for d in [False, True]:
-                lst.append(dc.replace(iv, opts=dc.replace(iv.opts, debug=d)))
+        if pd:
+            pyp_dct['tool.setuptools.package-data'] = pd
+        if epd:
+            pyp_dct['tool.setuptools.exclude-package-data'] = epd
 
-        return lst
+        #
+
+        # TODO: default
+        # manifest_in = [
+        #     'global-exclude **/conftest.py',
+        # ]
 
-    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = self._get_installable_versions(spec)
+        mani_in = st.pop('manifest_in', None)
 
-        if self._try_update and not any(v in spec for v in lst):
-            if self._pyenv.update():
-                lst = self._get_installable_versions(spec)
+        #
 
-        return lst
+        return self.FileContents(
+            pyp_dct,
+            mani_in,
+        )
 
-    def install_version(self, version: InterpVersion) -> Interp:
-        inst_version = str(version.version)
-        inst_opts = version.opts
-        if inst_opts.threaded:
-            inst_version += 't'
-            inst_opts = dc.replace(inst_opts, threaded=False)
+    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)
 
-        installer = PyenvVersionInstaller(
-            inst_version,
-            interp_opts=inst_opts,
-        )
+        if fc.manifest_in:
+            with open(os.path.join(self._pkg_dir(), 'MANIFEST.in'), 'w') as f:
+                f.write('\n'.join(fc.manifest_in))  # noqa
 
-        exe = installer.install()
-        return Interp(exe, version)
+    #
 
+    @cached_nullary
+    def children(self) -> ta.Sequence[BasePyprojectPackageGenerator]:
+        out: ta.List[BasePyprojectPackageGenerator] = []
 
-########################################
-# ../../interp/system.py
-"""
-TODO:
- - python, python3, python3.12, ...
- - check if path py's are venvs: sys.prefix != sys.base_prefix
-"""
+        if self.build_specs().setuptools.get('cexts'):
+            out.append(_PyprojectCextPackageGenerator(
+                self._dir_name,
+                self._pkgs_root,
+                pkg_suffix='-cext',
+            ))
 
+        if self.build_specs().pyproject.get('cli_scripts'):
+            out.append(_PyprojectCliPackageGenerator(
+                self._dir_name,
+                self._pkgs_root,
+                pkg_suffix='-cli',
+            ))
 
-##
+        return out
 
 
-@dc.dataclass(frozen=True)
-class SystemInterpProvider(InterpProvider):
-    cmd: str = 'python3'
-    path: ta.Optional[str] = None
+#
 
-    inspect: bool = False
-    inspector: InterpInspector = INTERP_INSPECTOR
+
+class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
 
     #
 
-    @staticmethod
-    def _re_which(
-            pat: re.Pattern,
-            *,
-            mode: int = os.F_OK | os.X_OK,
-            path: ta.Optional[str] = None,
-    ) -> ta.List[str]:
-        if path is None:
-            path = os.environ.get('PATH', None)
-            if path is None:
-                try:
-                    path = os.confstr('CS_PATH')
-                except (AttributeError, ValueError):
-                    path = os.defpath
+    @cached_nullary
+    def find_cext_srcs(self) -> ta.Sequence[str]:
+        return sorted(find_magic_files(
+            CextMagic.STYLE,
+            [self._dir_name],
+            keys=[CextMagic.KEY],
+        ))
 
-        if not path:
-            return []
+    #
 
-        path = os.fsdecode(path)
-        pathlst = path.split(os.pathsep)
+    @dc.dataclass(frozen=True)
+    class FileContents:
+        pyproject_dct: ta.Mapping[str, ta.Any]
+        setup_py: str
 
-        def _access_check(fn: str, mode: int) -> bool:
-            return os.path.exists(fn) and os.access(fn, mode)
+    @cached_nullary
+    def file_contents(self) -> FileContents:
+        specs = self.build_specs()
 
-        out = []
-        seen = set()
-        for d in pathlst:
-            normdir = os.path.normcase(d)
-            if normdir not in seen:
-                seen.add(normdir)
-                if not _access_check(normdir, mode):
-                    continue
-                for thefile in os.listdir(d):
-                    name = os.path.join(d, thefile)
-                    if not (
-                            os.path.isfile(name) and
-                            pat.fullmatch(thefile) and
-                            _access_check(name, mode)
-                    ):
-                        continue
-                    out.append(name)
+        #
 
-        return out
+        pyp_dct = {}
 
-    @cached_nullary
-    def exes(self) -> ta.List[str]:
-        return self._re_which(
-            re.compile(r'python3(\.\d+)?'),
-            path=self.path,
-        )
+        pyp_dct['build-system'] = {
+            'requires': ['setuptools'],
+            '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)
 
-    def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
-        if not self.inspect:
-            s = os.path.basename(exe)
-            if s.startswith('python'):
-                s = s[len('python'):]
-            if '.' in s:
-                try:
-                    return InterpVersion.parse(s)
-                except InvalidVersion:
-                    pass
-        ii = self.inspector.inspect(exe)
-        return ii.iv if ii is not None else None
+        pyp_dct['project'] = prj
 
-    def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
-        lst = []
-        for e in self.exes():
-            if (ev := self.get_exe_version(e)) is None:
-                log.debug('Invalid system version: %s', e)
-                continue
-            lst.append((e, ev))
-        return lst
+        #
 
-    #
+        st = dict(specs.setuptools)
+        pyp_dct['tool.setuptools'] = st
 
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [ev for e, ev in self.exe_versions()]
+        for k in [
+            'cexts',
 
-    def get_installed_version(self, version: InterpVersion) -> Interp:
-        for e, ev in self.exe_versions():
-            if ev != version:
-                continue
-            return Interp(
-                exe=e,
-                version=ev,
-            )
-        raise KeyError(version)
+            'find_packages',
+            'package_data',
+            'manifest_in',
+        ]:
+            st.pop(k, None)
 
+        pyp_dct['tool.setuptools.packages.find'] = {
+            'include': [],
+        }
 
-########################################
-# ../pkg.py
-"""
-TODO:
- - ext scanning
- - __revision__
- - entry_points
+        #
 
-** NOTE **
-setuptools now (2024/09/02) has experimental support for extensions in pure pyproject.toml - but we still want a
-separate '-cext' package
-  https://setuptools.pypa.io/en/latest/userguide/ext_modules.html
-  https://github.com/pypa/setuptools/commit/1a9d87308dc0d8aabeaae0dce989b35dfb7699f0#diff-61d113525e9cc93565799a4bb8b34a68e2945b8a3f7d90c81380614a4ea39542R7-R8
+        ext_lines = []
 
---
+        for ext_src in self.find_cext_srcs():
+            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'],",
+                '),',
+            ])
 
-https://setuptools.pypa.io/en/latest/references/keywords.html
-https://packaging.python.org/en/latest/specifications/pyproject-toml
+        src = '\n'.join([
+            'import setuptools as st',
+            '',
+            '',
+            'st.setup(',
+            '    ext_modules=[',
+            *['        ' + l for l in ext_lines],
+            '    ]',
+            ')',
+            '',
+        ])
 
-How to build a C extension in keeping with PEP 517, i.e. with pyproject.toml instead of setup.py?
-https://stackoverflow.com/a/66479252
+        #
 
-https://github.com/pypa/sampleproject/blob/db5806e0a3204034c51b1c00dde7d5eb3fa2532e/setup.py
+        return self.FileContents(
+            pyp_dct,
+            src,
+        )
 
-https://pip.pypa.io/en/stable/cli/pip_install/#vcs-support
-vcs+protocol://repo_url/#egg=pkg&subdirectory=pkg_dir
-'git+https://github.com/wrmsr/omlish@master#subdirectory=.pip/omlish'
-"""  # noqa
+    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)
 
-#
+        with open(os.path.join(self._pkg_dir(), 'setup.py'), 'w') as f:
+            f.write(fc.setup_py)
 
 
-class BasePyprojectPackageGenerator(abc.ABC):
-    def __init__(
-            self,
-            dir_name: str,
-            pkgs_root: str,
-            *,
-            pkg_suffix: str = '',
-    ) -> None:
-        super().__init__()
-        self._dir_name = dir_name
-        self._pkgs_root = pkgs_root
-        self._pkg_suffix = pkg_suffix
+##
 
-    #
 
-    @cached_nullary
-    def about(self) -> types.ModuleType:
-        return importlib.import_module(f'{self._dir_name}.__about__')
+class _PyprojectCliPackageGenerator(BasePyprojectPackageGenerator):
 
     #
 
+    @dc.dataclass(frozen=True)
+    class FileContents:
+        pyproject_dct: ta.Mapping[str, ta.Any]
+
     @cached_nullary
-    def _pkg_dir(self) -> str:
-        pkg_dir: str = os.path.join(self._pkgs_root, self._dir_name + self._pkg_suffix)
-        if os.path.isdir(pkg_dir):
-            shutil.rmtree(pkg_dir)
-        os.makedirs(pkg_dir)
-        return pkg_dir
+    def file_contents(self) -> FileContents:
+        specs = self.build_specs()
 
-    #
+        #
 
-    _GIT_IGNORE: ta.Sequence[str] = [
-        '/*.egg-info/',
-        '/dist',
-    ]
+        pyp_dct = {}
 
-    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))
+        pyp_dct['build-system'] = {
+            'requires': ['setuptools'],
+            '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',
+        ]:
+            prj.pop(k, None)
 
-    def _symlink_source_dir(self) -> None:
-        os.symlink(
-            os.path.relpath(self._dir_name, self._pkg_dir()),
-            os.path.join(self._pkg_dir(), self._dir_name),
-        )
+        pyp_dct['project'] = prj
 
-    #
+        if (scs := prj.pop('cli_scripts', None)):
+            pyp_dct['project.scripts'] = scs
 
-    @cached_nullary
-    def project_cls(self) -> type:
-        return self.about().Project
+        #
 
-    @cached_nullary
-    def setuptools_cls(self) -> type:
-        return self.about().Setuptools
+        st = dict(specs.setuptools)
+        pyp_dct['tool.setuptools'] = st
 
-    @staticmethod
-    def _build_cls_dct(cls: type) -> ta.Dict[str, ta.Any]:  # noqa
-        dct = {}
-        for b in reversed(cls.__mro__):
-            for k, v in b.__dict__.items():
-                if k.startswith('_'):
-                    continue
-                dct[k] = v
-        return dct
+        for k in [
+            'cexts',
 
-    @staticmethod
-    def _move_dict_key(
-            sd: ta.Dict[str, ta.Any],
-            sk: str,
-            dd: ta.Dict[str, ta.Any],
-            dk: str,
-    ) -> None:
-        if sk in sd:
-            dd[dk] = sd.pop(sk)
+            'find_packages',
+            'package_data',
+            'manifest_in',
+        ]:
+            st.pop(k, None)
 
-    @dc.dataclass(frozen=True)
-    class Specs:
-        pyproject: ta.Dict[str, ta.Any]
-        setuptools: ta.Dict[str, ta.Any]
+        pyp_dct['tool.setuptools.packages.find'] = {
+            'include': [],
+        }
 
-    def build_specs(self) -> Specs:
-        return self.Specs(
-            self._build_cls_dct(self.project_cls()),
-            self._build_cls_dct(self.setuptools_cls()),
+        #
+
+        return self.FileContents(
+            pyp_dct,
         )
 
-    #
+    def _write_file_contents(self) -> None:
+        fc = self.file_contents()
 
-    class _PkgData(ta.NamedTuple):
-        inc: ta.List[str]
-        exc: ta.List[str]
+        with open(os.path.join(self._pkg_dir(), 'pyproject.toml'), 'w') as f:
+            TomlWriter(f).write_root(fc.pyproject_dct)
 
-    @cached_nullary
-    def _collect_pkg_data(self) -> _PkgData:
-        inc: ta.List[str] = []
-        exc: ta.List[str] = []
 
-        for p, ds, fs in os.walk(self._dir_name):  # noqa
-            for f in fs:
-                if f != '.pkgdata':
-                    continue
-                rp = os.path.relpath(p, self._dir_name)
-                log.info('Found pkgdata %s for pkg %s', rp, self._dir_name)
-                with open(os.path.join(p, f)) as fo:
-                    src = fo.read()
-                for l in src.splitlines():
-                    if not (l := l.strip()):
-                        continue
-                    if l.startswith('!'):
-                        exc.append(os.path.join(rp, l[1:]))
-                    else:
-                        inc.append(os.path.join(rp, l))
+########################################
+# ../../interp/pyenv.py
+"""
+TODO:
+ - custom tags
+  - 'aliases'
+  - https://github.com/pyenv/pyenv/pull/2966
+  - https://github.com/pyenv/pyenv/issues/218 (lol)
+  - probably need custom (temp?) definition file
+  - *or* python-build directly just into the versions dir?
+ - optionally install / upgrade pyenv itself
+ - new vers dont need these custom mac opts, only run on old vers
+"""
 
-        return self._PkgData(inc, exc)
 
-    #
+##
 
-    @abc.abstractmethod
-    def _write_file_contents(self) -> None:
-        raise NotImplementedError
 
-    #
+class Pyenv:
+    def __init__(
+            self,
+            *,
+            root: ta.Optional[str] = None,
+    ) -> None:
+        if root is not None and not (isinstance(root, str) and root):
+            raise ValueError(f'pyenv_root: {root!r}')
 
-    _STANDARD_FILES: ta.Sequence[str] = [
-        'LICENSE',
-        'README.rst',
-    ]
+        super().__init__()
 
-    def _symlink_standard_files(self) -> None:
-        for fn in self._STANDARD_FILES:
-            if os.path.exists(fn):
-                os.symlink(os.path.relpath(fn, self._pkg_dir()), os.path.join(self._pkg_dir(), fn))
+        self._root_kw = root
 
-    #
+    @async_cached_nullary
+    async def root(self) -> ta.Optional[str]:
+        if self._root_kw is not None:
+            return self._root_kw
 
-    def children(self) -> ta.Sequence['BasePyprojectPackageGenerator']:
-        return []
+        if shutil.which('pyenv'):
+            return await asyncio_subprocess_check_output_str('pyenv', 'root')
 
-    #
+        d = os.path.expanduser('~/.pyenv')
+        if os.path.isdir(d) and os.path.isfile(os.path.join(d, 'bin', 'pyenv')):
+            return d
 
-    def gen(self) -> str:
-        log.info('Generating pyproject package: %s -> %s (%s)', self._dir_name, self._pkgs_root, self._pkg_suffix)
+        return None
 
-        self._pkg_dir()
-        self._write_git_ignore()
-        self._symlink_source_dir()
-        self._write_file_contents()
-        self._symlink_standard_files()
+    @async_cached_nullary
+    async def exe(self) -> str:
+        return os.path.join(check_not_none(await self.root()), 'bin', 'pyenv')
 
-        return self._pkg_dir()
+    async def version_exes(self) -> ta.List[ta.Tuple[str, str]]:
+        if (root := await self.root()) is None:
+            return []
+        ret = []
+        vp = os.path.join(root, 'versions')
+        if os.path.isdir(vp):
+            for dn in os.listdir(vp):
+                ep = os.path.join(vp, dn, 'bin', 'python')
+                if not os.path.isfile(ep):
+                    continue
+                ret.append((dn, ep))
+        return ret
 
-    #
+    async def installable_versions(self) -> ta.List[str]:
+        if await self.root() is None:
+            return []
+        ret = []
+        s = await asyncio_subprocess_check_output_str(await self.exe(), 'install', '--list')
+        for l in s.splitlines():
+            if not l.startswith('  '):
+                continue
+            l = l.strip()
+            if not l:
+                continue
+            ret.append(l)
+        return ret
 
-    @dc.dataclass(frozen=True)
-    class BuildOpts:
-        add_revision: bool = False
-        test: bool = False
+    async def update(self) -> bool:
+        if (root := await self.root()) is None:
+            return False
+        if not os.path.isdir(os.path.join(root, '.git')):
+            return False
+        await asyncio_subprocess_check_call('git', 'pull', cwd=root)
+        return True
 
-    def build(
-            self,
-            output_dir: ta.Optional[str] = None,
-            opts: BuildOpts = BuildOpts(),
-    ) -> None:
-        subprocess_check_call(
-            sys.executable,
-            '-m',
-            'build',
-            cwd=self._pkg_dir(),
-        )
 
-        dist_dir = os.path.join(self._pkg_dir(), 'dist')
+##
 
-        if opts.add_revision:
-            GitRevisionAdder().add_to(dist_dir)
 
-        if opts.test:
-            for fn in os.listdir(dist_dir):
-                tmp_dir = tempfile.mkdtemp()
+@dc.dataclass(frozen=True)
+class PyenvInstallOpts:
+    opts: ta.Sequence[str] = ()
+    conf_opts: ta.Sequence[str] = ()
+    cflags: ta.Sequence[str] = ()
+    ldflags: ta.Sequence[str] = ()
+    env: ta.Mapping[str, str] = dc.field(default_factory=dict)
 
-                subprocess_check_call(
-                    sys.executable,
-                    '-m', 'venv',
-                    'test-install',
-                    cwd=tmp_dir,
-                )
+    def merge(self, *others: 'PyenvInstallOpts') -> 'PyenvInstallOpts':
+        return PyenvInstallOpts(
+            opts=list(itertools.chain.from_iterable(o.opts for o in [self, *others])),
+            conf_opts=list(itertools.chain.from_iterable(o.conf_opts for o in [self, *others])),
+            cflags=list(itertools.chain.from_iterable(o.cflags for o in [self, *others])),
+            ldflags=list(itertools.chain.from_iterable(o.ldflags for o in [self, *others])),
+            env=dict(itertools.chain.from_iterable(o.env.items() for o in [self, *others])),
+        )
 
-                subprocess_check_call(
-                    os.path.join(tmp_dir, 'test-install', 'bin', 'python3'),
-                    '-m', 'pip',
-                    'install',
-                    os.path.abspath(os.path.join(dist_dir, fn)),
-                    cwd=tmp_dir,
-                )
 
-        if output_dir is not None:
-            for fn in os.listdir(dist_dir):
-                shutil.copyfile(os.path.join(dist_dir, fn), os.path.join(output_dir, fn))
+# TODO: https://github.com/pyenv/pyenv/blob/master/plugins/python-build/README.md#building-for-maximum-performance
+DEFAULT_PYENV_INSTALL_OPTS = PyenvInstallOpts(
+    opts=[
+        '-s',
+        '-v',
+        '-k',
+    ],
+    conf_opts=[
+        # FIXME: breaks on mac for older py's
+        '--enable-loadable-sqlite-extensions',
 
+        # '--enable-shared',
 
-#
+        '--enable-optimizations',
+        '--with-lto',
 
+        # '--enable-profiling', # ?
 
-class PyprojectPackageGenerator(BasePyprojectPackageGenerator):
+        # '--enable-ipv6', # ?
+    ],
+    cflags=[
+        # '-march=native',
+        # '-mtune=native',
+    ],
+)
 
-    #
+DEBUG_PYENV_INSTALL_OPTS = PyenvInstallOpts(opts=['-g'])
+
+THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
 
-    @dc.dataclass(frozen=True)
-    class FileContents:
-        pyproject_dct: ta.Mapping[str, ta.Any]
-        manifest_in: ta.Optional[ta.Sequence[str]]
 
-    @cached_nullary
-    def file_contents(self) -> FileContents:
-        specs = self.build_specs()
+#
 
-        #
 
-        pyp_dct = {}
+class PyenvInstallOptsProvider(abc.ABC):
+    @abc.abstractmethod
+    def opts(self) -> ta.Awaitable[PyenvInstallOpts]:
+        raise NotImplementedError
 
-        pyp_dct['build-system'] = {
-            'requires': ['setuptools'],
-            'build-backend': 'setuptools.build_meta',
-        }
 
-        prj = specs.pyproject
-        prj['name'] += self._pkg_suffix
+class LinuxPyenvInstallOpts(PyenvInstallOptsProvider):
+    async def opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts()
 
-        pyp_dct['project'] = prj
 
-        self._move_dict_key(prj, 'optional_dependencies', pyp_dct, extrask := 'project.optional-dependencies')
-        if (extras := pyp_dct.get(extrask)):
-            pyp_dct[extrask] = {
-                'all': [
-                    e
-                    for lst in extras.values()
-                    for e in lst
-                ],
-                **extras,
-            }
+class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
+    @cached_nullary
+    def framework_opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts(conf_opts=['--enable-framework'])
 
-        if (eps := prj.pop('entry_points', None)):
-            pyp_dct['project.entry-points'] = {TomlWriter.Literal(f"'{k}'"): v for k, v in eps.items()}  # type: ignore  # noqa
+    @cached_nullary
+    def has_brew(self) -> bool:
+        return shutil.which('brew') is not None
 
-        if (scs := prj.pop('scripts', None)):
-            pyp_dct['project.scripts'] = scs
+    BREW_DEPS: ta.Sequence[str] = [
+        'openssl',
+        'readline',
+        'sqlite3',
+        'zlib',
+    ]
 
-        prj.pop('cli_scripts', None)
+    @async_cached_nullary
+    async def brew_deps_opts(self) -> PyenvInstallOpts:
+        cflags = []
+        ldflags = []
+        for dep in self.BREW_DEPS:
+            dep_prefix = await asyncio_subprocess_check_output_str('brew', '--prefix', dep)
+            cflags.append(f'-I{dep_prefix}/include')
+            ldflags.append(f'-L{dep_prefix}/lib')
+        return PyenvInstallOpts(
+            cflags=cflags,
+            ldflags=ldflags,
+        )
 
-        ##
+    @async_cached_nullary
+    async def brew_tcl_opts(self) -> PyenvInstallOpts:
+        if await asyncio_subprocess_try_output('brew', '--prefix', 'tcl-tk') is None:
+            return PyenvInstallOpts()
 
-        st = dict(specs.setuptools)
-        pyp_dct['tool.setuptools'] = st
+        tcl_tk_prefix = await asyncio_subprocess_check_output_str('brew', '--prefix', 'tcl-tk')
+        tcl_tk_ver_str = await asyncio_subprocess_check_output_str('brew', 'ls', '--versions', 'tcl-tk')
+        tcl_tk_ver = '.'.join(tcl_tk_ver_str.split()[1].split('.')[:2])
 
-        st.pop('cexts', None)
+        return PyenvInstallOpts(conf_opts=[
+            f"--with-tcltk-includes='-I{tcl_tk_prefix}/include'",
+            f"--with-tcltk-libs='-L{tcl_tk_prefix}/lib -ltcl{tcl_tk_ver} -ltk{tcl_tk_ver}'",
+        ])
 
-        #
+    # @cached_nullary
+    # def brew_ssl_opts(self) -> PyenvInstallOpts:
+    #     pkg_config_path = subprocess_check_output_str('brew', '--prefix', 'openssl')
+    #     if 'PKG_CONFIG_PATH' in os.environ:
+    #         pkg_config_path += ':' + os.environ['PKG_CONFIG_PATH']
+    #     return PyenvInstallOpts(env={'PKG_CONFIG_PATH': pkg_config_path})
 
-        # TODO: default
-        # find_packages = {
-        #     'include': [Project.name, f'{Project.name}.*'],
-        #     'exclude': [*SetuptoolsBase.find_packages['exclude']],
-        # }
+    async def opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts().merge(
+            self.framework_opts(),
+            await self.brew_deps_opts(),
+            await self.brew_tcl_opts(),
+            # self.brew_ssl_opts(),
+        )
 
-        fp = dict(st.pop('find_packages', {}))
 
-        pyp_dct['tool.setuptools.packages.find'] = fp
+PLATFORM_PYENV_INSTALL_OPTS: ta.Dict[str, PyenvInstallOptsProvider] = {
+    'darwin': DarwinPyenvInstallOpts(),
+    'linux': LinuxPyenvInstallOpts(),
+}
 
-        #
 
-        # TODO: default
-        # package_data = {
-        #     '*': [
-        #         '*.c',
-        #         '*.cc',
-        #         '*.h',
-        #         '.manifests.json',
-        #         'LICENSE',
-        #     ],
-        # }
+##
 
-        pd = dict(st.pop('package_data', {}))
-        epd = dict(st.pop('exclude_package_data', {}))
 
-        cpd = self._collect_pkg_data()
-        if cpd.inc:
-            pd['*'] = [*pd.get('*', []), *sorted(set(cpd.inc))]
-        if cpd.exc:
-            epd['*'] = [*epd.get('*', []), *sorted(set(cpd.exc))]
+class PyenvVersionInstaller:
+    """
+    Messy: can install freethreaded build with a 't' suffixed version str _or_ by THREADED_PYENV_INSTALL_OPTS - need
+    latter to build custom interp with ft, need former to use canned / blessed interps. Muh.
+    """
 
-        if pd:
-            pyp_dct['tool.setuptools.package-data'] = pd
-        if epd:
-            pyp_dct['tool.setuptools.exclude-package-data'] = epd
+    def __init__(
+            self,
+            version: str,
+            opts: ta.Optional[PyenvInstallOpts] = None,
+            interp_opts: InterpOpts = InterpOpts(),
+            *,
+            install_name: ta.Optional[str] = None,
+            no_default_opts: bool = False,
+            pyenv: Pyenv = Pyenv(),
+    ) -> None:
+        super().__init__()
 
-        #
+        self._version = version
+        self._given_opts = opts
+        self._interp_opts = interp_opts
+        self._given_install_name = install_name
 
-        # TODO: default
-        # manifest_in = [
-        #     'global-exclude **/conftest.py',
-        # ]
+        self._no_default_opts = no_default_opts
+        self._pyenv = pyenv
 
-        mani_in = st.pop('manifest_in', None)
+    @property
+    def version(self) -> str:
+        return self._version
 
-        #
+    @async_cached_nullary
+    async def opts(self) -> PyenvInstallOpts:
+        opts = self._given_opts
+        if self._no_default_opts:
+            if opts is None:
+                opts = PyenvInstallOpts()
+        else:
+            lst = [self._given_opts if self._given_opts is not None else DEFAULT_PYENV_INSTALL_OPTS]
+            if self._interp_opts.debug:
+                lst.append(DEBUG_PYENV_INSTALL_OPTS)
+            if self._interp_opts.threaded:
+                lst.append(THREADED_PYENV_INSTALL_OPTS)
+            lst.append(await PLATFORM_PYENV_INSTALL_OPTS[sys.platform].opts())
+            opts = PyenvInstallOpts().merge(*lst)
+        return opts
 
-        return self.FileContents(
-            pyp_dct,
-            mani_in,
-        )
+    @cached_nullary
+    def install_name(self) -> str:
+        if self._given_install_name is not None:
+            return self._given_install_name
+        return self._version + ('-debug' if self._interp_opts.debug else '')
 
-    def _write_file_contents(self) -> None:
-        fc = self.file_contents()
+    @async_cached_nullary
+    async def install_dir(self) -> str:
+        return str(os.path.join(check_not_none(await self._pyenv.root()), 'versions', self.install_name()))
 
-        with open(os.path.join(self._pkg_dir(), 'pyproject.toml'), 'w') as f:
-            TomlWriter(f).write_root(fc.pyproject_dct)
+    @async_cached_nullary
+    async def install(self) -> str:
+        opts = await self.opts()
+        env = {**os.environ, **opts.env}
+        for k, l in [
+            ('CFLAGS', opts.cflags),
+            ('LDFLAGS', opts.ldflags),
+            ('PYTHON_CONFIGURE_OPTS', opts.conf_opts),
+        ]:
+            v = ' '.join(l)
+            if k in os.environ:
+                v += ' ' + os.environ[k]
+            env[k] = v
 
-        if fc.manifest_in:
-            with open(os.path.join(self._pkg_dir(), 'MANIFEST.in'), 'w') as f:
-                f.write('\n'.join(fc.manifest_in))  # noqa
+        conf_args = [
+            *opts.opts,
+            self._version,
+        ]
 
-    #
+        if self._given_install_name is not None:
+            full_args = [
+                os.path.join(check_not_none(await self._pyenv.root()), 'plugins', 'python-build', 'bin', 'python-build'),  # noqa
+                *conf_args,
+                self.install_dir(),
+            ]
+        else:
+            full_args = [
+                self._pyenv.exe(),
+                'install',
+                *conf_args,
+            ]
 
-    @cached_nullary
-    def children(self) -> ta.Sequence[BasePyprojectPackageGenerator]:
-        out: ta.List[BasePyprojectPackageGenerator] = []
+        await asyncio_subprocess_check_call(
+            *full_args,
+            env=env,
+        )
 
-        if self.build_specs().setuptools.get('cexts'):
-            out.append(_PyprojectCextPackageGenerator(
-                self._dir_name,
-                self._pkgs_root,
-                pkg_suffix='-cext',
-            ))
+        exe = os.path.join(await self.install_dir(), 'bin', 'python')
+        if not os.path.isfile(exe):
+            raise RuntimeError(f'Interpreter not found: {exe}')
+        return exe
 
-        if self.build_specs().pyproject.get('cli_scripts'):
-            out.append(_PyprojectCliPackageGenerator(
-                self._dir_name,
-                self._pkgs_root,
-                pkg_suffix='-cli',
-            ))
 
-        return out
+##
 
 
-#
+class PyenvInterpProvider(InterpProvider):
+    def __init__(
+            self,
+            pyenv: Pyenv = Pyenv(),
 
+            inspect: bool = False,
+            inspector: InterpInspector = INTERP_INSPECTOR,
 
-class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
+            *,
 
-    #
+            try_update: bool = False,
+    ) -> None:
+        super().__init__()
 
-    @cached_nullary
-    def find_cext_srcs(self) -> ta.Sequence[str]:
-        return sorted(find_magic_files(
-            CextMagic.STYLE,
-            [self._dir_name],
-            keys=[CextMagic.KEY],
-        ))
+        self._pyenv = pyenv
 
-    #
+        self._inspect = inspect
+        self._inspector = inspector
 
-    @dc.dataclass(frozen=True)
-    class FileContents:
-        pyproject_dct: ta.Mapping[str, ta.Any]
-        setup_py: str
+        self._try_update = try_update
 
-    @cached_nullary
-    def file_contents(self) -> FileContents:
-        specs = self.build_specs()
+    #
 
-        #
+    @staticmethod
+    def guess_version(s: str) -> ta.Optional[InterpVersion]:
+        def strip_sfx(s: str, sfx: str) -> ta.Tuple[str, bool]:
+            if s.endswith(sfx):
+                return s[:-len(sfx)], True
+            return s, False
+        ok = {}
+        s, ok['debug'] = strip_sfx(s, '-debug')
+        s, ok['threaded'] = strip_sfx(s, 't')
+        try:
+            v = Version(s)
+        except InvalidVersion:
+            return None
+        return InterpVersion(v, InterpOpts(**ok))
 
-        pyp_dct = {}
+    class Installed(ta.NamedTuple):
+        name: str
+        exe: str
+        version: InterpVersion
 
-        pyp_dct['build-system'] = {
-            'requires': ['setuptools'],
-            'build-backend': 'setuptools.build_meta',
-        }
+    async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
+        iv: ta.Optional[InterpVersion]
+        if self._inspect:
+            try:
+                iv = check_not_none(await self._inspector.inspect(ep)).iv
+            except Exception as e:  # noqa
+                return None
+        else:
+            iv = self.guess_version(vn)
+        if iv is None:
+            return None
+        return PyenvInterpProvider.Installed(
+            name=vn,
+            exe=ep,
+            version=iv,
+        )
 
-        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)
+    async def installed(self) -> ta.Sequence[Installed]:
+        ret: ta.List[PyenvInterpProvider.Installed] = []
+        for vn, ep in await self._pyenv.version_exes():
+            if (i := await self._make_installed(vn, ep)) is None:
+                log.debug('Invalid pyenv version: %s', vn)
+                continue
+            ret.append(i)
+        return ret
 
-        pyp_dct['project'] = prj
+    #
 
-        #
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [i.version for i in await self.installed()]
 
-        st = dict(specs.setuptools)
-        pyp_dct['tool.setuptools'] = st
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        for i in await self.installed():
+            if i.version == version:
+                return Interp(
+                    exe=i.exe,
+                    version=i.version,
+                )
+        raise KeyError(version)
 
-        for k in [
-            'cexts',
+    #
 
-            'find_packages',
-            'package_data',
-            'manifest_in',
-        ]:
-            st.pop(k, None)
+    async def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = []
 
-        pyp_dct['tool.setuptools.packages.find'] = {
-            'include': [],
-        }
+        for vs in await self._pyenv.installable_versions():
+            if (iv := self.guess_version(vs)) is None:
+                continue
+            if iv.opts.debug:
+                raise Exception('Pyenv installable versions not expected to have debug suffix')
+            for d in [False, True]:
+                lst.append(dc.replace(iv, opts=dc.replace(iv.opts, debug=d)))
 
-        #
+        return lst
 
-        ext_lines = []
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = await self._get_installable_versions(spec)
 
-        for ext_src in self.find_cext_srcs():
-            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'],",
-                '),',
-            ])
+        if self._try_update and not any(v in spec for v in lst):
+            if self._pyenv.update():
+                lst = await self._get_installable_versions(spec)
 
-        src = '\n'.join([
-            'import setuptools as st',
-            '',
-            '',
-            'st.setup(',
-            '    ext_modules=[',
-            *['        ' + l for l in ext_lines],
-            '    ]',
-            ')',
-            '',
-        ])
+        return lst
 
-        #
+    async def install_version(self, version: InterpVersion) -> Interp:
+        inst_version = str(version.version)
+        inst_opts = version.opts
+        if inst_opts.threaded:
+            inst_version += 't'
+            inst_opts = dc.replace(inst_opts, threaded=False)
 
-        return self.FileContents(
-            pyp_dct,
-            src,
+        installer = PyenvVersionInstaller(
+            inst_version,
+            interp_opts=inst_opts,
         )
 
-    def _write_file_contents(self) -> None:
-        fc = self.file_contents()
+        exe = await installer.install()
+        return Interp(exe, version)
 
-        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)
+########################################
+# ../../interp/system.py
+"""
+TODO:
+ - python, python3, python3.12, ...
+ - check if path py's are venvs: sys.prefix != sys.base_prefix
+"""
 
 
 ##
 
 
-class _PyprojectCliPackageGenerator(BasePyprojectPackageGenerator):
-
-    #
-
-    @dc.dataclass(frozen=True)
-    class FileContents:
-        pyproject_dct: ta.Mapping[str, ta.Any]
-
-    @cached_nullary
-    def file_contents(self) -> FileContents:
-        specs = self.build_specs()
+@dc.dataclass(frozen=True)
+class SystemInterpProvider(InterpProvider):
+    cmd: str = 'python3'
+    path: ta.Optional[str] = None
 
-        #
+    inspect: bool = False
+    inspector: InterpInspector = INTERP_INSPECTOR
 
-        pyp_dct = {}
+    #
 
-        pyp_dct['build-system'] = {
-            'requires': ['setuptools'],
-            'build-backend': 'setuptools.build_meta',
-        }
+    @staticmethod
+    def _re_which(
+            pat: re.Pattern,
+            *,
+            mode: int = os.F_OK | os.X_OK,
+            path: ta.Optional[str] = None,
+    ) -> ta.List[str]:
+        if path is None:
+            path = os.environ.get('PATH', None)
+            if path is None:
+                try:
+                    path = os.confstr('CS_PATH')
+                except (AttributeError, ValueError):
+                    path = os.defpath
 
-        prj = specs.pyproject
-        prj['dependencies'] = [f'{prj["name"]} == {prj["version"]}']
-        prj['name'] += self._pkg_suffix
-        for k in [
-            'optional_dependencies',
-            'entry_points',
-            'scripts',
-        ]:
-            prj.pop(k, None)
+        if not path:
+            return []
 
-        pyp_dct['project'] = prj
+        path = os.fsdecode(path)
+        pathlst = path.split(os.pathsep)
 
-        if (scs := prj.pop('cli_scripts', None)):
-            pyp_dct['project.scripts'] = scs
+        def _access_check(fn: str, mode: int) -> bool:
+            return os.path.exists(fn) and os.access(fn, mode)
 
-        #
+        out = []
+        seen = set()
+        for d in pathlst:
+            normdir = os.path.normcase(d)
+            if normdir not in seen:
+                seen.add(normdir)
+                if not _access_check(normdir, mode):
+                    continue
+                for thefile in os.listdir(d):
+                    name = os.path.join(d, thefile)
+                    if not (
+                            os.path.isfile(name) and
+                            pat.fullmatch(thefile) and
+                            _access_check(name, mode)
+                    ):
+                        continue
+                    out.append(name)
 
-        st = dict(specs.setuptools)
-        pyp_dct['tool.setuptools'] = st
+        return out
 
-        for k in [
-            'cexts',
+    @cached_nullary
+    def exes(self) -> ta.List[str]:
+        return self._re_which(
+            re.compile(r'python3(\.\d+)?'),
+            path=self.path,
+        )
 
-            'find_packages',
-            'package_data',
-            'manifest_in',
-        ]:
-            st.pop(k, None)
+    #
 
-        pyp_dct['tool.setuptools.packages.find'] = {
-            'include': [],
-        }
+    async def get_exe_version(self, exe: str) -> ta.Optional[InterpVersion]:
+        if not self.inspect:
+            s = os.path.basename(exe)
+            if s.startswith('python'):
+                s = s[len('python'):]
+            if '.' in s:
+                try:
+                    return InterpVersion.parse(s)
+                except InvalidVersion:
+                    pass
+        ii = await self.inspector.inspect(exe)
+        return ii.iv if ii is not None else None
 
-        #
+    async def exe_versions(self) -> ta.Sequence[ta.Tuple[str, InterpVersion]]:
+        lst = []
+        for e in self.exes():
+            if (ev := await self.get_exe_version(e)) is None:
+                log.debug('Invalid system version: %s', e)
+                continue
+            lst.append((e, ev))
+        return lst
 
-        return self.FileContents(
-            pyp_dct,
-        )
+    #
 
-    def _write_file_contents(self) -> None:
-        fc = self.file_contents()
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [ev for e, ev in await self.exe_versions()]
 
-        with open(os.path.join(self._pkg_dir(), 'pyproject.toml'), 'w') as f:
-            TomlWriter(f).write_root(fc.pyproject_dct)
+    async def get_installed_version(self, version: InterpVersion) -> Interp:
+        for e, ev in await self.exe_versions():
+            if ev != version:
+                continue
+            return Interp(
+                exe=e,
+                version=ev,
+            )
+        raise KeyError(version)
 
 
 ########################################
@@ -5738,13 +6162,14 @@ class InterpResolver:
             providers: ta.Sequence[ta.Tuple[str, InterpProvider]],
     ) -> None:
         super().__init__()
+
         self._providers: ta.Mapping[str, InterpProvider] = collections.OrderedDict(providers)
 
-    def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
+    async def _resolve_installed(self, spec: InterpSpecifier) -> ta.Optional[ta.Tuple[InterpProvider, InterpVersion]]:
         lst = [
             (i, si)
             for i, p in enumerate(self._providers.values())
-            for si in p.get_installed_versions(spec)
+            for si in await p.get_installed_versions(spec)
             if spec.contains(si)
         ]
 
@@ -5756,16 +6181,16 @@ class InterpResolver:
         bp = list(self._providers.values())[bi]
         return (bp, bv)
 
-    def resolve(
+    async def resolve(
             self,
             spec: InterpSpecifier,
             *,
             install: bool = False,
     ) -> ta.Optional[Interp]:
-        tup = self._resolve_installed(spec)
+        tup = await self._resolve_installed(spec)
         if tup is not None:
             bp, bv = tup
-            return bp.get_installed_version(bv)
+            return await bp.get_installed_version(bv)
 
         if not install:
             return None
@@ -5773,21 +6198,21 @@ class InterpResolver:
         tp = list(self._providers.values())[0]  # noqa
 
         sv = sorted(
-            [s for s in tp.get_installable_versions(spec) if s in spec],
+            [s for s in await tp.get_installable_versions(spec) if s in spec],
             key=lambda s: s.version,
         )
         if not sv:
             return None
 
         bv = sv[-1]
-        return tp.install_version(bv)
+        return await tp.install_version(bv)
 
-    def list(self, spec: InterpSpecifier) -> None:
+    async def list(self, spec: InterpSpecifier) -> None:
         print('installed:')
         for n, p in self._providers.items():
             lst = [
                 si
-                for si in p.get_installed_versions(spec)
+                for si in await p.get_installed_versions(spec)
                 if spec.contains(si)
             ]
             if lst:
@@ -5801,7 +6226,7 @@ class InterpResolver:
         for n, p in self._providers.items():
             lst = [
                 si
-                for si in p.get_installable_versions(spec)
+                for si in await p.get_installable_versions(spec)
                 if spec.contains(si)
             ]
             if lst:
@@ -5892,10 +6317,10 @@ class Venv:
     def dir_name(self) -> str:
         return os.path.join(self.DIR_NAME, self._name)
 
-    @cached_nullary
-    def interp_exe(self) -> str:
+    @async_cached_nullary
+    async def interp_exe(self) -> str:
         i = InterpSpecifier.parse(check_not_none(self._cfg.interp))
-        return check_not_none(DEFAULT_INTERP_RESOLVER.resolve(i, install=True)).exe
+        return check_not_none(await DEFAULT_INTERP_RESOLVER.resolve(i, install=True)).exe
 
     @cached_nullary
     def exe(self) -> str:
@@ -5904,14 +6329,14 @@ class Venv:
             raise Exception(f'venv exe {ve} does not exist or is not a file!')
         return ve
 
-    @cached_nullary
-    def create(self) -> bool:
+    @async_cached_nullary
+    async def create(self) -> bool:
         if os.path.exists(dn := self.dir_name):
             if not os.path.isdir(dn):
                 raise Exception(f'{dn} exists but is not a directory!')
             return False
 
-        log.info('Using interpreter %s', (ie := self.interp_exe()))
+        log.info('Using interpreter %s', (ie := await self.interp_exe()))
         subprocess_check_call(ie, '-m', 'venv', dn)
 
         ve = self.exe()
@@ -6011,7 +6436,7 @@ class Run:
 ##
 
 
-def _venv_cmd(args) -> None:
+async def _venv_cmd(args) -> None:
     venv = Run().venvs()[args.name]
     if (sd := venv.cfg.docker) is not None and sd != (cd := args._docker_container):  # noqa
         script = ' '.join([
@@ -6048,10 +6473,10 @@ def _venv_cmd(args) -> None:
 
     cmd = args.cmd
     if not cmd:
-        venv.create()
+        await venv.create()
 
     elif cmd == 'python':
-        venv.create()
+        await venv.create()
         os.execl(
             (exe := venv.exe()),
             exe,
@@ -6059,12 +6484,12 @@ def _venv_cmd(args) -> None:
         )
 
     elif cmd == 'exe':
-        venv.create()
+        await venv.create()
         check_not(args.args)
         print(venv.exe())
 
     elif cmd == 'run':
-        venv.create()
+        await venv.create()
         sh = check_not_none(shutil.which('bash'))
         script = ' '.join(args.args)
         if not script:
@@ -6081,7 +6506,7 @@ def _venv_cmd(args) -> None:
         print('\n'.join(venv.srcs()))
 
     elif cmd == 'test':
-        venv.create()
+        await venv.create()
         subprocess_check_call(venv.exe(), '-m', 'pytest', *(args.args or []), *venv.srcs())
 
     else:
@@ -6091,7 +6516,7 @@ def _venv_cmd(args) -> None:
 ##
 
 
-def _pkg_cmd(args) -> None:
+async def _pkg_cmd(args) -> None:
     run = Run()
 
     cmd = args.cmd
@@ -6178,7 +6603,7 @@ def _build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def _main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+async def _async_main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
     check_runtime_version()
     configure_standard_logging()
 
@@ -6187,7 +6612,11 @@ def _main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
     if not getattr(args, 'func', None):
         parser.print_help()
     else:
-        args.func(args)
+        await args.func(args)
+
+
+def _main(argv: ta.Optional[ta.Sequence[str]] = None) -> None:
+    asyncio.run(_async_main(argv))
 
 
 if __name__ == '__main__':