python-package-folder 7.1.0__tar.gz → 8.1.0__tar.gz

{python_package_folder-7.1.0 → python_package_folder-8.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 7.1.0
+Version: 8.1.0
 Summary: Python package to automatically package and build a folder, fetching all relevant dependencies.
 Project-URL: Repository, https://github.com/alelom/python-package-folder
 Author-email: Alessio Lombardi <work@alelom.com>

{python_package_folder-7.1.0 → python_package_folder-8.1.0}/coverage.svg

@@ -14,7 +14,7 @@
   <g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11">
     <text x="31.5" y="15" fill="#010101" fill-opacity=".3">coverage</text>
     <text x="31.5" y="14">coverage</text>
-    <text x="81" y="15" fill="#010101" fill-opacity=".3">65%</text>
-    <text x="81" y="14">65%</text>
+    <text x="81" y="15" fill="#010101" fill-opacity=".3">67%</text>
+    <text x="81" y="14">67%</text>
   </g>
 </svg>

{python_package_folder-7.1.0 → python_package_folder-8.1.0}/pyproject.toml

@@ -43,7 +43,7 @@ dependencies = [
 
 # ---- Dev dependencies ----
 
-version = "7.1.0"
+version = "8.1.0"
 [dependency-groups]
 dev = [
     "pytest>=8.3.5",

{python_package_folder-7.1.0 → python_package_folder-8.1.0}/src/python_package_folder/manager.py

@@ -933,6 +933,9 @@ class BuildManager:
         ambiguous: list[ImportInfo] = []
 
         for file_path in python_files:
+            # Skip files that don't exist (might be in temp directory that wasn't fully created)
+            if not file_path.exists():
+                continue
             imports = analyzer.extract_imports(file_path)
             for imp in imports:
                 analyzer.classify_import(imp, self.src_dir)
@@ -1150,12 +1153,24 @@ class BuildManager:
                         f"Temporary package directory does not exist: {temp_dir}. "
                         "This should have been created during prepare_build()."
                     )
+                # Debug: List all files in temp directory
+                all_files = list(temp_dir.rglob("*"))
+                all_files = [f for f in all_files if f.is_file()]
+                print(
+                    f"DEBUG: Temp package directory {temp_dir} contains {len(all_files)} files: "
+                    f"{[str(f.relative_to(temp_dir)) for f in all_files[:10]]}",
+                    file=sys.stderr,
+                )
                 # Verify it contains Python files
                 py_files = list(temp_dir.glob("*.py"))
                 if not py_files:
-                    raise RuntimeError(
-                        f"Temporary package directory exists but contains no Python files: {temp_dir}"
-                    )
+                    # Also check recursively
+                    py_files = list(temp_dir.rglob("*.py"))
+                    if not py_files:
+                        raise RuntimeError(
+                            f"Temporary package directory exists but contains no Python files: {temp_dir}. "
+                            f"Total files found: {len(all_files)}"
+                        )
                 # Verify __init__.py exists
                 if not (temp_dir / "__init__.py").exists():
                     raise RuntimeError(

{python_package_folder-7.1.0 → python_package_folder-8.1.0}/src/python_package_folder/subfolder_build.py

@@ -134,6 +134,7 @@ class SubfolderBuildConfig:
         This way, hatchling will install it with the correct name without needing force-include.
         """
         if not self.package_name:
+            print("DEBUG: No package_name provided, skipping temp package directory creation", file=sys.stderr)
             return
         
         # Convert package name (with hyphens) to import name (with underscores)
@@ -144,13 +145,21 @@ class SubfolderBuildConfig:
         # This way, hatchling will install it with the correct name
         import_name_dir = self.project_root / import_name
         
+        print(
+            f"DEBUG: Creating temporary package directory: {import_name_dir} "
+            f"(from src_dir: {self.src_dir}, import name: {import_name})",
+            file=sys.stderr,
+        )
+        
         # Check if the directory already exists and is the correct one
         if import_name_dir.exists() and import_name_dir == self._temp_package_dir:
             # Directory already exists and is the correct one, no need to recreate
+            print(f"DEBUG: Temporary package directory already exists: {import_name_dir}", file=sys.stderr)
             return
         
         # Remove if it already exists (from a previous build)
         if import_name_dir.exists():
+            print(f"DEBUG: Removing existing temporary package directory: {import_name_dir}", file=sys.stderr)
             shutil.rmtree(import_name_dir)
         
         # Copy the entire source directory contents directly to the import name directory
@@ -171,9 +180,38 @@ class SubfolderBuildConfig:
             self._temp_package_dir = None
             return
         
+        # Get exclude patterns from parent pyproject.toml
+        exclude_patterns = []
+        original_pyproject = self.project_root / "pyproject.toml"
+        if original_pyproject.exists():
+            exclude_patterns = read_exclude_patterns(original_pyproject)
+            print(
+                f"DEBUG: Using exclude patterns for temp directory copy: {exclude_patterns}",
+                file=sys.stderr,
+            )
+        
+        # Check if src_dir has any files before copying
+        src_files = list(self.src_dir.rglob("*"))
+        src_files = [f for f in src_files if f.is_file()]
+        print(
+            f"DEBUG: Source directory {self.src_dir} contains {len(src_files)} files before copy",
+            file=sys.stderr,
+        )
+        
+        # Use a copy method that respects exclude patterns and handles missing directories
         try:
-            shutil.copytree(self.src_dir, import_name_dir)
+            print(f"DEBUG: Starting copy from {self.src_dir} to {import_name_dir}", file=sys.stderr)
+            self._copytree_excluding_patterns(self.src_dir, import_name_dir, exclude_patterns)
             self._temp_package_dir = import_name_dir
+            
+            # Verify files were copied
+            copied_files = list(import_name_dir.rglob("*"))
+            copied_files = [f for f in copied_files if f.is_file()]
+            print(
+                f"DEBUG: After copy, temp directory {import_name_dir} contains {len(copied_files)} files",
+                file=sys.stderr,
+            )
+            
             print(
                 f"Created temporary package directory: {import_name_dir} "
                 f"(import name: {import_name})"
@@ -183,8 +221,141 @@ class SubfolderBuildConfig:
                 f"Warning: Could not create temporary package directory: {e}",
                 file=sys.stderr,
             )
+            import traceback
+            print(f"DEBUG: Traceback: {traceback.format_exc()}", file=sys.stderr)
             # Fall back to using src_dir directly
             self._temp_package_dir = None
+    
+    def _copytree_excluding_patterns(self, src: Path, dst: Path, exclude_patterns: list[str]) -> None:
+        """
+        Copy a directory tree, excluding certain patterns and handling missing directories gracefully.
+        
+        This is similar to BuildManager._copytree_excluding but works without needing
+        the BuildManager instance. It respects exclude patterns and skips missing directories
+        (e.g., broken symlinks or already-excluded directories).
+        
+        Args:
+            src: Source directory
+            dst: Destination directory
+            exclude_patterns: List of patterns to exclude (e.g., ['_SS', '__SS', '.*_test.*'])
+        """
+        default_patterns = [
+            "_SS",
+            "__SS",
+            "_sandbox",
+            "__sandbox",
+            "_skip",
+            "__skip",
+            "_test",
+            "__test__",
+        ]
+        all_exclude_patterns = default_patterns + exclude_patterns
+        
+        def should_exclude(path: Path) -> bool:
+            """Check if a path should be excluded."""
+            import re
+            # Only check parts of the path relative to src_dir, not the entire absolute path
+            # This prevents matching test directory names or other parts outside the source
+            try:
+                rel_path = path.relative_to(src)
+                # Check each component of the relative path
+                for part in rel_path.parts:
+                    # Check if any part matches an exclusion pattern
+                    for pattern in all_exclude_patterns:
+                        # Determine if pattern is a regex (contains regex special characters)
+                        is_regex = any(c in pattern for c in ['.', '*', '+', '?', '^', '$', '[', ']', '(', ')', '{', '}', '|', '\\'])
+                        
+                        if is_regex:
+                            # Use regex matching for patterns like '.*_test.*'
+                            try:
+                                if re.search(pattern, part):
+                                    print(f"DEBUG: Excluding {path} (part '{part}' matches regex pattern '{pattern}')", file=sys.stderr)
+                                    return True
+                            except re.error:
+                                # Invalid regex, fall back to simple string matching
+                                if part == pattern or part.startswith(pattern):
+                                    print(f"DEBUG: Excluding {path} (part '{part}' matches pattern '{pattern}')", file=sys.stderr)
+                                    return True
+                        else:
+                            # Simple string matching for patterns like '_SS'
+                            if part == pattern or part.startswith(pattern):
+                                print(f"DEBUG: Excluding {path} (part '{part}' matches pattern '{pattern}')", file=sys.stderr)
+                                return True
+            except ValueError:
+                # Path is not relative to src, check the name only
+                for pattern in all_exclude_patterns:
+                    is_regex = any(c in pattern for c in ['.', '*', '+', '?', '^', '$', '[', ']', '(', ')', '{', '}', '|', '\\'])
+                    if is_regex:
+                        try:
+                            if re.search(pattern, path.name):
+                                return True
+                        except re.error:
+                            if path.name == pattern or path.name.startswith(pattern):
+                                return True
+                    else:
+                        if path.name == pattern or path.name.startswith(pattern):
+                            return True
+            return False
+        
+        # Create destination directory
+        dst.mkdir(parents=True, exist_ok=True)
+        
+        # Copy files and subdirectories, excluding patterns
+        copied_count = 0
+        excluded_count = 0
+        skipped_count = 0
+        try:
+            items = list(src.iterdir())
+            print(f"DEBUG: Copying from {src} to {dst}, found {len(items)} items", file=sys.stderr)
+            for item in items:
+                if should_exclude(item):
+                    print(f"DEBUG: Excluding {item} from temp package directory copy", file=sys.stderr)
+                    excluded_count += 1
+                    continue
+                
+                src_item = src / item.name
+                dst_item = dst / item.name
+                
+                # Skip if source doesn't exist (broken symlink, already deleted, etc.)
+                if not src_item.exists():
+                    print(
+                        f"DEBUG: Skipping non-existent item: {src_item}",
+                        file=sys.stderr,
+                    )
+                    skipped_count += 1
+                    continue
+                
+                if src_item.is_file():
+                    try:
+                        shutil.copy2(src_item, dst_item)
+                        copied_count += 1
+                        print(f"DEBUG: Copied file {src_item} -> {dst_item}", file=sys.stderr)
+                    except (OSError, IOError) as e:
+                        print(
+                            f"DEBUG: Could not copy file {src_item}: {e}, skipping",
+                            file=sys.stderr,
+                        )
+                        skipped_count += 1
+                        continue
+                elif src_item.is_dir():
+                    try:
+                        self._copytree_excluding_patterns(src_item, dst_item, exclude_patterns)
+                        copied_count += 1
+                        print(f"DEBUG: Copied directory {src_item} -> {dst_item}", file=sys.stderr)
+                    except (OSError, IOError) as e:
+                        print(
+                            f"DEBUG: Could not copy directory {src_item}: {e}, skipping",
+                            file=sys.stderr,
+                        )
+                        skipped_count += 1
+                        continue
+            print(
+                f"DEBUG: Copy summary: {copied_count} items copied, {excluded_count} excluded, {skipped_count} skipped",
+                file=sys.stderr,
+            )
+        except (OSError, IOError) as e:
+            # If we can't even iterate the source directory, that's a problem
+            raise RuntimeError(f"Cannot iterate source directory {src}: {e}") from e
 
     def _get_package_structure(self) -> tuple[str, list[str]]:
         """
@@ -198,6 +369,13 @@ class SubfolderBuildConfig:
         # Use temporary package directory if it exists, otherwise use src_dir
         package_dir = self._temp_package_dir if self._temp_package_dir and self._temp_package_dir.exists() else self.src_dir
         
+        print(
+            f"DEBUG: _get_package_structure: temp_package_dir={self._temp_package_dir}, "
+            f"exists={self._temp_package_dir.exists() if self._temp_package_dir else False}, "
+            f"using package_dir={package_dir}",
+            file=sys.stderr,
+        )
+        
         # Check if package_dir itself is a package (has __init__.py)
         has_init = (package_dir / "__init__.py").exists()
 
@@ -211,6 +389,16 @@ class SubfolderBuildConfig:
             packages_path = str(rel_path).replace("\\", "/")
         except ValueError:
             packages_path = None
+            print(
+                f"DEBUG: Could not calculate relative path from {self.project_root} to {package_dir}",
+                file=sys.stderr,
+            )
+
+        print(
+            f"DEBUG: _get_package_structure returning: packages_path={packages_path}, "
+            f"has_init={has_init}, has_py_files={has_py_files}",
+            file=sys.stderr,
+        )
 
         # If package_dir has Python files but no __init__.py, we need to make it a package
         # or include it as a module directory
@@ -280,9 +468,19 @@ class SubfolderBuildConfig:
                 in_sdist_section = False
                 result.append(line)
             elif in_sdist_section:
-                # Track if only-include already exists
+                # Replace only-include path if it exists
                 if re.match(r"^\s*only-include\s*=", line):
                     only_include_set = True
+                    # Replace with correct path
+                    only_include_paths = [correct_packages_path]
+                    only_include_paths.append("pyproject.toml")
+                    only_include_paths.append("README.md")
+                    only_include_paths.append("README.rst")
+                    only_include_paths.append("README.txt")
+                    only_include_paths.append("README")
+                    only_include_str = ", ".join(f'"{p}"' for p in only_include_paths)
+                    result.append(f"only-include = [{only_include_str}]")
+                    continue
                 result.append(line)
             elif in_hatch_build_section:
                 result.append(line)
@@ -327,19 +525,27 @@ class SubfolderBuildConfig:
 
         # Use only-include for source distributions to ensure only the subfolder is included
         # This prevents including files from the project root
-        if correct_packages_path and not only_include_set:
-            result.append("")
-            result.append("[tool.hatch.build.targets.sdist]")
-            # Include only the subfolder directory and necessary files
-            only_include_paths = [correct_packages_path]
-            # Also include pyproject.toml and README if they exist
-            only_include_paths.append("pyproject.toml")
-            only_include_paths.append("README.md")
-            only_include_paths.append("README.rst")
-            only_include_paths.append("README.txt")
-            only_include_paths.append("README")
-            only_include_str = ", ".join(f'"{p}"' for p in only_include_paths)
-            result.append(f"only-include = [{only_include_str}]")
+        # Only add sdist section if it doesn't already exist and only-include wasn't set
+        if correct_packages_path:
+            # Check if sdist section already exists in result
+            sdist_section_exists = any(
+                line.strip().startswith("[tool.hatch.build.targets.sdist]")
+                for line in result
+            )
+            # Only add section and only-include if they don't already exist
+            if not sdist_section_exists and not only_include_set:
+                result.append("")
+                result.append("[tool.hatch.build.targets.sdist]")
+                # Include only the subfolder directory and necessary files
+                only_include_paths = [correct_packages_path]
+                # Also include pyproject.toml and README if they exist
+                only_include_paths.append("pyproject.toml")
+                only_include_paths.append("README.md")
+                only_include_paths.append("README.rst")
+                only_include_paths.append("README.txt")
+                only_include_paths.append("README")
+                only_include_str = ", ".join(f'"{p}"' for p in only_include_paths)
+                result.append(f"only-include = [{only_include_str}]")
 
         return "\n".join(result)
 
@@ -407,6 +613,14 @@ class SubfolderBuildConfig:
                 # This will copy the __init__.py we just created (if any)
                 self._create_temp_package_directory()
                 
+                # Verify temporary package directory was created
+                if not self._temp_package_dir or not self._temp_package_dir.exists():
+                    print(
+                        f"Warning: Temporary package directory was not created. "
+                        f"Falling back to using src_dir: {self.src_dir}",
+                        file=sys.stderr,
+                    )
+                
                 # Determine which directory to use (temp package dir or src_dir)
                 package_dir = self._temp_package_dir if self._temp_package_dir and self._temp_package_dir.exists() else self.src_dir
                 # Use the subfolder's pyproject.toml
@@ -421,6 +635,8 @@ class SubfolderBuildConfig:
                 temp_pyproject_path = self.project_root / "pyproject.toml.temp"
 
                 # Adjust packages path to be relative to project root
+                # This must be called AFTER _create_temp_package_directory() so _get_package_structure() 
+                # can find the temporary directory
                 adjusted_content = self._adjust_subfolder_pyproject_packages_path(subfolder_content)
                 
                 # Read exclude patterns from root pyproject.toml and inject them (if it exists)
@@ -490,8 +706,28 @@ class SubfolderBuildConfig:
         # This will copy the __init__.py we just created (if any)
         self._create_temp_package_directory()
         
+        # Log the result of temp directory creation
+        if self._temp_package_dir and self._temp_package_dir.exists():
+            py_files = list(self._temp_package_dir.glob("*.py"))
+            print(
+                f"DEBUG: Temp package directory created successfully: {self._temp_package_dir}, "
+                f"contains {len(py_files)} Python files",
+                file=sys.stderr,
+            )
+        else:
+            print(
+                f"WARNING: Temp package directory was NOT created. "
+                f"Will fall back to using src_dir: {self.src_dir}",
+                file=sys.stderr,
+            )
+        
         # Determine which directory to use (temp package dir or src_dir)
         package_dir = self._temp_package_dir if self._temp_package_dir and self._temp_package_dir.exists() else self.src_dir
+        print(
+            f"DEBUG: Using package_dir for build: {package_dir} "
+            f"(temp_dir={self._temp_package_dir}, src_dir={self.src_dir})",
+            file=sys.stderr,
+        )
 
         # Read the original pyproject.toml
         original_pyproject = self.project_root / "pyproject.toml"

{python_package_folder-7.1.0 → python_package_folder-8.1.0}/tests/test_subfolder_build.py

@@ -1130,6 +1130,85 @@ class TestTemporaryPackageDirectory:
 
         config.restore()
 
+    def test_temp_package_directory_respects_exclude_patterns_without_matching_test_dirs(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """
+        Test that exclude patterns don't incorrectly match pytest temp directory names.
+        
+        This test ensures that exclude patterns like '.*test_.*' only match files/directories
+        within the source directory, not the pytest temp directory name (e.g., 
+        'test_real_world_ml_drawing_assistant_data_scenario').
+        
+        This is a regression test for the bug where all files were excluded because the
+        exclude pattern matching checked the entire absolute path instead of just the
+        relative path within src_dir.
+        """
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+        
+        # Create files that should NOT be excluded
+        (subfolder / "__init__.py").write_text("# Package init")
+        (subfolder / "module.py").write_text("def func(): pass")
+        (subfolder / "utils.py").write_text("def util(): pass")
+        
+        # Create a file that SHOULD be excluded (matches pattern)
+        (subfolder / "test_helper.py").write_text("def test(): pass")
+        (subfolder / "_SS").mkdir()
+        (subfolder / "_SS" / "excluded.py").write_text("# Should be excluded")
+        
+        # Update pyproject.toml with exclude patterns that could match test directory names
+        pyproject_path = project_root / "pyproject.toml"
+        pyproject_content = pyproject_path.read_text()
+        # Add exclude patterns including ones that could match pytest temp dirs
+        if "[tool.python-package-folder]" not in pyproject_content:
+            pyproject_content += "\n[tool.python-package-folder]\n"
+        pyproject_content += 'exclude-patterns = ["_SS", "__SS", ".*_test.*", ".*test_.*", "sandbox"]\n'
+        pyproject_path.write_text(pyproject_content)
+        
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            version="1.0.0",
+            package_name="my-package",
+        )
+        
+        # Create temp pyproject (which creates temp package directory with exclude patterns)
+        config.create_temp_pyproject()
+        
+        temp_package_dir = config._temp_package_dir
+        assert temp_package_dir is not None
+        assert temp_package_dir.exists()
+        
+        # Files that should NOT be excluded should be copied
+        assert (temp_package_dir / "__init__.py").exists(), (
+            "__init__.py should be copied (doesn't match exclude patterns)"
+        )
+        assert (temp_package_dir / "module.py").exists(), (
+            "module.py should be copied (doesn't match exclude patterns)"
+        )
+        assert (temp_package_dir / "utils.py").exists(), (
+            "utils.py should be copied (doesn't match exclude patterns)"
+        )
+        
+        # Files that SHOULD be excluded should NOT be copied
+        assert not (temp_package_dir / "test_helper.py").exists(), (
+            "test_helper.py should be excluded (matches '.*test_.*' pattern)"
+        )
+        assert not (temp_package_dir / "_SS").exists(), (
+            "_SS directory should be excluded (matches '_SS' pattern)"
+        )
+        
+        # Verify at least some files were copied (this would fail if all files were excluded)
+        all_files = list(temp_package_dir.rglob("*"))
+        all_files = [f for f in all_files if f.is_file()]
+        assert len(all_files) >= 3, (
+            f"Expected at least 3 files to be copied, but only found {len(all_files)}. "
+            f"This suggests exclude patterns are incorrectly matching test directory names."
+        )
+        
+        config.restore()
+
 
 class TestWheelPackaging:
     """Tests to verify that wheels are correctly packaged with the right directory structure."""
@@ -1353,4 +1432,393 @@ build-backend = "hatchling.build"
         
         # Verify dist-info also exists
         dist_info_dir = site_packages / f"{import_name}-{version}.dist-info"
-        assert dist_info_dir.exists(), f"dist-info directory should exist: {dist_info_dir}"
+        assert dist_info_dir.exists(), f"dist-info directory should exist: {dist_info_dir}"
+
+    def test_wheel_with_subfolder_pyproject_toml_uses_temp_directory(self, tmp_path: Path) -> None:
+        """Test that when subfolder has pyproject.toml with only-include, it's replaced with temp directory."""
+        project_root = tmp_path / "test_project"
+        project_root.mkdir()
+
+        # Create parent pyproject.toml
+        pyproject_content = """[project]
+name = "test-package"
+version = "0.1.0"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+"""
+        (project_root / "pyproject.toml").write_text(pyproject_content)
+
+        # Create subfolder with pyproject.toml that has only-include
+        subfolder = project_root / "src" / "data"
+        subfolder.mkdir(parents=True)
+        
+        # Create some Python files
+        (subfolder / "__init__.py").write_text("# Package init")
+        (subfolder / "module.py").write_text("def hello(): return 'world'")
+        
+        # Create subfolder pyproject.toml with only-include pointing to src/data
+        subfolder_pyproject = """[project]
+name = "ml-drawing-assistant-data"
+version = "1.0.0"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/data"]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["src/data", "pyproject.toml", "README.md"]
+"""
+        (subfolder / "pyproject.toml").write_text(subfolder_pyproject)
+
+        # Package name with hyphens
+        package_name = "ml-drawing-assistant-data"
+        import_name = "ml_drawing_assistant_data"  # Expected import name
+        version = "1.0.0"
+
+        # Build the wheel
+        manager = BuildManager(project_root=project_root, src_dir=subfolder)
+        
+        def build_wheel() -> None:
+            """Build the wheel using uv build."""
+            subprocess.run(
+                ["uv", "build", "--wheel"],
+                cwd=project_root,
+                check=True,
+                capture_output=True,
+            )
+
+        try:
+            manager.run_build(build_wheel, version=version, package_name=package_name)
+        finally:
+            manager.cleanup()
+
+        # Find the built wheel
+        dist_dir = project_root / "dist"
+        assert dist_dir.exists(), "dist directory should exist after build"
+        
+        wheel_files = list(dist_dir.glob("*.whl"))
+        assert len(wheel_files) > 0, "At least one wheel should be built"
+        
+        wheel_file = wheel_files[0]
+        
+        # Extract and inspect the wheel
+        with zipfile.ZipFile(wheel_file, "r") as wheel:
+            file_names = wheel.namelist()
+            
+            # Verify the package directory exists with the correct import name
+            package_dir_prefix = f"{import_name}/"
+            package_files = [f for f in file_names if f.startswith(package_dir_prefix)]
+            
+            assert len(package_files) > 0, (
+                f"Wheel should contain files in {import_name}/ directory, not 'data/'. "
+                f"Found files: {[f for f in file_names if '/' in f and '.dist-info' not in f][:10]}"
+            )
+            
+            # Verify the expected files are present
+            assert f"{import_name}/__init__.py" in file_names, (
+                f"Wheel should contain {import_name}/__init__.py"
+            )
+            assert f"{import_name}/module.py" in file_names, (
+                f"Wheel should contain {import_name}/module.py"
+            )
+            
+            # Verify 'data/' is NOT in the wheel (should be replaced with import_name)
+            data_files = [f for f in file_names if f.startswith("data/") and ".dist-info" not in f]
+            assert len(data_files) == 0, (
+                f"Wheel should not contain 'data/' directory, should use '{import_name}/' instead. "
+                f"Found: {data_files[:5]}"
+            )
+
+    def test_real_world_ml_drawing_assistant_data_scenario(self, tmp_path: Path) -> None:
+        """
+        Integration test that mimics publishing src/data as ml-drawing-assistant-data.
+        
+        This test verifies the complete workflow:
+        1. Project structure with src/data subfolder
+        2. External dependencies (_shared, models, etc.)
+        3. Subfolder pyproject.toml with only-include
+        4. Building and installing the wheel
+        5. Verifying the package directory exists with correct name
+        """
+        project_root = tmp_path / "ml_drawing_assistant"
+        project_root.mkdir()
+
+        # Create parent pyproject.toml (similar to ml-drawing-assistant)
+        parent_pyproject = """[project]
+name = "ml-drawing-assistant"
+version = "0.1.0"
+description = "ML Drawing Assistant"
+requires-python = ">=3.12, <3.13"
+dependencies = [
+    "numpy>=2.2.5",
+    "pillow>=11.2.1",
+]
+
+[tool.python-package-folder]
+exclude-patterns = ["_SS", "__SS", ".*_test.*", ".*test_.*", "sandbox"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+"""
+        (project_root / "pyproject.toml").write_text(parent_pyproject)
+
+        # Create external dependency: _shared
+        shared_dir = project_root / "src" / "_shared"
+        shared_dir.mkdir(parents=True)
+        (shared_dir / "__init__.py").write_text("# Shared utilities")
+        (shared_dir / "image_utils.py").write_text("def process_image(): return 'processed'")
+
+        # Create external dependency: models/Information_extraction/_shared_ie
+        models_ie_dir = project_root / "src" / "models" / "Information_extraction" / "_shared_ie"
+        models_ie_dir.mkdir(parents=True)
+        (models_ie_dir / "__init__.py").write_text("# IE shared")
+        (models_ie_dir / "ie_enums.py").write_text("class IEEnum: pass")
+
+        # Create external dependency: _globals.py
+        (project_root / "src" / "_globals.py").write_text("IS_TESTING = False")
+
+        # Create the subfolder to publish: src/data
+        data_dir = project_root / "src" / "data"
+        data_dir.mkdir(parents=True)
+        
+        # Create some Python files in data/
+        (data_dir / "__init__.py").write_text("# ML Drawing Assistant Data Package")
+        # Use imports that will be found as external dependencies
+        # These will be copied into the temp package directory during build
+        (data_dir / "datacollection.py").write_text(
+            """# Import external dependencies that will be copied during build
+try:
+    from _shared.image_utils import process_image
+    from models.Information_extraction._shared_ie.ie_enums import IEEnum
+    from _globals import IS_TESTING
+except ImportError:
+    # During analysis, these might not be available yet
+    pass
+
+def collect_data():
+    try:
+        return process_image()
+    except NameError:
+        return "data collected"
+"""
+        )
+        (data_dir / "data_storage").mkdir(parents=True)
+        (data_dir / "data_storage" / "storage.py").write_text("def store(): pass")
+        (data_dir / "data_storage" / "__init__.py").write_text("")
+
+        # Create subfolder pyproject.toml (similar to real scenario)
+        # This has only-include pointing to src/data which should be replaced
+        subfolder_pyproject = """[project]
+name = "ml-drawing-assistant-data"
+version = "1.0.0"
+description = "Data package for ML Drawing Assistant"
+requires-python = ">=3.12, <3.13"
+dependencies = [
+    "numpy>=2.2.5",
+    "pillow>=11.2.1",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/data"]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["src/data", "pyproject.toml", "README.md"]
+"""
+        (data_dir / "pyproject.toml").write_text(subfolder_pyproject)
+
+        # Package name with hyphens (like ml-drawing-assistant-data)
+        package_name = "ml-drawing-assistant-data"
+        import_name = "ml_drawing_assistant_data"  # Expected import name
+        version = "1.0.0"
+
+        # Build the wheel
+        manager = BuildManager(project_root=project_root, src_dir=data_dir)
+        
+        def build_wheel() -> None:
+            """Build the wheel using uv build."""
+            result = subprocess.run(
+                ["uv", "build", "--wheel"],
+                cwd=project_root,
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode != 0:
+                print(f"Build failed with return code {result.returncode}")
+                print(f"stdout: {result.stdout}")
+                print(f"stderr: {result.stderr}")
+                raise subprocess.CalledProcessError(result.returncode, result.args, result.stdout, result.stderr)
+
+        try:
+            manager.run_build(build_wheel, version=version, package_name=package_name)
+        finally:
+            manager.cleanup()
+
+        # Find the built wheel
+        dist_dir = project_root / "dist"
+        assert dist_dir.exists(), "dist directory should exist after build"
+        
+        wheel_files = list(dist_dir.glob("*.whl"))
+        assert len(wheel_files) > 0, "At least one wheel should be built"
+        
+        wheel_file = wheel_files[0]
+        
+        # Extract and inspect the wheel
+        with zipfile.ZipFile(wheel_file, "r") as wheel:
+            file_names = wheel.namelist()
+            
+            # Verify the package directory exists with the correct import name
+            package_dir_prefix = f"{import_name}/"
+            package_files = [f for f in file_names if f.startswith(package_dir_prefix)]
+            
+            assert len(package_files) > 0, (
+                f"Wheel should contain files in {import_name}/ directory, not 'data/'. "
+                f"Found files: {[f for f in file_names if '/' in f and '.dist-info' not in f][:15]}"
+            )
+            
+            # Verify the expected files are present
+            # Note: When src/data is copied, it becomes ml_drawing_assistant_data/data/
+            # because copytree copies the directory structure
+            init_paths = [f"{import_name}/data/__init__.py", f"{import_name}/__init__.py"]
+            assert any(path in file_names for path in init_paths), (
+                f"Wheel should contain {import_name}/__init__.py or {import_name}/data/__init__.py"
+            )
+            datacollection_paths = [
+                f"{import_name}/data/datacollection.py",
+                f"{import_name}/datacollection.py"
+            ]
+            assert any(path in file_names for path in datacollection_paths), (
+                f"Wheel should contain datacollection.py. "
+                f"Found: {[f for f in file_names if 'datacollection' in f]}"
+            )
+            # data_storage should be under data/ if data/ is preserved
+            data_storage_paths = [
+                f"{import_name}/data/data_storage/storage.py",
+                f"{import_name}/data_storage/storage.py"
+            ]
+            assert any(path in file_names for path in data_storage_paths), (
+                f"Wheel should contain data_storage/storage.py. "
+                f"Found: {[f for f in file_names if 'storage.py' in f]}"
+            )
+            
+            # Verify external dependencies were copied
+            assert f"{import_name}/_shared/image_utils.py" in file_names, (
+                f"Wheel should contain copied external dependency {import_name}/_shared/image_utils.py"
+            )
+            assert f"{import_name}/models/Information_extraction/_shared_ie/ie_enums.py" in file_names, (
+                f"Wheel should contain copied external dependency {import_name}/models/Information_extraction/_shared_ie/ie_enums.py"
+            )
+            assert f"{import_name}/_globals.py" in file_names, (
+                f"Wheel should contain copied external dependency {import_name}/_globals.py"
+            )
+            
+            # Verify 'data/' is NOT in the wheel (should be replaced with import_name)
+            data_files = [f for f in file_names if f.startswith("data/") and ".dist-info" not in f]
+            assert len(data_files) == 0, (
+                f"Wheel should not contain 'data/' directory, should use '{import_name}/' instead. "
+                f"Found: {data_files[:5]}"
+            )
+            
+            # Verify 'src/data' is NOT in the wheel
+            src_data_files = [f for f in file_names if "src/data" in f and ".dist-info" not in f]
+            assert len(src_data_files) == 0, (
+                f"Wheel should not contain 'src/data' paths, should use '{import_name}/' instead. "
+                f"Found: {src_data_files[:5]}"
+            )
+
+        # Try to install the wheel to verify it works (optional - skip if installation fails)
+        # This verifies the package can be installed and the package directory exists
+        try:
+            # Create a temporary virtual environment and install the wheel
+            venv_dir = tmp_path / "test_venv"
+            venv.create(venv_dir, with_pip=True)
+            
+            # Determine the Python executable in the venv
+            if sys.platform == "win32":
+                python_exe = venv_dir / "Scripts" / "python.exe"
+                pip_exe = venv_dir / "Scripts" / "pip.exe"
+            else:
+                python_exe = venv_dir / "bin" / "python"
+                pip_exe = venv_dir / "bin" / "pip"
+            
+            # Install the wheel
+            install_result = subprocess.run(
+                [str(pip_exe), "install", str(wheel_file)],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            
+            if install_result.returncode != 0:
+                # Installation failed - skip installation verification but wheel packaging is still verified
+                print(f"Note: Wheel installation failed (this is OK for testing): {install_result.stderr}")
+                return  # Wheel contents verification above is the main test
+            
+            # Find the site-packages directory
+            if sys.platform == "win32":
+                site_packages = venv_dir / "Lib" / "site-packages"
+            else:
+                # Get Python version
+                version_result = subprocess.run(
+                    [str(python_exe), "-c", "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')"],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                py_version = version_result.stdout.strip()
+                site_packages = venv_dir / "lib" / f"python{py_version}" / "site-packages"
+            
+            assert site_packages.exists(), f"site-packages directory should exist at {site_packages}"
+            
+            # Verify the package directory exists (not just dist-info)
+            package_dir = site_packages / import_name
+            assert package_dir.exists(), (
+                f"Package directory {import_name}/ should exist in site-packages after installation. "
+                f"Found in site-packages: {list(site_packages.iterdir())[:20]}"
+            )
+            assert package_dir.is_dir(), f"{import_name} should be a directory, not a file"
+            
+            # Verify the expected files are present
+            # Check both possible structures (with or without data/ subdirectory)
+            init_exists = (package_dir / "__init__.py").exists() or (package_dir / "data" / "__init__.py").exists()
+            assert init_exists, f"{import_name}/__init__.py or {import_name}/data/__init__.py should exist"
+            
+            datacollection_exists = (package_dir / "datacollection.py").exists() or (package_dir / "data" / "datacollection.py").exists()
+            assert datacollection_exists, f"{import_name}/datacollection.py or {import_name}/data/datacollection.py should exist"
+            
+            storage_exists = (
+                (package_dir / "data_storage" / "storage.py").exists() or
+                (package_dir / "data" / "data_storage" / "storage.py").exists()
+            )
+            assert storage_exists, f"{import_name}/data_storage/storage.py should exist"
+            
+            # Verify external dependencies were installed
+            assert (package_dir / "_shared" / "image_utils.py").exists(), (
+                f"{import_name}/_shared/image_utils.py should exist after installation"
+            )
+            assert (package_dir / "models" / "Information_extraction" / "_shared_ie" / "ie_enums.py").exists(), (
+                f"{import_name}/models/Information_extraction/_shared_ie/ie_enums.py should exist after installation"
+            )
+            assert (package_dir / "_globals.py").exists(), (
+                f"{import_name}/_globals.py should exist after installation"
+            )
+            
+            # Verify dist-info also exists
+            dist_info_dir = site_packages / f"{import_name}-{version}.dist-info"
+            assert dist_info_dir.exists(), f"dist-info directory should exist: {dist_info_dir}"
+            
+            # Verify we can import the package
+            import_result = subprocess.run(
+                [str(python_exe), "-c", f"import {import_name}; print('OK')"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            assert "OK" in import_result.stdout, f"Should be able to import {import_name}"
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            # Installation or import failed - this is acceptable if dependencies are missing
+            # The main verification (wheel contents) has already passed
+            print(f"Note: Installation/import test skipped due to: {e}")
+            # The wheel packaging verification above is the main test