omdev 0.0.0.dev111__py3-none-any.whl → 0.0.0.dev113__py3-none-any.whl

omdev/scripts/pyproject.py

@@ -99,109 +99,6 @@ UnparsedVersionVar = ta.TypeVar('UnparsedVersionVar', bound=UnparsedVersion)
 CallableVersionOperator = ta.Callable[['Version', str], bool]
 
 
-########################################
-# ../../git.py
-
-
-def git_clone_subtree(
-        *,
-        base_dir: str,
-        repo_url: str,
-        repo_dir: str,
-        branch: ta.Optional[str] = None,
-        rev: ta.Optional[str] = None,
-        repo_subtrees: ta.Sequence[str],
-) -> None:
-    if not bool(branch) ^ bool(rev):
-        raise ValueError('must set branch or rev')
-
-    if isinstance(repo_subtrees, str):
-        raise TypeError(repo_subtrees)
-
-    git_opts = [
-        '-c', 'advice.detachedHead=false',
-    ]
-
-    subprocess.check_call(
-        [
-            'git',
-            *git_opts,
-            'clone',
-            '-n',
-            '--depth=1',
-            '--filter=tree:0',
-            *(['-b', branch] if branch else []),
-            '--single-branch',
-            repo_url,
-            repo_dir,
-        ],
-        cwd=base_dir,
-    )
-
-    rd = os.path.join(base_dir, repo_dir)
-    subprocess.check_call(
-        [
-            'git',
-            *git_opts,
-            'sparse-checkout',
-            'set',
-            '--no-cone',
-            *repo_subtrees,
-        ],
-        cwd=rd,
-    )
-
-    subprocess.check_call(
-        [
-            'git',
-            *git_opts,
-            'checkout',
-            *([rev] if rev else []),
-        ],
-        cwd=rd,
-    )
-
-
-def get_git_revision(
-        *,
-        cwd: ta.Optional[str] = None,
-) -> ta.Optional[str]:
-    subprocess.check_output(['git', '--version'])
-
-    if cwd is None:
-        cwd = os.getcwd()
-
-    if subprocess.run(  # noqa
-        [
-            'git',
-            'rev-parse',
-            '--is-inside-work-tree',
-        ],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-    ).returncode:
-        return None
-
-    has_untracked = bool(subprocess.check_output([
-        'git',
-        'ls-files',
-        '.',
-        '--exclude-standard',
-        '--others',
-    ], cwd=cwd).decode().strip())
-
-    dirty_rev = subprocess.check_output([
-        'git',
-        'describe',
-        '--match=NeVeRmAtCh',
-        '--always',
-        '--abbrev=40',
-        '--dirty',
-    ], cwd=cwd).decode().strip()
-
-    return dirty_rev + ('-untracked' if has_untracked else '')
-
-
 ########################################
 # ../../magic/magic.py
 
@@ -3735,126 +3632,6 @@ class RequirementsRewriter:
             return in_req
 
 
-########################################
-# ../../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__'
-
-    def add_to_contents(self, dct: ta.Dict[str, bytes]) -> bool:
-        changed = False
-        for n in dct:
-            if not n.endswith('__about__.py'):
-                continue
-            src = dct[n].decode('utf-8')
-            lines = src.splitlines(keepends=True)
-            for i, l in enumerate(lines):
-                if l != f'{self.REVISION_ATTR} = None\n':
-                    continue
-                lines[i] = f"{self.REVISION_ATTR} = '{self.revision()}'\n"
-                changed = True
-            dct[n] = ''.join(lines).encode('utf-8')
-        return changed
-
-    def add_to_wheel(self, f: str) -> None:
-        if not f.endswith('.whl'):
-            raise Exception(f)
-        log.info('Scanning wheel %s', f)
-
-        zis: ta.Dict[str, zipfile.ZipInfo] = {}
-        dct: ta.Dict[str, bytes] = {}
-        with WheelFile(f) as wf:
-            for zi in wf.filelist:
-                if zi.filename == wf.record_path:
-                    continue
-                zis[zi.filename] = zi
-                dct[zi.filename] = wf.read(zi.filename)
-
-        if self.add_to_contents(dct):
-            of = f[:-4] + (self._output_suffix or '') + '.whl'
-            log.info('Repacking wheel %s', of)
-            with WheelFile(of, 'w') as wf:
-                for n, d in dct.items():
-                    log.info('Adding zipinfo %s', n)
-                    wf.writestr(zis[n], d)
-
-    def add_to_tgz(self, f: str) -> None:
-        if not f.endswith('.tar.gz'):
-            raise Exception(f)
-        log.info('Scanning tgz %s', f)
-
-        tis: ta.Dict[str, tarfile.TarInfo] = {}
-        dct: ta.Dict[str, bytes] = {}
-        with tarfile.open(f, 'r:gz') as tf:
-            for ti in tf:
-                tis[ti.name] = ti
-                if ti.type == tarfile.REGTYPE:
-                    with tf.extractfile(ti.name) as tif:  # type: ignore
-                        dct[ti.name] = tif.read()
-
-        if self.add_to_contents(dct):
-            of = f[:-7] + (self._output_suffix or '') + '.tar.gz'
-            log.info('Repacking tgz %s', of)
-            with tarfile.open(of, 'w:gz') as tf:
-                for n, ti in tis.items():
-                    log.info('Adding tarinfo %s', n)
-                    if n in dct:
-                        data = dct[n]
-                        ti.size = len(data)
-                        fo = io.BytesIO(data)
-                    else:
-                        fo = None
-                    tf.addfile(ti, fileobj=fo)
-
-    EXTS = ('.tar.gz', '.whl')
-
-    def add_to_file(self, f: str) -> None:
-        if f.endswith('.whl'):
-            self.add_to_wheel(f)
-
-        elif f.endswith('.tar.gz'):
-            self.add_to_tgz(f)
-
-    def add_to(self, tgt: str) -> None:
-        log.info('Using revision %s', self.revision())
-
-        if os.path.isfile(tgt):
-            self.add_to_file(tgt)
-
-        elif os.path.isdir(tgt):
-            for dp, dns, fns in os.walk(tgt):  # noqa
-                for f in fns:
-                    if any(f.endswith(ext) for ext in self.EXTS):
-                        self.add_to_file(os.path.join(dp, f))
-
-
-#
-
-
 ########################################
 # ../../../omlish/lite/subprocesses.py
 
@@ -3980,39 +3757,436 @@ def subprocess_close(
 
 
 ########################################
-# ../../interp/inspect.py
-
+# ../../git.py
+"""
+git status
+  --porcelain=v1
+  --ignore-submodules
+  2>/dev/null
+"""
 
-@dc.dataclass(frozen=True)
-class InterpInspection:
-    exe: str
-    version: Version
 
-    version_str: str
-    config_vars: ta.Mapping[str, str]
-    prefix: str
-    base_prefix: str
+##
 
-    @property
-    def opts(self) -> InterpOpts:
-        return InterpOpts(
-            threaded=bool(self.config_vars.get('Py_GIL_DISABLED')),
-            debug=bool(self.config_vars.get('Py_DEBUG')),
-        )
 
-    @property
-    def iv(self) -> InterpVersion:
-        return InterpVersion(
-            version=self.version,
-            opts=self.opts,
-        )
+def git_clone_subtree(
+        *,
+        base_dir: str,
+        repo_url: str,
+        repo_dir: str,
+        branch: ta.Optional[str] = None,
+        rev: ta.Optional[str] = None,
+        repo_subtrees: ta.Sequence[str],
+) -> None:
+    if not bool(branch) ^ bool(rev):
+        raise ValueError('must set branch or rev')
 
-    @property
-    def is_venv(self) -> bool:
-        return self.prefix != self.base_prefix
+    if isinstance(repo_subtrees, str):
+        raise TypeError(repo_subtrees)
 
+    git_opts = [
+        '-c', 'advice.detachedHead=false',
+    ]
 
-class InterpInspector:
+    subprocess.check_call(
+        subprocess_maybe_shell_wrap_exec(
+            'git',
+            *git_opts,
+            'clone',
+            '-n',
+            '--depth=1',
+            '--filter=tree:0',
+            *(['-b', branch] if branch else []),
+            '--single-branch',
+            repo_url,
+            repo_dir,
+        ),
+        cwd=base_dir,
+    )
+
+    rd = os.path.join(base_dir, repo_dir)
+    subprocess.check_call(
+        subprocess_maybe_shell_wrap_exec(
+            'git',
+            *git_opts,
+            'sparse-checkout',
+            'set',
+            '--no-cone',
+            *repo_subtrees,
+        ),
+        cwd=rd,
+    )
+
+    subprocess.check_call(
+        subprocess_maybe_shell_wrap_exec(
+            'git',
+            *git_opts,
+            'checkout',
+            *([rev] if rev else []),
+        ),
+        cwd=rd,
+    )
+
+
+def get_git_revision(
+        *,
+        cwd: ta.Optional[str] = None,
+) -> ta.Optional[str]:
+    subprocess.check_output(subprocess_maybe_shell_wrap_exec('git', '--version'))
+
+    if cwd is None:
+        cwd = os.getcwd()
+
+    if subprocess.run(  # noqa
+        subprocess_maybe_shell_wrap_exec(
+            'git',
+            'rev-parse',
+            '--is-inside-work-tree',
+        ),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    ).returncode:
+        return None
+
+    has_untracked = bool(subprocess.check_output(subprocess_maybe_shell_wrap_exec(
+        'git',
+        'ls-files',
+        '.',
+        '--exclude-standard',
+        '--others',
+    ), cwd=cwd).decode().strip())
+
+    dirty_rev = subprocess.check_output(subprocess_maybe_shell_wrap_exec(
+        'git',
+        'describe',
+        '--match=NeVeRmAtCh',
+        '--always',
+        '--abbrev=40',
+        '--dirty',
+    ), cwd=cwd).decode().strip()
+
+    return dirty_rev + ('-untracked' if has_untracked else '')
+
+
+##
+
+
+_GIT_STATUS_LINE_ESCAPE_CODES: ta.Mapping[str, str] = {
+    '\\': '\\',
+    '"': '"',
+    'n': '\n',
+    't': '\t',
+}
+
+
+def yield_git_status_line_fields(l: str) -> ta.Iterator[str]:
+    def find_any(chars: str, start: int = 0) -> int:
+        ret = -1
+        for c in chars:
+            if (found := l.find(c, start)) >= 0 and (ret < 0 or ret > found):
+                ret = found
+        return ret
+
+    p = 0
+    while True:
+        if l[p] == '"':
+            p += 1
+            s = []
+            while (n := find_any('\\"', p)) > 0:
+                if (c := l[n]) == '\\':
+                    s.append(l[p:n])
+                    s.append(_GIT_STATUS_LINE_ESCAPE_CODES[l[n + 1]])
+                    p = n + 2
+                elif c == '"':
+                    s.append(l[p:n])
+                    p = n
+                    break
+                else:
+                    raise ValueError(l)
+
+            if l[p] != '"':
+                raise ValueError(l)
+
+            yield ''.join(s)
+
+            p += 1
+            if p == len(l):
+                return
+            elif l[p] != ' ':
+                raise ValueError(l)
+
+            p += 1
+
+        else:
+            if (e := l.find(' ', p)) < 0:
+                yield l[p:]
+                return
+
+            yield l[p:e]
+            p = e + 1
+
+
+"""
+When merge is occurring and was successful, or outside of a merge situation, X shows the status of the index and Y shows
+the status of the working tree:
+-------------------------------------------------
+X         Y       Meaning
+-------------------------------------------------
+          [AMD]   not updated
+M         [ MTD]  updated in index
+T         [ MTD]  type changed in index
+A         [ MTD]  added to index
+D                 deleted from index
+R         [ MTD]  renamed in index
+C         [ MTD]  copied in index
+[MTARC]           index and work tree matches
+[ MTARC]  M       work tree changed since index
+[ MTARC]  T       type changed in work tree since index
+[ MTARC]  D       deleted in work tree
+          R       renamed in work tree
+          C       copied in work tree
+
+When merge conflict has occurred and has not yet been resolved, X and Y show the state introduced by each head of the
+merge, relative to the common ancestor:
+-------------------------------------------------
+X         Y       Meaning
+-------------------------------------------------
+D         D       unmerged, both deleted
+A         U       unmerged, added by us
+U         D       unmerged, deleted by them
+U         A       unmerged, added by them
+D         U       unmerged, deleted by us
+A         A       unmerged, both added
+U         U       unmerged, both modified
+
+When path is untracked, X and Y are always the same, since they are unknown to the index:
+-------------------------------------------------
+X         Y       Meaning
+-------------------------------------------------
+?         ?       untracked
+!         !       ignored
+
+Submodules have more state and instead report
+
+ - M = the submodule has a different HEAD than recorded in the index
+ - m = the submodule has modified content
+ - ? = the submodule has untracked files
+
+This is since modified content or untracked files in a submodule cannot be added via git add in the superproject to
+prepare a commit. m and ? are applied recursively. For example if a nested submodule in a submodule contains an
+untracked file, this is reported as ? as well.
+"""  # noqa
+
+
+class GitStatusLineState(enum.Enum):
+    UNMODIFIED = ' '
+    MODIFIED = 'M'
+    FILE_TYPE_CHANGED = 'T'
+    ADDED = 'A'
+    DELETED = 'D'
+    RENAMED = 'R'
+    COPIED = 'C'
+    UPDATED_BUT_UNMERGED = 'U'
+    UNTRACKED = '?'
+    IGNORED = '!'
+    SUBMODULE_MODIFIED_CONTENT = 'm'
+
+
+_EXTRA_UNMERGED_GIT_STATUS_LINE_STATES: ta.FrozenSet[ta.Tuple[GitStatusLineState, GitStatusLineState]] = frozenset([
+    (GitStatusLineState.ADDED, GitStatusLineState.ADDED),
+    (GitStatusLineState.DELETED, GitStatusLineState.DELETED),
+])
+
+
+@dc.dataclass(frozen=True)
+class GitStatusLine:
+    x: GitStatusLineState
+    y: GitStatusLineState
+
+    a: str
+    b: ta.Optional[str]
+
+    @property
+    def is_unmerged(self) -> bool:
+        return (
+            self.x is GitStatusLineState.UPDATED_BUT_UNMERGED or
+            self.y is GitStatusLineState.UPDATED_BUT_UNMERGED or
+            (self.x, self.y) in _EXTRA_UNMERGED_GIT_STATUS_LINE_STATES
+        )
+
+    def __repr__(self) -> str:
+        return (
+            f'{self.__class__.__name__}('
+            f'x={self.x.name}, '
+            f'y={self.y.name}, '
+            f'a={self.a!r}' +
+            (f', b={self.b!r}' if self.b is not None else '') +
+            ')'
+        )
+
+
+def parse_git_status_line(l: str) -> GitStatusLine:
+    if len(l) < 3 or l[2] != ' ':
+        raise ValueError(l)
+    x, y = l[0], l[1]
+
+    fields = list(yield_git_status_line_fields(l[3:]))
+    if len(fields) == 1:
+        a, b = fields[0], None
+    elif len(fields) == 3:
+        check_state(fields[1] == '->', l)
+        a, b = fields[0], fields[2]
+    else:
+        raise ValueError(l)
+
+    return GitStatusLine(
+        GitStatusLineState(x),
+        GitStatusLineState(y),
+        a,
+        b,
+    )
+
+
+class GitStatus(ta.Sequence[GitStatusLine]):
+    def __init__(self, lines: ta.Iterable[GitStatusLine]) -> None:
+        super().__init__()
+
+        self._lst = list(lines)
+
+        by_x: ta.Dict[GitStatusLineState, list[GitStatusLine]] = {}
+        by_y: ta.Dict[GitStatusLineState, list[GitStatusLine]] = {}
+
+        by_a: ta.Dict[str, GitStatusLine] = {}
+        by_b: ta.Dict[str, GitStatusLine] = {}
+
+        for l in self._lst:
+            by_x.setdefault(l.x, []).append(l)
+            by_y.setdefault(l.y, []).append(l)
+
+            if l.a in by_a:
+                raise KeyError(l.a)
+            by_a[l.a] = l
+
+            if l.b is not None:
+                if l.b in by_b:
+                    raise KeyError(l.b)
+                by_b[l.b] = l
+
+        self._by_x = by_x
+        self._by_y = by_y
+
+        self._by_a = by_a
+        self._by_b = by_b
+
+        self._has_unmerged = any(l.is_unmerged for l in self)
+
+    #
+
+    def __iter__(self) -> ta.Iterator[GitStatusLine]:
+        return iter(self._lst)
+
+    def __getitem__(self, index):
+        return self._lst[index]
+
+    def __len__(self) -> int:
+        return len(self._lst)
+
+    #
+
+    @property
+    def by_x(self) -> ta.Mapping[GitStatusLineState, ta.Sequence[GitStatusLine]]:
+        return self._by_x
+
+    @property
+    def by_y(self) -> ta.Mapping[GitStatusLineState, ta.Sequence[GitStatusLine]]:
+        return self._by_y
+
+    @property
+    def by_a(self) -> ta.Mapping[str, GitStatusLine]:
+        return self._by_a
+
+    @property
+    def by_b(self) -> ta.Mapping[str, GitStatusLine]:
+        return self._by_b
+
+    #
+
+    @property
+    def has_unmerged(self) -> bool:
+        return self._has_unmerged
+
+    @property
+    def has_staged(self) -> bool:
+        return any(l.x != GitStatusLineState.UNMODIFIED for l in self._lst)
+
+    @property
+    def has_dirty(self) -> bool:
+        return any(l.y != GitStatusLineState.UNMODIFIED for l in self._lst)
+
+
+def parse_git_status(s: str) -> GitStatus:
+    return GitStatus(parse_git_status_line(l) for l in s.splitlines())
+
+
+def get_git_status(
+        *,
+        cwd: ta.Optional[str] = None,
+        ignore_submodules: bool = False,
+        verbose: bool = False,
+) -> GitStatus:
+    if cwd is None:
+        cwd = os.getcwd()
+
+    proc = subprocess.run(  # type: ignore
+        subprocess_maybe_shell_wrap_exec(
+            'git',
+            'status',
+            '--porcelain=v1',
+            *(['--ignore-submodules'] if ignore_submodules else []),
+        ),
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        **(dict(stderr=subprocess.PIPE) if not verbose else {}),
+        check=True,
+    )
+
+    return parse_git_status(proc.stdout.decode())  # noqa
+
+
+########################################
+# ../../interp/inspect.py
+
+
+@dc.dataclass(frozen=True)
+class InterpInspection:
+    exe: str
+    version: Version
+
+    version_str: str
+    config_vars: ta.Mapping[str, str]
+    prefix: str
+    base_prefix: str
+
+    @property
+    def opts(self) -> InterpOpts:
+        return InterpOpts(
+            threaded=bool(self.config_vars.get('Py_GIL_DISABLED')),
+            debug=bool(self.config_vars.get('Py_DEBUG')),
+        )
+
+    @property
+    def iv(self) -> InterpVersion:
+        return InterpVersion(
+            version=self.version,
+            opts=self.opts,
+        )
+
+    @property
+    def is_venv(self) -> bool:
+        return self.prefix != self.base_prefix
+
+
+class InterpInspector:
 
     def __init__(self) -> None:
         super().__init__()
@@ -4076,1180 +4250,1300 @@ INTERP_INSPECTOR = InterpInspector()
 
 
 ########################################
-# ../pkg.py
+# ../../interp/providers.py
 """
 TODO:
- - ext scanning
- - __revision__
- - entry_points
+ - backends
+  - local builds
+  - deadsnakes?
+  - uv
+ - loose versions
+"""
 
-** 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
 
---
+##
 
-https://setuptools.pypa.io/en/latest/references/keywords.html
-https://packaging.python.org/en/latest/specifications/pyproject-toml
 
-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
+class InterpProvider(abc.ABC):
+    name: ta.ClassVar[str]
 
-https://github.com/pypa/sampleproject/blob/db5806e0a3204034c51b1c00dde7d5eb3fa2532e/setup.py
+    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)]))
 
-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
+    @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
 
-#
+    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return []
 
+    def install_version(self, version: InterpVersion) -> Interp:
+        raise TypeError
 
-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
 
-    #
+##
 
+
+class RunningInterpProvider(InterpProvider):
     @cached_nullary
-    def about(self) -> types.ModuleType:
-        return importlib.import_module(f'{self._dir_name}.__about__')
+    def version(self) -> InterpVersion:
+        return InterpInspector.running().iv
 
-    #
+    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [self.version()]
 
-    @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 get_installed_version(self, version: InterpVersion) -> Interp:
+        if version != self.version():
+            raise KeyError(version)
+        return Interp(
+            exe=sys.executable,
+            version=self.version(),
+        )
 
-    #
 
-    _GIT_IGNORE: ta.Sequence[str] = [
-        '/*.egg-info/',
-        '/dist',
-    ]
+########################################
+# ../../revisions.py
+"""
+TODO:
+ - omlish-lite, move to pyproject/
+  - vendor-lite wheel.wheelfile
+"""
 
-    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))
 
-    #
+##
 
-    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 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 project_cls(self) -> type:
-        return self.about().Project
+    def revision(self) -> str:
+        if self._given_revision is not None:
+            return self._given_revision
+        return check_non_empty_str(get_git_revision())
 
-    @cached_nullary
-    def setuptools_cls(self) -> type:
-        return self.about().Setuptools
+    REVISION_ATTR = '__revision__'
 
-    @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('_'):
+    def add_to_contents(self, dct: ta.Dict[str, bytes]) -> bool:
+        changed = False
+        for n in dct:
+            if not n.endswith('__about__.py'):
+                continue
+            src = dct[n].decode('utf-8')
+            lines = src.splitlines(keepends=True)
+            for i, l in enumerate(lines):
+                if l != f'{self.REVISION_ATTR} = None\n':
                     continue
-                dct[k] = v
-        return dct
-
-    @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)
+                lines[i] = f"{self.REVISION_ATTR} = '{self.revision()}'\n"
+                changed = True
+            dct[n] = ''.join(lines).encode('utf-8')
+        return changed
 
-    @dc.dataclass(frozen=True)
-    class Specs:
-        pyproject: ta.Dict[str, ta.Any]
-        setuptools: ta.Dict[str, ta.Any]
+    def add_to_wheel(self, f: str) -> None:
+        if not f.endswith('.whl'):
+            raise Exception(f)
+        log.info('Scanning wheel %s', f)
 
-    def build_specs(self) -> Specs:
-        return self.Specs(
-            self._build_cls_dct(self.project_cls()),
-            self._build_cls_dct(self.setuptools_cls()),
-        )
+        zis: ta.Dict[str, zipfile.ZipInfo] = {}
+        dct: ta.Dict[str, bytes] = {}
+        with WheelFile(f) as wf:
+            for zi in wf.filelist:
+                if zi.filename == wf.record_path:
+                    continue
+                zis[zi.filename] = zi
+                dct[zi.filename] = wf.read(zi.filename)
 
-    #
+        if self.add_to_contents(dct):
+            of = f[:-4] + (self._output_suffix or '') + '.whl'
+            log.info('Repacking wheel %s', of)
+            with WheelFile(of, 'w') as wf:
+                for n, d in dct.items():
+                    log.info('Adding zipinfo %s', n)
+                    wf.writestr(zis[n], d)
 
-    class _PkgData(ta.NamedTuple):
-        inc: ta.List[str]
-        exc: ta.List[str]
+    def add_to_tgz(self, f: str) -> None:
+        if not f.endswith('.tar.gz'):
+            raise Exception(f)
+        log.info('Scanning tgz %s', f)
 
-    @cached_nullary
-    def _collect_pkg_data(self) -> _PkgData:
-        inc: ta.List[str] = []
-        exc: ta.List[str] = []
+        tis: ta.Dict[str, tarfile.TarInfo] = {}
+        dct: ta.Dict[str, bytes] = {}
+        with tarfile.open(f, 'r:gz') as tf:
+            for ti in tf:
+                tis[ti.name] = ti
+                if ti.type == tarfile.REGTYPE:
+                    with tf.extractfile(ti.name) as tif:  # type: ignore
+                        dct[ti.name] = tif.read()
 
-        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:]))
+        if self.add_to_contents(dct):
+            of = f[:-7] + (self._output_suffix or '') + '.tar.gz'
+            log.info('Repacking tgz %s', of)
+            with tarfile.open(of, 'w:gz') as tf:
+                for n, ti in tis.items():
+                    log.info('Adding tarinfo %s', n)
+                    if n in dct:
+                        data = dct[n]
+                        ti.size = len(data)
+                        fo = io.BytesIO(data)
                     else:
-                        inc.append(os.path.join(rp, l))
+                        fo = None
+                    tf.addfile(ti, fileobj=fo)
 
-        return self._PkgData(inc, exc)
+    EXTS = ('.tar.gz', '.whl')
 
-    #
+    def add_to_file(self, f: str) -> None:
+        if f.endswith('.whl'):
+            self.add_to_wheel(f)
 
-    @abc.abstractmethod
-    def _write_file_contents(self) -> None:
-        raise NotImplementedError
+        elif f.endswith('.tar.gz'):
+            self.add_to_tgz(f)
 
-    #
+    def add_to(self, tgt: str) -> None:
+        log.info('Using revision %s', self.revision())
 
-    _STANDARD_FILES: ta.Sequence[str] = [
-        'LICENSE',
-        'README.rst',
-    ]
+        if os.path.isfile(tgt):
+            self.add_to_file(tgt)
 
-    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))
+        elif os.path.isdir(tgt):
+            for dp, dns, fns in os.walk(tgt):  # noqa
+                for f in fns:
+                    if any(f.endswith(ext) for ext in self.EXTS):
+                        self.add_to_file(os.path.join(dp, f))
 
-    #
 
-    def children(self) -> ta.Sequence['BasePyprojectPackageGenerator']:
-        return []
+#
 
-    #
 
-    def gen(self) -> str:
-        log.info('Generating pyproject package: %s -> %s (%s)', self._dir_name, self._pkgs_root, self._pkg_suffix)
+########################################
+# ../../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
+"""
 
-        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
+class Pyenv:
 
-    def build(
+    def __init__(
             self,
-            output_dir: ta.Optional[str] = None,
-            opts: BuildOpts = BuildOpts(),
+            *,
+            root: ta.Optional[str] = None,
     ) -> None:
-        subprocess_check_call(
-            sys.executable,
-            '-m',
-            'build',
-            cwd=self._pkg_dir(),
-        )
+        if root is not None and not (isinstance(root, str) and root):
+            raise ValueError(f'pyenv_root: {root!r}')
 
-        dist_dir = os.path.join(self._pkg_dir(), 'dist')
+        super().__init__()
 
-        if opts.add_revision:
-            GitRevisionAdder().add_to(dist_dir)
+        self._root_kw = root
 
-        if opts.test:
-            for fn in os.listdir(dist_dir):
-                tmp_dir = tempfile.mkdtemp()
+    @cached_nullary
+    def root(self) -> ta.Optional[str]:
+        if self._root_kw is not None:
+            return self._root_kw
 
-                subprocess_check_call(
-                    sys.executable,
-                    '-m', 'venv',
-                    'test-install',
-                    cwd=tmp_dir,
-                )
+        if shutil.which('pyenv'):
+            return subprocess_check_output_str('pyenv', 'root')
 
-                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,
-                )
+        d = os.path.expanduser('~/.pyenv')
+        if os.path.isdir(d) and os.path.isfile(os.path.join(d, 'bin', 'pyenv')):
+            return d
 
-        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))
+        return None
 
+    @cached_nullary
+    def exe(self) -> str:
+        return os.path.join(check_not_none(self.root()), 'bin', 'pyenv')
 
-#
+    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
 
+    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
 
-class PyprojectPackageGenerator(BasePyprojectPackageGenerator):
+    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
 
-    #
 
-    @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()
 
-        #
+@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)
 
-        pyp_dct = {}
+    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])),
+        )
 
-        pyp_dct['build-system'] = {
-            'requires': ['setuptools'],
-            'build-backend': 'setuptools.build_meta',
-        }
 
-        prj = specs.pyproject
-        prj['name'] += self._pkg_suffix
+# 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=[
+        '--enable-loadable-sqlite-extensions',
 
-        pyp_dct['project'] = prj
+        # '--enable-shared',
 
-        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,
-            }
+        '--enable-optimizations',
+        '--with-lto',
 
-        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
+        # '--enable-profiling', # ?
 
-        if (scs := prj.pop('scripts', None)):
-            pyp_dct['project.scripts'] = scs
+        # '--enable-ipv6', # ?
+    ],
+    cflags=[
+        # '-march=native',
+        # '-mtune=native',
+    ],
+)
 
-        prj.pop('cli_scripts', None)
+DEBUG_PYENV_INSTALL_OPTS = PyenvInstallOpts(opts=['-g'])
 
-        ##
+THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
 
-        st = dict(specs.setuptools)
-        pyp_dct['tool.setuptools'] = st
 
-        st.pop('cexts', None)
+#
 
-        #
 
-        # TODO: default
-        # find_packages = {
-        #     'include': [Project.name, f'{Project.name}.*'],
-        #     'exclude': [*SetuptoolsBase.find_packages['exclude']],
-        # }
+class PyenvInstallOptsProvider(abc.ABC):
+    @abc.abstractmethod
+    def opts(self) -> PyenvInstallOpts:
+        raise NotImplementedError
 
-        fp = dict(st.pop('find_packages', {}))
 
-        pyp_dct['tool.setuptools.packages.find'] = fp
+class LinuxPyenvInstallOpts(PyenvInstallOptsProvider):
+    def opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts()
 
-        #
 
-        # TODO: default
-        # package_data = {
-        #     '*': [
-        #         '*.c',
-        #         '*.cc',
-        #         '*.h',
-        #         '.manifests.json',
-        #         'LICENSE',
-        #     ],
-        # }
+class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
 
-        pd = dict(st.pop('package_data', {}))
-        epd = dict(st.pop('exclude_package_data', {}))
+    @cached_nullary
+    def framework_opts(self) -> PyenvInstallOpts:
+        return PyenvInstallOpts(conf_opts=['--enable-framework'])
 
-        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))]
+    @cached_nullary
+    def has_brew(self) -> bool:
+        return shutil.which('brew') is not None
 
-        if pd:
-            pyp_dct['tool.setuptools.package-data'] = pd
-        if epd:
-            pyp_dct['tool.setuptools.exclude-package-data'] = epd
+    BREW_DEPS: ta.Sequence[str] = [
+        'openssl',
+        'readline',
+        'sqlite3',
+        'zlib',
+    ]
 
-        #
+    @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,
+        )
 
-        # TODO: default
-        # manifest_in = [
-        #     'global-exclude **/conftest.py',
-        # ]
+    @cached_nullary
+    def brew_tcl_opts(self) -> PyenvInstallOpts:
+        if subprocess_try_output('brew', '--prefix', 'tcl-tk') is None:
+            return PyenvInstallOpts()
 
-        mani_in = st.pop('manifest_in', None)
+        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])
 
-        #
+        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.FileContents(
-            pyp_dct,
-            mani_in,
+    # @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(),
         )
 
-    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)
+PLATFORM_PYENV_INSTALL_OPTS: ta.Dict[str, PyenvInstallOptsProvider] = {
+    'darwin': DarwinPyenvInstallOpts(),
+    'linux': LinuxPyenvInstallOpts(),
+}
 
-        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
 
-    #
+##
 
-    @cached_nullary
-    def children(self) -> ta.Sequence[BasePyprojectPackageGenerator]:
-        out: ta.List[BasePyprojectPackageGenerator] = []
 
-        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',
-            ))
+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.
+    """
 
-        return out
+    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__()
 
+        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)
 
-#
+        self._version = version
+        self._opts = opts
+        self._interp_opts = interp_opts
+        self._given_install_name = install_name
 
+        self._no_default_opts = no_default_opts
+        self._pyenv = pyenv
 
-class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
+    @property
+    def version(self) -> str:
+        return self._version
 
-    #
+    @property
+    def opts(self) -> PyenvInstallOpts:
+        return self._opts
 
     @cached_nullary
-    def find_cext_srcs(self) -> ta.Sequence[str]:
-        return sorted(find_magic_files(
-            CextMagic.STYLE,
-            [self._dir_name],
-            keys=[CextMagic.KEY],
-        ))
-
-    #
+    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 '')
 
-    @dc.dataclass(frozen=True)
-    class FileContents:
-        pyproject_dct: ta.Mapping[str, ta.Any]
-        setup_py: str
+    @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 file_contents(self) -> FileContents:
-        specs = self.build_specs()
+    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,
+        ]
 
-        pyp_dct = {}
+        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,
+            ]
 
-        pyp_dct['build-system'] = {
-            'requires': ['setuptools'],
-            'build-backend': 'setuptools.build_meta',
-        }
+        subprocess_check_call(
+            *full_args,
+            env=env,
+        )
 
-        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)
+        exe = os.path.join(self.install_dir(), 'bin', 'python')
+        if not os.path.isfile(exe):
+            raise RuntimeError(f'Interpreter not found: {exe}')
+        return exe
 
-        pyp_dct['project'] = prj
 
-        #
+##
 
-        st = dict(specs.setuptools)
-        pyp_dct['tool.setuptools'] = st
 
-        for k in [
-            'cexts',
+class PyenvInterpProvider(InterpProvider):
 
-            'find_packages',
-            'package_data',
-            'manifest_in',
-        ]:
-            st.pop(k, None)
+    def __init__(
+            self,
+            pyenv: Pyenv = Pyenv(),
 
-        pyp_dct['tool.setuptools.packages.find'] = {
-            'include': [],
-        }
+            inspect: bool = False,
+            inspector: InterpInspector = INTERP_INSPECTOR,
 
-        #
+            *,
 
-        ext_lines = []
+            try_update: bool = False,
+    ) -> None:
+        super().__init__()
 
-        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'],",
-                '),',
-            ])
+        self._pyenv = pyenv
 
-        src = '\n'.join([
-            'import setuptools as st',
-            '',
-            '',
-            'st.setup(',
-            '    ext_modules=[',
-            *['        ' + l for l in ext_lines],
-            '    ]',
-            ')',
-            '',
-        ])
+        self._inspect = inspect
+        self._inspector = inspector
 
-        #
+        self._try_update = try_update
 
-        return self.FileContents(
-            pyp_dct,
-            src,
-        )
+    #
 
-    def _write_file_contents(self) -> None:
-        fc = self.file_contents()
+    @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))
 
-        with open(os.path.join(self._pkg_dir(), 'pyproject.toml'), 'w') as f:
-            TomlWriter(f).write_root(fc.pyproject_dct)
+    class Installed(ta.NamedTuple):
+        name: str
+        exe: str
+        version: InterpVersion
 
-        with open(os.path.join(self._pkg_dir(), 'setup.py'), 'w') as f:
-            f.write(fc.setup_py)
+    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,
+        )
 
+    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
 
-##
+    #
 
+    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [i.version for i in self.installed()]
 
-class _PyprojectCliPackageGenerator(BasePyprojectPackageGenerator):
+    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)
 
     #
 
-    @dc.dataclass(frozen=True)
-    class FileContents:
-        pyproject_dct: ta.Mapping[str, ta.Any]
-
-    @cached_nullary
-    def file_contents(self) -> FileContents:
-        specs = self.build_specs()
+    def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = []
 
-        #
-
-        pyp_dct = {}
-
-        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)
-
-        pyp_dct['project'] = prj
-
-        if (scs := prj.pop('cli_scripts', None)):
-            pyp_dct['project.scripts'] = scs
-
-        #
+        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)))
 
-        st = dict(specs.setuptools)
-        pyp_dct['tool.setuptools'] = st
+        return lst
 
-        for k in [
-            'cexts',
+    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = self._get_installable_versions(spec)
 
-            'find_packages',
-            'package_data',
-            'manifest_in',
-        ]:
-            st.pop(k, 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)
 
-        pyp_dct['tool.setuptools.packages.find'] = {
-            'include': [],
-        }
+        return lst
 
-        #
+    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,
+        installer = PyenvVersionInstaller(
+            inst_version,
+            interp_opts=inst_opts,
         )
 
-    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)
+        exe = installer.install()
+        return Interp(exe, version)
 
 
 ########################################
-# ../../interp/providers.py
+# ../../interp/system.py
 """
 TODO:
- - backends
-  - local builds
-  - deadsnakes?
-  - uv
- - loose versions
+ - python, python3, python3.12, ...
+ - check if path py's are venvs: sys.prefix != sys.base_prefix
 """
 
 
 ##
 
 
-class InterpProvider(abc.ABC):
-    name: ta.ClassVar[str]
+@dc.dataclass(frozen=True)
+class SystemInterpProvider(InterpProvider):
+    cmd: str = 'python3'
+    path: ta.Optional[str] = None
 
-    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)]))
+    inspect: bool = False
+    inspector: InterpInspector = INTERP_INSPECTOR
 
-    @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
+    @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
 
-    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return []
+        if not path:
+            return []
 
-    def install_version(self, version: InterpVersion) -> Interp:
-        raise TypeError
+        path = os.fsdecode(path)
+        pathlst = path.split(os.pathsep)
 
+        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)
 
+        return out
 
-class RunningInterpProvider(InterpProvider):
     @cached_nullary
-    def version(self) -> InterpVersion:
-        return InterpInspector.running().iv
+    def exes(self) -> ta.List[str]:
+        return self._re_which(
+            re.compile(r'python3(\.\d+)?'),
+            path=self.path,
+        )
+
+    #
+
+    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
+
+    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
+
+    #
 
     def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [self.version()]
+        return [ev for e, ev in self.exe_versions()]
 
     def get_installed_version(self, version: InterpVersion) -> Interp:
-        if version != self.version():
-            raise KeyError(version)
-        return Interp(
-            exe=sys.executable,
-            version=self.version(),
-        )
+        for e, ev in self.exe_versions():
+            if ev != version:
+                continue
+            return Interp(
+                exe=e,
+                version=ev,
+            )
+        raise KeyError(version)
 
 
 ########################################
-# ../../interp/pyenv.py
+# ../pkg.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
-"""
+ - 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
 
+--
 
-##
+https://setuptools.pypa.io/en/latest/references/keywords.html
+https://packaging.python.org/en/latest/specifications/pyproject-toml
 
+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
+
+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
+
+
+#
 
-class Pyenv:
 
+class BasePyprojectPackageGenerator(abc.ABC):
     def __init__(
             self,
+            dir_name: str,
+            pkgs_root: str,
             *,
-            root: ta.Optional[str] = None,
+            pkg_suffix: str = '',
     ) -> None:
-        if root is not None and not (isinstance(root, str) and root):
-            raise ValueError(f'pyenv_root: {root!r}')
-
         super().__init__()
+        self._dir_name = dir_name
+        self._pkgs_root = pkgs_root
+        self._pkg_suffix = pkg_suffix
 
-        self._root_kw = root
+    #
 
     @cached_nullary
-    def root(self) -> ta.Optional[str]:
-        if self._root_kw is not None:
-            return self._root_kw
-
-        if shutil.which('pyenv'):
-            return subprocess_check_output_str('pyenv', 'root')
+    def about(self) -> types.ModuleType:
+        return importlib.import_module(f'{self._dir_name}.__about__')
 
-        d = os.path.expanduser('~/.pyenv')
-        if os.path.isdir(d) and os.path.isfile(os.path.join(d, 'bin', 'pyenv')):
-            return d
-
-        return None
+    #
 
     @cached_nullary
-    def exe(self) -> str:
-        return os.path.join(check_not_none(self.root()), 'bin', 'pyenv')
-
-    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
+    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 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
+    #
 
-    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
+    _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))
 
-##
+    #
 
+    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),
+        )
 
-@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)
+    #
 
-    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])),
-        )
+    @cached_nullary
+    def project_cls(self) -> type:
+        return self.about().Project
 
+    @cached_nullary
+    def setuptools_cls(self) -> type:
+        return self.about().Setuptools
 
-# 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=[
-        '--enable-loadable-sqlite-extensions',
+    @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
 
-        # '--enable-shared',
+    @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)
 
-        '--enable-optimizations',
-        '--with-lto',
+    @dc.dataclass(frozen=True)
+    class Specs:
+        pyproject: ta.Dict[str, ta.Any]
+        setuptools: ta.Dict[str, ta.Any]
 
-        # '--enable-profiling', # ?
+    def build_specs(self) -> Specs:
+        return self.Specs(
+            self._build_cls_dct(self.project_cls()),
+            self._build_cls_dct(self.setuptools_cls()),
+        )
 
-        # '--enable-ipv6', # ?
-    ],
-    cflags=[
-        # '-march=native',
-        # '-mtune=native',
-    ],
-)
+    #
 
-DEBUG_PYENV_INSTALL_OPTS = PyenvInstallOpts(opts=['-g'])
+    class _PkgData(ta.NamedTuple):
+        inc: ta.List[str]
+        exc: ta.List[str]
 
-THREADED_PYENV_INSTALL_OPTS = PyenvInstallOpts(conf_opts=['--disable-gil'])
+    @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))
 
-#
+        return self._PkgData(inc, exc)
 
+    #
 
-class PyenvInstallOptsProvider(abc.ABC):
     @abc.abstractmethod
-    def opts(self) -> PyenvInstallOpts:
+    def _write_file_contents(self) -> None:
         raise NotImplementedError
 
+    #
 
-class LinuxPyenvInstallOpts(PyenvInstallOptsProvider):
-    def opts(self) -> PyenvInstallOpts:
-        return PyenvInstallOpts()
-
+    _STANDARD_FILES: ta.Sequence[str] = [
+        'LICENSE',
+        'README.rst',
+    ]
 
-class DarwinPyenvInstallOpts(PyenvInstallOptsProvider):
+    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))
 
-    @cached_nullary
-    def framework_opts(self) -> PyenvInstallOpts:
-        return PyenvInstallOpts(conf_opts=['--enable-framework'])
+    #
 
-    @cached_nullary
-    def has_brew(self) -> bool:
-        return shutil.which('brew') is not None
+    def children(self) -> ta.Sequence['BasePyprojectPackageGenerator']:
+        return []
 
-    BREW_DEPS: ta.Sequence[str] = [
-        'openssl',
-        'readline',
-        'sqlite3',
-        'zlib',
-    ]
+    #
 
-    @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,
-        )
+    def gen(self) -> str:
+        log.info('Generating pyproject package: %s -> %s (%s)', self._dir_name, self._pkgs_root, self._pkg_suffix)
 
-    @cached_nullary
-    def brew_tcl_opts(self) -> PyenvInstallOpts:
-        if subprocess_try_output('brew', '--prefix', 'tcl-tk') is None:
-            return PyenvInstallOpts()
+        self._pkg_dir()
+        self._write_git_ignore()
+        self._symlink_source_dir()
+        self._write_file_contents()
+        self._symlink_standard_files()
 
-        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])
+        return self._pkg_dir()
 
-        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})
+    @dc.dataclass(frozen=True)
+    class BuildOpts:
+        add_revision: bool = False
+        test: bool = False
 
-    def opts(self) -> PyenvInstallOpts:
-        return PyenvInstallOpts().merge(
-            self.framework_opts(),
-            self.brew_deps_opts(),
-            self.brew_tcl_opts(),
-            # self.brew_ssl_opts(),
+    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')
 
-PLATFORM_PYENV_INSTALL_OPTS: ta.Dict[str, PyenvInstallOptsProvider] = {
-    'darwin': DarwinPyenvInstallOpts(),
-    'linux': LinuxPyenvInstallOpts(),
-}
+        if opts.add_revision:
+            GitRevisionAdder().add_to(dist_dir)
 
+        if opts.test:
+            for fn in os.listdir(dist_dir):
+                tmp_dir = tempfile.mkdtemp()
 
-##
+                subprocess_check_call(
+                    sys.executable,
+                    '-m', 'venv',
+                    'test-install',
+                    cwd=tmp_dir,
+                )
 
+                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,
+                )
 
-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 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))
 
-    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__()
 
-        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)
+#
 
-        self._version = version
-        self._opts = opts
-        self._interp_opts = interp_opts
-        self._given_install_name = install_name
 
-        self._no_default_opts = no_default_opts
-        self._pyenv = pyenv
+class PyprojectPackageGenerator(BasePyprojectPackageGenerator):
 
-    @property
-    def version(self) -> str:
-        return self._version
+    #
 
-    @property
-    def opts(self) -> PyenvInstallOpts:
-        return self._opts
+    @dc.dataclass(frozen=True)
+    class FileContents:
+        pyproject_dct: ta.Mapping[str, ta.Any]
+        manifest_in: ta.Optional[ta.Sequence[str]]
 
     @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 file_contents(self) -> FileContents:
+        specs = self.build_specs()
 
-    @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
+        pyp_dct = {}
 
-        conf_args = [
-            *self._opts.opts,
-            self._version,
-        ]
+        pyp_dct['build-system'] = {
+            'requires': ['setuptools'],
+            'build-backend': 'setuptools.build_meta',
+        }
 
-        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,
-            ]
+        prj = specs.pyproject
+        prj['name'] += self._pkg_suffix
 
-        subprocess_check_call(
-            *full_args,
-            env=env,
-        )
+        pyp_dct['project'] = prj
 
-        exe = os.path.join(self.install_dir(), 'bin', 'python')
-        if not os.path.isfile(exe):
-            raise RuntimeError(f'Interpreter not found: {exe}')
-        return exe
+        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,
+            }
 
+        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
 
-##
+        if (scs := prj.pop('scripts', None)):
+            pyp_dct['project.scripts'] = scs
 
+        prj.pop('cli_scripts', None)
 
-class PyenvInterpProvider(InterpProvider):
+        ##
 
-    def __init__(
-            self,
-            pyenv: Pyenv = Pyenv(),
+        st = dict(specs.setuptools)
+        pyp_dct['tool.setuptools'] = st
 
-            inspect: bool = False,
-            inspector: InterpInspector = INTERP_INSPECTOR,
+        st.pop('cexts', None)
 
-            *,
+        #
 
-            try_update: bool = False,
-    ) -> None:
-        super().__init__()
+        # TODO: default
+        # find_packages = {
+        #     'include': [Project.name, f'{Project.name}.*'],
+        #     'exclude': [*SetuptoolsBase.find_packages['exclude']],
+        # }
 
-        self._pyenv = pyenv
+        fp = dict(st.pop('find_packages', {}))
 
-        self._inspect = inspect
-        self._inspector = inspector
+        pyp_dct['tool.setuptools.packages.find'] = fp
 
-        self._try_update = try_update
+        #
 
-    #
+        # TODO: default
+        # package_data = {
+        #     '*': [
+        #         '*.c',
+        #         '*.cc',
+        #         '*.h',
+        #         '.manifests.json',
+        #         'LICENSE',
+        #     ],
+        # }
 
-    @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))
+        pd = dict(st.pop('package_data', {}))
+        epd = dict(st.pop('exclude_package_data', {}))
 
-    class Installed(ta.NamedTuple):
-        name: str
-        exe: str
-        version: InterpVersion
+        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))]
 
-    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,
-        )
+        if pd:
+            pyp_dct['tool.setuptools.package-data'] = pd
+        if epd:
+            pyp_dct['tool.setuptools.exclude-package-data'] = epd
 
-    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
+        #
 
-    #
+        # TODO: default
+        # manifest_in = [
+        #     'global-exclude **/conftest.py',
+        # ]
 
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [i.version for i in self.installed()]
+        mani_in = st.pop('manifest_in', None)
 
-    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)
+        #
 
-    #
+        return self.FileContents(
+            pyp_dct,
+            mani_in,
+        )
 
-    def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = []
+    def _write_file_contents(self) -> None:
+        fc = self.file_contents()
 
-        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)))
+        with open(os.path.join(self._pkg_dir(), 'pyproject.toml'), 'w') as f:
+            TomlWriter(f).write_root(fc.pyproject_dct)
 
-        return lst
+        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
 
-    def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = self._get_installable_versions(spec)
+    #
 
-        if self._try_update and not any(v in spec for v in lst):
-            if self._pyenv.update():
-                lst = self._get_installable_versions(spec)
+    @cached_nullary
+    def children(self) -> ta.Sequence[BasePyprojectPackageGenerator]:
+        out: ta.List[BasePyprojectPackageGenerator] = []
 
-        return lst
+        if self.build_specs().setuptools.get('cexts'):
+            out.append(_PyprojectCextPackageGenerator(
+                self._dir_name,
+                self._pkgs_root,
+                pkg_suffix='-cext',
+            ))
 
-    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)
+        if self.build_specs().pyproject.get('cli_scripts'):
+            out.append(_PyprojectCliPackageGenerator(
+                self._dir_name,
+                self._pkgs_root,
+                pkg_suffix='-cli',
+            ))
 
-        installer = PyenvVersionInstaller(
-            inst_version,
-            interp_opts=inst_opts,
-        )
+        return out
 
-        exe = installer.install()
-        return Interp(exe, version)
 
+#
 
-########################################
-# ../../interp/system.py
-"""
-TODO:
- - python, python3, python3.12, ...
- - check if path py's are venvs: sys.prefix != sys.base_prefix
-"""
 
+class _PyprojectCextPackageGenerator(BasePyprojectPackageGenerator):
 
-##
+    #
 
+    @cached_nullary
+    def find_cext_srcs(self) -> ta.Sequence[str]:
+        return sorted(find_magic_files(
+            CextMagic.STYLE,
+            [self._dir_name],
+            keys=[CextMagic.KEY],
+        ))
 
-@dc.dataclass(frozen=True)
-class SystemInterpProvider(InterpProvider):
-    cmd: str = 'python3'
-    path: ta.Optional[str] = None
+    #
 
-    inspect: bool = False
-    inspector: InterpInspector = INTERP_INSPECTOR
+    @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()
 
-    @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
+        #
 
-        if not path:
-            return []
+        pyp_dct = {}
 
-        path = os.fsdecode(path)
-        pathlst = path.split(os.pathsep)
+        pyp_dct['build-system'] = {
+            'requires': ['setuptools'],
+            'build-backend': 'setuptools.build_meta',
+        }
 
-        def _access_check(fn: str, mode: int) -> bool:
-            return os.path.exists(fn) and os.access(fn, mode)
+        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)
 
-        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)
+        pyp_dct['project'] = prj
 
-        return out
+        #
 
-    @cached_nullary
-    def exes(self) -> ta.List[str]:
-        return self._re_which(
-            re.compile(r'python3(\.\d+)?'),
-            path=self.path,
+        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': [],
+        }
+
+        #
+
+        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'],",
+                '),',
+            ])
+
+        src = '\n'.join([
+            'import setuptools as st',
+            '',
+            '',
+            'st.setup(',
+            '    ext_modules=[',
+            *['        ' + l for l in ext_lines],
+            '    ]',
+            ')',
+            '',
+        ])
+
+        #
+
+        return self.FileContents(
+            pyp_dct,
+            src,
         )
 
-    #
+    def _write_file_contents(self) -> None:
+        fc = self.file_contents()
 
-    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
+        with open(os.path.join(self._pkg_dir(), 'pyproject.toml'), 'w') as f:
+            TomlWriter(f).write_root(fc.pyproject_dct)
 
-    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
+        with open(os.path.join(self._pkg_dir(), 'setup.py'), 'w') as f:
+            f.write(fc.setup_py)
+
+
+##
+
+
+class _PyprojectCliPackageGenerator(BasePyprojectPackageGenerator):
 
     #
 
-    def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [ev for e, ev in self.exe_versions()]
+    @dc.dataclass(frozen=True)
+    class FileContents:
+        pyproject_dct: ta.Mapping[str, ta.Any]
 
-    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)
+    @cached_nullary
+    def file_contents(self) -> FileContents:
+        specs = self.build_specs()
+
+        #
+
+        pyp_dct = {}
+
+        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)
+
+        pyp_dct['project'] = prj
+
+        if (scs := prj.pop('cli_scripts', None)):
+            pyp_dct['project.scripts'] = scs
+
+        #
+
+        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': [],
+        }
+
+        #
+
+        return self.FileContents(
+            pyp_dct,
+        )
+
+    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)
 
 
 ########################################