ENH: add support for editable installs

Signed-off-by: Filipe Laíns <[email protected]>

Author: FFY00

mesonpy/__init__.py

@@ -918,6 +918,9 @@ def wheel(self, directory: Path) -> pathlib.Path:  # noqa: F811
         shutil.move(os.fspath(wheel), final_wheel)
         return final_wheel
 
+    def editable(self, directory: Path) -> pathlib.Path:
+        raise NotImplementedError
+
 
 @contextlib.contextmanager
 def _project(config_settings: Optional[Dict[Any, Any]]) -> Iterator[Project]:
@@ -1054,3 +1057,21 @@ def build_wheel(
     out = pathlib.Path(wheel_directory)
     with _project(config_settings) as project:
         return project.wheel(out).name
+
+
+def build_editable(
+    wheel_directory: str,
+    config_settings: Optional[Dict[Any, Any]] = None,
+    metadata_directory: Optional[str] = None,
+) -> str:
+    _setup_cli()
+
+    out = pathlib.Path(wheel_directory)
+    with _project(config_settings) as project:
+        return project.editable(out).name
+
+
+def get_requires_for_build_editable(
+    config_settings: Optional[Dict[str, str]] = None,
+) -> List[str]:
+    return get_requires_for_build_wheel()

mesonpy/_editable.py

@@ -0,0 +1,156 @@
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import io
+import itertools
+import os
+import pathlib
+import sys
+
+from types import ModuleType
+from typing import Optional, Union
+
+from mesonpy._compat import Iterator, Sequence
+
+
+if sys.version_info >= (3, 11):
+    import importlib.resources.abc as resources_abc
+elif sys.version_info >= (3, 9):
+    import importlib.abc as resources_abc
+else:
+    import importlib_resources.abc as resources_abc
+
+
+StrPath = Union[str, os.PathLike[str]]
+
+
+class Editable:
+    def __init__(self, source_dir: str) -> None:
+        self._source_dir = source_dir
+
+    @property
+    def source_dir(self) -> str:
+        return self._source_dir
+
+
+class EditablePath(resources_abc.Traversable):  # type: ignore[misc]
+    def __init__(self, project: Editable) -> None:
+        self._project = project
+
+    def iterdir(self) -> Iterator[resources_abc.Traversable]:
+        raise NotImplementedError
+
+    def is_dir(self) -> bool:
+        raise NotImplementedError
+
+    def is_file(self) -> bool:
+        raise NotImplementedError
+
+    def open(
+        self,
+        mode: str = 'r',
+        buffering: int = ...,
+        encoding: Optional[str] = ...,
+        errors: Optional[str] = ...,
+        newline: Optional[str] = ...,
+    ) -> io.TextIOWrapper:
+        raise NotImplementedError
+
+    def name(self) -> str:
+        raise NotImplementedError
+
+    # backport from 3.10
+
+    def read_bytes(self) -> bytes:
+        """
+        Read contents of self as bytes
+        """
+        with self.open('rb') as strm:
+            return strm.read()  # type: ignore[return-value]
+
+    def read_text(self, encoding: Optional[str] = None) -> str:
+        """
+        Read contents of self as text
+        """
+        with self.open(encoding=encoding) as strm:
+            return strm.read()
+
+    def __truediv__(self, child: StrPath) -> resources_abc.Traversable:
+        """
+        Return Traversable child in self
+        """
+        return self.joinpath(child)
+
+    # backport from 3.12
+
+    def joinpath(self, *descendants: StrPath) -> resources_abc.Traversable:
+        if not descendants:
+            return self
+        names = itertools.chain.from_iterable(
+            path.parts for path in map(pathlib.PurePosixPath, descendants)
+        )
+        target = next(names)
+        matches = (
+            traversable
+            for traversable in self.iterdir()
+            if traversable.name == target
+        )
+        try:
+            match = next(matches)
+        except StopIteration:
+            raise ImportError(
+                'Target not found during traversal.', target, list(names)
+            )
+        return match.joinpath(*names)
+
+
+class EditableReader(resources_abc.TraversableResources):  # type: ignore[misc]
+    def __init__(self, path: EditablePath) -> None:
+        self._path = path
+
+    def files(self) -> resources_abc.Traversable:
+        return self._path
+
+
+class EditableLoader(importlib.machinery.SourceFileLoader):
+    def __init__(self, fullname: str, path: EditablePath) -> None:
+        super().__init__(fullname, fullname)
+        self._fullname = fullname
+        self._path = path
+
+    def __repr__(self) -> str:
+        return f'{self.__class__}({self._path})'
+
+    def get_data(self, path: Union[str, bytes]) -> bytes:
+        if path != self._fullname:
+            raise ImportError(f'Requesting data from unexpected path `{path!r}` in {self}')
+        return self._path.read_bytes()
+
+    def get_resource_reader(self) -> importlib.abc.ResourceReader:
+        return EditableReader(self._path)
+
+
+class MesonpyFinder(importlib.abc.MetaPathFinder):  # remove instantiation?
+    def __init__(self, editable: Editable) -> None:
+        self._editable = editable
+        self._base_path = EditablePath(self._editable)
+
+    def __repr__(self) -> str:
+        return f'{self.__class__}({self._editable})'
+
+    def find_spec(
+        self,
+        fullname: str,
+        path: Optional[Sequence[Union[str, bytes]]],
+        target: Optional[ModuleType] = None,
+    ) -> Optional[importlib.machinery.ModuleSpec]:
+        if not fullname.startswith('aaaa'):
+            return None
+        spec_path = self._base_path.joinpath(*fullname.split('.'))
+        return importlib.util.spec_from_loader(fullname, EditableLoader(fullname, spec_path))
+
+
+def install(path: str) -> None:
+    editable = Editable(os.path.abspath(path))
+    sys.meta_path.append(MesonpyFinder(editable))
+    print('mesonpy import hook installed')