implement rest of HatchlingProject

Author: thrau

plux/build/discovery.py

@@ -85,6 +85,8 @@ class SimplePackageFinder(PackageFinder):
     everything in the preceding path that's not a package.
     """
 
+    DEFAULT_EXCLUDES = "__pycache__"
+
     def __init__(self, path: str):
         self._path = path
 
@@ -130,6 +132,10 @@ def find_packages(self) -> t.Iterable[str]:
                 # If we're at the root and it's a package, use the directory name
                 rel_path = os.path.basename(abs_path)
 
+            # skip excludes TODO: should re-use Filter API
+            if os.path.basename(rel_path).strip(os.pathsep) in self.DEFAULT_EXCLUDES:
+                continue
+
             # Skip invalid package names (those containing dots in the path)
             if "." in os.path.basename(rel_path):
                 continue

plux/build/hatchling.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import sys
 import typing as t
 from pathlib import Path
 
@@ -13,20 +14,11 @@
 LOG = logging.getLogger(__name__)
 
 
-def _path_to_module(path):
-    """
-    Convert a path to a Python module to its module representation.
-
-    Example: plux/core/test -> plux.core.test
-    """
-    return ".".join(Path(path).with_suffix("").parts)
-
-
 class HatchlingPackageFinder(PackageFinder):
     """
     Uses hatchling's BuilderConfig abstraction to enumerate packages.
 
-    TODO: this might not be 100% correct and needs more thorough testing with different scenarios.
+    TODO: include/exclude configuration of packages in hatch needs more thorough testing with different scenarios.
     """
 
     builder_config: BuilderConfig
@@ -111,27 +103,44 @@ def __init__(self, workdir: str = None):
                 "Hatchling integration currently only works with entrypoint_build_mode=manual"
             )
 
-        # FIXME it's unclear whether this will really hold for all configs. most configs we assume will build a wheel,
-        #  and any associated package configuration will come from there. so currently we make the wheel build config
-        #  the source of truth, but we should revisit this once we know more about hatch build configurations.
+        # we assume that a wheel will be the source of truth for the packages finally ending up in the distribution.
+        # therefore we care foremost about the wheel configuration. this also builds on the assumption that building
+        # the wheel from the local sources, and the sdist, will be the same.
         self.builder = WheelBuilder(workdir)
 
+    @property
+    def hatchling_config(self) -> BuilderConfig:
+        return self.builder.config
+
     def create_package_finder(self) -> PackageFinder:
         return HatchlingPackageFinder(
             self.hatchling_config,
             exclude=self.config.exclude,
             include=self.config.include,
         )
 
-    @property
-    def hatchling_config(self) -> BuilderConfig:
-        return self.builder.config
-
     def find_plux_index_file(self) -> Path:
         # TODO: extend as soon as we support EntryPointBuildMode = build-hook
         return Path(self.hatchling_config.root, self.config.entrypoint_static_file)
 
     def find_entry_point_file(self) -> Path:
-        # TODO: we'll assume that `pip install -e .` is used, and therefore the entrypoints file will be in the
-        #  .dist-info metadata directory
-        raise NotImplementedError
+        # we assume that `pip install -e .` is used, and therefore the entrypoints file used during local execution
+        # will be in the .dist-info metadata directory in the sys path
+        metadata_dir = f"{self.builder.artifact_project_id}.dist-info"
+
+        for path in sys.path:
+            metadata_path = os.path.join(path, metadata_dir)
+            if not os.path.exists(metadata_path):
+                continue
+
+            return Path(metadata_path) / "entry_points.txt"
+
+        raise FileNotFoundError(f"No metadata found for {self.builder.artifact_project_id} in sys path")
+
+    def build_entrypoints(self):
+        # TODO: currently this just replicates the manual build mode.
+        path = os.path.join(os.getcwd(), self.config.entrypoint_static_file)
+        print(f"discovering plugins and writing to {path} ...")
+        builder = self.create_plugin_index_builder()
+        with open(path, "w") as fd:
+            builder.write(fd, output_format="ini")

plux/core/entrypoint.py

@@ -34,7 +34,7 @@ def discover_entry_points(finder: PluginFinder) -> EntryPointDict:
     return to_entry_point_dict([spec_to_entry_point(spec) for spec in finder.find_plugins()])
 
 
-def to_entry_point_dict(eps: list[EntryPoint]) -> EntryPointDict:
+def to_entry_point_dict(eps: t.Iterable[EntryPoint]) -> EntryPointDict:
     """
     Convert the list of EntryPoint objects to a dictionary that maps entry point groups to their respective list of
     ``name=value`` entry points. Each pair is represented as a string.

tests/cli/test_hatch.py

@@ -1,5 +1,6 @@
 import os.path
 import sys
+from pathlib import Path
 
 
 def test_discover_with_ini_output(tmp_path):
@@ -27,7 +28,7 @@ def test_discover_with_ini_output(tmp_path):
     ]
 
 
-def test_discover_with_ini_output_namespace_Package(tmp_path):
+def test_discover_with_ini_output_namespace_package(tmp_path):
     from plux.__main__ import main
 
     project = os.path.join(os.path.dirname(__file__), "projects", "hatch", "namespace_package")
@@ -50,3 +51,31 @@ def test_discover_with_ini_output_namespace_Package(tmp_path):
         "mynestedplugin = test_project.subpkg.plugins:MyNestedPlugin",
         "myplugin = test_project.plugins:MyPlugin",
     ]
+
+
+def test_entrypoints_manual_build_mode():
+    from plux.__main__ import main
+
+    project = os.path.join(os.path.dirname(__file__), "projects", "hatch", "namespace_package")
+    os.chdir(project)
+
+    index_file = Path(project, "plux.ini")
+    index_file.unlink(missing_ok=True)
+
+    sys.path.append(project)
+    try:
+        try:
+            main(["--workdir", project, "entrypoints"])
+        except SystemExit:
+            pass
+    finally:
+        sys.path.remove(project)
+
+    assert index_file.exists()
+
+    lines = index_file.read_text().strip().splitlines()
+    assert lines == [
+        "[plux.test.plugins]",
+        "mynestedplugin = test_project.subpkg.plugins:MyNestedPlugin",
+        "myplugin = test_project.plugins:MyPlugin",
+    ]