fix hatchling source path detection

Author: alexrashed

plux/build/hatchling.py

@@ -114,9 +114,11 @@ def find_packages(self) -> t.Iterable[str]:
         for relative_package_path in package_paths:
             package_name = os.path.basename(relative_package_path)
 
+            # Package paths in hatchling are always relative to the project root, so we join
+            # with the project root (not self.path, which is the sources root).
             package_path = os.path.join(
-                self.path, relative_package_path
-            )  # build package path within sources root
+                self.builder_config.root, relative_package_path
+            )
             if not os.path.isdir(package_path):
                 continue
 
@@ -141,16 +143,38 @@ def find_packages(self) -> t.Iterable[str]:
 
     @property
     def path(self) -> str:
+        """Return the sources root — the directory under which the package names are located.
+
+        This is used by ``PluginFromPackageFinder._list_module_names`` to construct the
+        file-system path for each package name, so it must point to the directory that
+        *contains* the top-level packages (not the project root in general).
+
+        Hatchling's ``sources`` dict maps ``{source_dir: dest_dir_in_wheel}``:
+
+        - ``{"": "src"}``  — explicit src-layout: source root is ``src/``
+        - ``{"localstack-core/": ""}`` — packages in a subdirectory: source root is
+          ``localstack-core/`` (the key, not the value)
+        - ``{"": ""}``  — packages directly in the project root
+        """
+        root = self.builder_config.root
+
         if not self.builder_config.sources:
-            where = self.builder_config.root
-        else:
-            if self.builder_config.sources[""]:
-                where = self.builder_config.sources[""]
-            else:
-                LOG.warning("plux doesn't know how to resolve multiple sources directories")
-                where = self.builder_config.root
-
-        return where
+            return root
+
+        source_root = self.builder_config.sources.get("")
+        if source_root:
+            # Explicit mapping: "" -> "src" (or similar).  The value is the source dir.
+            return os.path.join(root, source_root)
+
+        # No "" key.  The keys themselves are source directories (e.g. "localstack-core/").
+        # Filter out any empty-string key that slipped through, strip trailing separators.
+        source_dirs = [k.rstrip("/") for k in self.builder_config.sources.keys() if k]
+        if len(source_dirs) == 1:
+            return os.path.join(root, source_dirs[0])
+
+        if source_dirs:
+            LOG.warning("plux doesn't know how to resolve multiple sources directories")
+        return root
 
     def filter_packages(self, packages: t.Iterable[str]) -> t.Iterable[str]:
         return [item for item in packages if not self.exclude(item) and self.include(item)]

tests/build/test_hatchling.py

@@ -372,3 +372,58 @@ def test_hatch_register_metadata_hook():
     hook_class = hatch_register_metadata_hook()
 
     assert hook_class is PluxMetadataHook
+
+
+class TestHatchlingPackageFinderPath:
+    """Tests for HatchlingPackageFinder.path property."""
+
+    def _make_finder(self, sources, root, packages=None):
+        pytest.importorskip("hatchling")
+        from unittest.mock import MagicMock
+        from plux.build.hatchling import HatchlingPackageFinder
+
+        builder_config = MagicMock()
+        builder_config.sources = sources
+        builder_config.root = root
+        builder_config.packages = packages or []
+        return HatchlingPackageFinder(builder_config)
+
+    def test_path_with_packages_in_subdirectory(self, tmp_path):
+        """Regression test: KeyError when packages live in a subdirectory.
+
+        When hatchling is configured with ``packages = ["localstack-core/localstack"]``,
+        builder_config.sources becomes ``{'localstack-core/': ''}`` — the key is the
+        source directory, not ``''``.  The old code did ``sources[""]`` which raised a
+        KeyError.  The fix must return the sources root (``{root}/localstack-core``)
+        so that ``_list_module_names`` can build correct file-system paths for each
+        discovered package name.
+        """
+        finder = self._make_finder(
+            sources={"localstack-core/": ""},
+            root=str(tmp_path),
+            packages=["localstack-core/localstack"],
+        )
+
+        # Must not raise KeyError, and must return the sources root directory
+        path = finder.path
+        import os
+        assert path == os.path.join(str(tmp_path), "localstack-core")
+
+    def test_path_with_empty_sources(self, tmp_path):
+        """When sources is empty, path falls back to the project root."""
+        finder = self._make_finder(sources={}, root=str(tmp_path))
+
+        assert finder.path == str(tmp_path)
+
+    def test_path_with_packages_in_root(self, tmp_path):
+        """When packages are in the project root (sources = {'': ''}), path returns root."""
+        finder = self._make_finder(sources={"": ""}, root=str(tmp_path))
+
+        assert finder.path == str(tmp_path)
+
+    def test_path_with_src_layout(self, tmp_path):
+        """When sources maps '' -> 'src', path returns the sources root joined to the project root."""
+        import os
+        finder = self._make_finder(sources={"": "src"}, root=str(tmp_path))
+
+        assert finder.path == os.path.join(str(tmp_path), "src")