omdev 0.0.0.dev180__py3-none-any.whl → 0.0.0.dev182__py3-none-any.whl

omdev/scripts/pyproject.py

@@ -66,7 +66,7 @@ import time
 import types
 import typing as ta
 import uuid
-import weakref  # noqa
+import weakref
 import zipfile
 
 
@@ -108,6 +108,11 @@ CheckOnRaiseFn = ta.Callable[[Exception], None]  # ta.TypeAlias
 CheckExceptionFactory = ta.Callable[..., Exception]  # ta.TypeAlias
 CheckArgsRenderer = ta.Callable[..., ta.Optional[str]]  # ta.TypeAlias
 
+# ../../omlish/lite/typing.py
+A0 = ta.TypeVar('A0')
+A1 = ta.TypeVar('A1')
+A2 = ta.TypeVar('A2')
+
 # ../packaging/specifiers.py
 UnparsedVersion = ta.Union['Version', str]
 UnparsedVersionVar = ta.TypeVar('UnparsedVersionVar', bound=UnparsedVersion)
@@ -2575,6 +2580,54 @@ def format_num_bytes(num_bytes: int) -> str:
     return f'{num_bytes / 1024 ** (len(FORMAT_NUM_BYTES_SUFFIXES) - 1):.2f}{FORMAT_NUM_BYTES_SUFFIXES[-1]}'
 
 
+########################################
+# ../../../omlish/lite/typing.py
+
+
+##
+# A workaround for typing deficiencies (like `Argument 2 to NewType(...) must be subclassable`).
+
+
+@dc.dataclass(frozen=True)
+class AnyFunc(ta.Generic[T]):
+    fn: ta.Callable[..., T]
+
+    def __call__(self, *args: ta.Any, **kwargs: ta.Any) -> T:
+        return self.fn(*args, **kwargs)
+
+
+@dc.dataclass(frozen=True)
+class Func0(ta.Generic[T]):
+    fn: ta.Callable[[], T]
+
+    def __call__(self) -> T:
+        return self.fn()
+
+
+@dc.dataclass(frozen=True)
+class Func1(ta.Generic[A0, T]):
+    fn: ta.Callable[[A0], T]
+
+    def __call__(self, a0: A0) -> T:
+        return self.fn(a0)
+
+
+@dc.dataclass(frozen=True)
+class Func2(ta.Generic[A0, A1, T]):
+    fn: ta.Callable[[A0, A1], T]
+
+    def __call__(self, a0: A0, a1: A1) -> T:
+        return self.fn(a0, a1)
+
+
+@dc.dataclass(frozen=True)
+class Func3(ta.Generic[A0, A1, A2, T]):
+    fn: ta.Callable[[A0, A1, A2], T]
+
+    def __call__(self, a0: A0, a1: A1, a2: A2) -> T:
+        return self.fn(a0, a1, a2)
+
+
 ########################################
 # ../../../omlish/logs/filters.py
 
@@ -5547,104 +5600,6 @@ def bind_interp_uv() -> InjectorBindings:
     return inj.as_bindings(*lst)
 
 
-########################################
-# ../configs.py
-
-
-@dc.dataclass(frozen=True)
-class VenvConfig:
-    inherits: ta.Optional[ta.Sequence[str]] = None
-    interp: ta.Optional[str] = None
-    requires: ta.Optional[ta.List[str]] = None
-    docker: ta.Optional[str] = None
-    srcs: ta.Optional[ta.List[str]] = None
-    use_uv: ta.Optional[bool] = None
-
-
-@dc.dataclass(frozen=True)
-class PyprojectConfig:
-    pkgs: ta.Sequence[str] = dc.field(default_factory=list)
-    srcs: ta.Mapping[str, ta.Sequence[str]] = dc.field(default_factory=dict)
-    venvs: ta.Mapping[str, VenvConfig] = dc.field(default_factory=dict)
-
-    venvs_dir: str = '.venvs'
-    versions_file: ta.Optional[str] = '.versions'
-
-
-class PyprojectConfigPreparer:
-    def __init__(
-            self,
-            *,
-            python_versions: ta.Optional[ta.Mapping[str, str]] = None,
-    ) -> None:
-        super().__init__()
-
-        self._python_versions = python_versions or {}
-
-    def _inherit_venvs(self, m: ta.Mapping[str, VenvConfig]) -> ta.Mapping[str, VenvConfig]:
-        done: ta.Dict[str, VenvConfig] = {}
-
-        def rec(k):
-            try:
-                return done[k]
-            except KeyError:
-                pass
-
-            c = m[k]
-            kw = dc.asdict(c)
-            for i in c.inherits or ():
-                ic = rec(i)
-                kw.update({k: v for k, v in dc.asdict(ic).items() if v is not None and kw.get(k) is None})
-            del kw['inherits']
-
-            d = done[k] = VenvConfig(**kw)
-            return d
-
-        for k in m:
-            rec(k)
-        return done
-
-    def _resolve_srcs(
-            self,
-            lst: ta.Sequence[str],
-            aliases: ta.Mapping[str, ta.Sequence[str]],
-    ) -> ta.List[str]:
-        todo = list(reversed(lst))
-        raw: ta.List[str] = []
-        seen: ta.Set[str] = set()
-
-        while todo:
-            cur = todo.pop()
-            if cur in seen:
-                continue
-
-            seen.add(cur)
-            if not cur.startswith('@'):
-                raw.append(cur)
-                continue
-
-            todo.extend(aliases[cur[1:]][::-1])
-
-        return raw
-
-    def _fixup_interp(self, s: ta.Optional[str]) -> ta.Optional[str]:
-        if not s or not s.startswith('@'):
-            return s
-        return self._python_versions[s[1:]]
-
-    def prepare_config(self, dct: ta.Mapping[str, ta.Any]) -> PyprojectConfig:
-        pcfg: PyprojectConfig = unmarshal_obj(dct, PyprojectConfig)
-
-        ivs = dict(self._inherit_venvs(pcfg.venvs or {}))
-        for k, v in ivs.items():
-            v = dc.replace(v, srcs=self._resolve_srcs(v.srcs or [], pcfg.srcs or {}))
-            v = dc.replace(v, interp=self._fixup_interp(v.interp))
-            ivs[k] = v
-
-        pcfg = dc.replace(pcfg, venvs=ivs)
-        return pcfg
-
-
 ########################################
 # ../../../omlish/logs/standard.py
 """
@@ -6443,9 +6398,15 @@ class InterpInspection:
 
 
 class InterpInspector:
-    def __init__(self) -> None:
+    def __init__(
+            self,
+            *,
+            log: ta.Optional[logging.Logger] = None,
+    ) -> None:
         super().__init__()
 
+        self._log = log
+
         self._cache: ta.Dict[str, ta.Optional[InterpInspection]] = {}
 
     _RAW_INSPECTION_CODE = """
@@ -6494,13 +6455,95 @@ class InterpInspector:
             try:
                 ret = await self._inspect(exe)
             except Exception as e:  # noqa
-                if log.isEnabledFor(logging.DEBUG):
-                    log.exception('Failed to inspect interp: %s', exe)
+                if self._log is not None and self._log.isEnabledFor(logging.DEBUG):
+                    self._log.exception('Failed to inspect interp: %s', exe)
                 ret = None
             self._cache[exe] = ret
             return ret
 
 
+########################################
+# ../../interp/pyenv/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
+"""
+
+
+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}')
+
+        super().__init__()
+
+        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
+
+        if shutil.which('pyenv'):
+            return await asyncio_subprocesses.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
+
+        return None
+
+    @async_cached_nullary
+    async def exe(self) -> str:
+        return os.path.join(check.not_none(await self.root()), 'bin', 'pyenv')
+
+    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_subprocesses.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
+
+    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_subprocesses.check_call('git', 'pull', cwd=root)
+        return True
+
+
 ########################################
 # ../../interp/resolvers.py
 
@@ -6755,12 +6798,14 @@ class SystemInterpProvider(InterpProvider):
             options: Options = Options(),
             *,
             inspector: ta.Optional[InterpInspector] = None,
+            log: ta.Optional[logging.Logger] = None,
     ) -> None:
         super().__init__()
 
         self._options = options
 
         self._inspector = inspector
+        self._log = log
 
     #
 
@@ -6834,7 +6879,8 @@ class SystemInterpProvider(InterpProvider):
         lst = []
         for e in self.exes():
             if (ev := await self.get_exe_version(e)) is None:
-                log.debug('Invalid system version: %s', e)
+                if self._log is not None:
+                    self._log.debug('Invalid system version: %s', e)
                 continue
             lst.append((e, ev))
         return lst
@@ -6856,109 +6902,28 @@ class SystemInterpProvider(InterpProvider):
 
 
 ########################################
-# ../../interp/pyenv/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
-"""
+# ../../interp/pyenv/install.py
 
 
 ##
 
 
-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}')
+@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)
 
-        super().__init__()
-
-        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
-
-        if shutil.which('pyenv'):
-            return await asyncio_subprocesses.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
-
-        return None
-
-    @async_cached_nullary
-    async def exe(self) -> str:
-        return os.path.join(check.not_none(await self.root()), 'bin', 'pyenv')
-
-    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_subprocesses.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
-
-    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_subprocesses.check_call('git', 'pull', cwd=root)
-        return True
-
-
-##
-
-
-@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])),
-        )
+    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])),
+        )
 
 
 # TODO: https://github.com/pyenv/pyenv/blob/master/plugins/python-build/README.md#building-for-maximum-performance
@@ -7175,133 +7140,6 @@ class PyenvVersionInstaller:
         return exe
 
 
-##
-
-
-class PyenvInterpProvider(InterpProvider):
-    @dc.dataclass(frozen=True)
-    class Options:
-        inspect: bool = False
-
-        try_update: bool = False
-
-    def __init__(
-            self,
-            options: Options = Options(),
-            *,
-            pyenv: Pyenv,
-            inspector: InterpInspector,
-    ) -> None:
-        super().__init__()
-
-        self._options = options
-
-        self._pyenv = pyenv
-        self._inspector = inspector
-
-    #
-
-    @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))
-
-    class Installed(ta.NamedTuple):
-        name: str
-        exe: str
-        version: InterpVersion
-
-    async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
-        iv: ta.Optional[InterpVersion]
-        if self._options.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,
-        )
-
-    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
-
-    #
-
-    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        return [i.version for i in await self.installed()]
-
-    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)
-
-    #
-
-    async def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = []
-
-        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
-
-    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
-        lst = await self._get_installable_versions(spec)
-
-        if self._options.try_update and not any(v in spec for v in lst):
-            if self._pyenv.update():
-                lst = await self._get_installable_versions(spec)
-
-        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)
-
-        installer = PyenvVersionInstaller(
-            inst_version,
-            interp_opts=inst_opts,
-            pyenv=self._pyenv,
-        )
-
-        exe = await installer.install()
-        return Interp(exe, version)
-
-
 ########################################
 # ../pkg.py
 """
@@ -7879,6 +7717,137 @@ def bind_interp_providers() -> InjectorBindings:
     return inj.as_bindings(*lst)
 
 
+########################################
+# ../../interp/pyenv/provider.py
+
+
+class PyenvInterpProvider(InterpProvider):
+    @dc.dataclass(frozen=True)
+    class Options:
+        inspect: bool = False
+
+        try_update: bool = False
+
+    def __init__(
+            self,
+            options: Options = Options(),
+            *,
+            pyenv: Pyenv,
+            inspector: InterpInspector,
+            log: ta.Optional[logging.Logger] = None,
+    ) -> None:
+        super().__init__()
+
+        self._options = options
+
+        self._pyenv = pyenv
+        self._inspector = inspector
+        self._log = log
+
+    #
+
+    @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))
+
+    class Installed(ta.NamedTuple):
+        name: str
+        exe: str
+        version: InterpVersion
+
+    async def _make_installed(self, vn: str, ep: str) -> ta.Optional[Installed]:
+        iv: ta.Optional[InterpVersion]
+        if self._options.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,
+        )
+
+    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:
+                if self._log is not None:
+                    self._log.debug('Invalid pyenv version: %s', vn)
+                continue
+            ret.append(i)
+        return ret
+
+    #
+
+    async def get_installed_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        return [i.version for i in await self.installed()]
+
+    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)
+
+    #
+
+    async def _get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = []
+
+        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
+
+    async def get_installable_versions(self, spec: InterpSpecifier) -> ta.Sequence[InterpVersion]:
+        lst = await self._get_installable_versions(spec)
+
+        if self._options.try_update and not any(v in spec for v in lst):
+            if self._pyenv.update():
+                lst = await self._get_installable_versions(spec)
+
+        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)
+
+        installer = PyenvVersionInstaller(
+            inst_version,
+            interp_opts=inst_opts,
+            pyenv=self._pyenv,
+        )
+
+        exe = await installer.install()
+        return Interp(exe, version)
+
+
 ########################################
 # ../../interp/pyenv/inject.py
 
@@ -7945,31 +7914,47 @@ def get_default_interp_resolver() -> InterpResolver:
 
 
 ########################################
-# ../venvs.py
+# ../../interp/venvs.py
 
 
 ##
 
 
-class Venv:
+@dc.dataclass(frozen=True)
+class InterpVenvConfig:
+    interp: ta.Optional[str] = None
+    requires: ta.Optional[ta.Sequence[str]] = None
+    use_uv: ta.Optional[bool] = None
+
+
+class InterpVenvRequirementsProcessor(Func2['InterpVenv', ta.Sequence[str], ta.Sequence[str]]):
+    pass
+
+
+class InterpVenv:
     def __init__(
             self,
-            name: str,
-            cfg: VenvConfig,
+            path: str,
+            cfg: InterpVenvConfig,
+            *,
+            requirements_processor: ta.Optional[InterpVenvRequirementsProcessor] = None,
+            log: ta.Optional[logging.Logger] = None,
     ) -> None:
         super().__init__()
-        self._name = name
+
+        self._path = path
         self._cfg = cfg
 
-    @property
-    def cfg(self) -> VenvConfig:
-        return self._cfg
+        self._requirements_processor = requirements_processor
+        self._log = log
 
-    DIR_NAME = '.venvs'
+    @property
+    def path(self) -> str:
+        return self._path
 
     @property
-    def dir_name(self) -> str:
-        return os.path.join(self.DIR_NAME, self._name)
+    def cfg(self) -> InterpVenvConfig:
+        return self._cfg
 
     @async_cached_nullary
     async def interp_exe(self) -> str:
@@ -7978,19 +7963,23 @@ class Venv:
 
     @cached_nullary
     def exe(self) -> str:
-        ve = os.path.join(self.dir_name, 'bin/python')
+        ve = os.path.join(self._path, 'bin/python')
         if not os.path.isfile(ve):
             raise Exception(f'venv exe {ve} does not exist or is not a file!')
         return ve
 
     @async_cached_nullary
     async def create(self) -> bool:
-        if os.path.exists(dn := self.dir_name):
+        if os.path.exists(dn := self._path):
             if not os.path.isdir(dn):
                 raise Exception(f'{dn} exists but is not a directory!')
             return False
 
-        log.info('Using interpreter %s', (ie := await self.interp_exe()))
+        ie = await self.interp_exe()
+
+        if self._log is not None:
+            self._log.info('Using interpreter %s', ie)
+
         await asyncio_subprocesses.check_call(ie, '-m', 'venv', dn)
 
         ve = self.exe()
@@ -8007,8 +7996,9 @@ class Venv:
         )
 
         if sr := self._cfg.requires:
-            rr = RequirementsRewriter(self._name)
-            reqs = [rr.rewrite(req) for req in sr]
+            reqs = list(sr)
+            if self._requirements_processor is not None:
+                reqs = list(self._requirements_processor(self, reqs))
 
             # TODO: automatically try slower uv download when it fails? lol
             #   Caused by: Failed to download distribution due to network timeout. Try increasing UV_HTTP_TIMEOUT (current value: 30s).  # noqa
@@ -8026,6 +8016,150 @@ class Venv:
 
         return True
 
+
+########################################
+# ../configs.py
+
+
+@dc.dataclass(frozen=True)
+class VenvConfig(InterpVenvConfig):
+    inherits: ta.Optional[ta.Sequence[str]] = None
+    docker: ta.Optional[str] = None
+    srcs: ta.Optional[ta.List[str]] = None
+
+
+@dc.dataclass(frozen=True)
+class PyprojectConfig:
+    pkgs: ta.Sequence[str] = dc.field(default_factory=list)
+    srcs: ta.Mapping[str, ta.Sequence[str]] = dc.field(default_factory=dict)
+    venvs: ta.Mapping[str, VenvConfig] = dc.field(default_factory=dict)
+
+    venvs_dir: str = '.venvs'
+    versions_file: ta.Optional[str] = '.versions'
+
+
+class PyprojectConfigPreparer:
+    def __init__(
+            self,
+            *,
+            python_versions: ta.Optional[ta.Mapping[str, str]] = None,
+    ) -> None:
+        super().__init__()
+
+        self._python_versions = python_versions or {}
+
+    def _inherit_venvs(self, m: ta.Mapping[str, VenvConfig]) -> ta.Mapping[str, VenvConfig]:
+        done: ta.Dict[str, VenvConfig] = {}
+
+        def rec(k):
+            try:
+                return done[k]
+            except KeyError:
+                pass
+
+            c = m[k]
+            kw = dc.asdict(c)
+            for i in c.inherits or ():
+                ic = rec(i)
+                kw.update({k: v for k, v in dc.asdict(ic).items() if v is not None and kw.get(k) is None})
+            del kw['inherits']
+
+            d = done[k] = VenvConfig(**kw)
+            return d
+
+        for k in m:
+            rec(k)
+        return done
+
+    def _resolve_srcs(
+            self,
+            lst: ta.Sequence[str],
+            aliases: ta.Mapping[str, ta.Sequence[str]],
+    ) -> ta.List[str]:
+        todo = list(reversed(lst))
+        raw: ta.List[str] = []
+        seen: ta.Set[str] = set()
+
+        while todo:
+            cur = todo.pop()
+            if cur in seen:
+                continue
+
+            seen.add(cur)
+            if not cur.startswith('@'):
+                raw.append(cur)
+                continue
+
+            todo.extend(aliases[cur[1:]][::-1])
+
+        return raw
+
+    def _fixup_interp(self, s: ta.Optional[str]) -> ta.Optional[str]:
+        if not s or not s.startswith('@'):
+            return s
+        return self._python_versions[s[1:]]
+
+    def prepare_config(self, dct: ta.Mapping[str, ta.Any]) -> PyprojectConfig:
+        pcfg: PyprojectConfig = unmarshal_obj(dct, PyprojectConfig)
+
+        ivs = dict(self._inherit_venvs(pcfg.venvs or {}))
+        for k, v in ivs.items():
+            v = dc.replace(v, srcs=self._resolve_srcs(v.srcs or [], pcfg.srcs or {}))
+            v = dc.replace(v, interp=self._fixup_interp(v.interp))
+            ivs[k] = v
+
+        pcfg = dc.replace(pcfg, venvs=ivs)
+        return pcfg
+
+
+########################################
+# ../venvs.py
+
+
+##
+
+
+class Venv:
+    def __init__(
+            self,
+            name: str,
+            cfg: VenvConfig,
+    ) -> None:
+        super().__init__()
+        self._name = name
+        self._cfg = cfg
+
+    @property
+    def cfg(self) -> VenvConfig:
+        return self._cfg
+
+    DIR_NAME = '.venvs'
+
+    @property
+    def dir_name(self) -> str:
+        return os.path.join(self.DIR_NAME, self._name)
+
+    @cached_nullary
+    def _iv(self) -> InterpVenv:
+        rr = RequirementsRewriter(self._name)
+
+        return InterpVenv(
+            self.dir_name,
+            self._cfg,
+            requirements_processor=InterpVenvRequirementsProcessor(
+                lambda iv, reqs: [rr.rewrite(req) for req in reqs]  # noqa
+            ),
+            log=log,
+        )
+
+    @cached_nullary
+    def exe(self) -> str:
+        return self._iv().exe()
+
+    @async_cached_nullary
+    async def create(self) -> bool:
+        return await self._iv().create()
+
     @staticmethod
     def _resolve_srcs(raw: ta.List[str]) -> ta.List[str]:
         out: list[str] = []