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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 6.0.0
+Version: 7.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-6.0.0 → python_package_folder-7.1.0}/pyproject.toml

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

{python_package_folder-6.0.0 → python_package_folder-7.1.0}/src/python_package_folder/analyzer.py

@@ -227,9 +227,22 @@ class ImportAnalyzer:
             import_info.classification = "stdlib"
             return
 
+        # Check if it's a third-party package (in site-packages) FIRST
+        # This must be checked before resolve_local_import to avoid incorrectly
+        # classifying site-packages modules as "external" when they're found
+        # by the recursive search
+        if self.is_third_party(module_name):
+            import_info.classification = "third_party"
+            return
+
         # Try to resolve as a local import
         resolved = self.resolve_local_import(import_info, src_dir)
         if resolved is not None:
+            # Double-check: if resolved path is in site-packages, it's actually third-party
+            # (this can happen if the recursive search finds it before importlib does)
+            if "site-packages" in str(resolved) or "dist-packages" in str(resolved):
+                import_info.classification = "third_party"
+                return
             if resolved.is_relative_to(src_dir):
                 import_info.classification = "local"
             else:
@@ -237,11 +250,6 @@ class ImportAnalyzer:
             import_info.resolved_path = resolved
             return
 
-        # Check if it's a third-party package (in site-packages)
-        if self.is_third_party(module_name):
-            import_info.classification = "third_party"
-            return
-
         # Mark as ambiguous if we can't determine
         import_info.classification = "ambiguous"
 
@@ -341,6 +349,9 @@ class ImportAnalyzer:
                         # Only search within project_root to avoid going too far
                         if not potential_file.is_relative_to(self.project_root):
                             continue
+                        # Skip site-packages and dist-packages (these are third-party, not external)
+                        if "site-packages" in str(potential_file) or "dist-packages" in str(potential_file):
+                            continue
                         # Skip excluded patterns
                         if any(
                             part.startswith("_SS")

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

@@ -1142,6 +1142,26 @@ class BuildManager:
             else:
                 print("No external dependencies found\n")
 
+            # Verify temporary package directory exists if using subfolder build
+            if self.subfolder_config and self.subfolder_config._temp_package_dir:
+                temp_dir = self.subfolder_config._temp_package_dir
+                if not temp_dir.exists():
+                    raise RuntimeError(
+                        f"Temporary package directory does not exist: {temp_dir}. "
+                        "This should have been created during prepare_build()."
+                    )
+                # 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}"
+                    )
+                # Verify __init__.py exists
+                if not (temp_dir / "__init__.py").exists():
+                    raise RuntimeError(
+                        f"Temporary package directory missing __init__.py: {temp_dir}"
+                    )
+
             print("Running build...")
             # Build command should run from project root to find pyproject.toml
             import os
@@ -1152,6 +1172,36 @@ class BuildManager:
                 build_command()
             finally:
                 os.chdir(original_cwd)
+            
+            # Verify wheel contents after build (for subfolder builds)
+            if self.subfolder_config and self.subfolder_config.package_name:
+                import_name = self.subfolder_config.package_name.replace("-", "_")
+                dist_dir = self.project_root / "dist"
+                if dist_dir.exists():
+                    wheel_files = list(dist_dir.glob("*.whl"))
+                    if wheel_files:
+                        import zipfile
+                        wheel_file = wheel_files[0]
+                        try:
+                            with zipfile.ZipFile(wheel_file, "r") as wheel:
+                                file_names = wheel.namelist()
+                                package_files = [f for f in file_names if f.startswith(f"{import_name}/")]
+                                if not package_files:
+                                    print(
+                                        f"\nWARNING: Built wheel does not contain package directory '{import_name}/'. "
+                                        f"Only found: {[f for f in file_names if '.dist-info' not in f][:10]}",
+                                        file=sys.stderr,
+                                    )
+                                else:
+                                    print(
+                                        f"\nVerified wheel contains package directory '{import_name}/' "
+                                        f"with {len(package_files)} files"
+                                    )
+                        except Exception as e:
+                            print(
+                                f"\nWARNING: Could not verify wheel contents: {e}",
+                                file=sys.stderr,
+                            )
 
         finally:
             print("\nCleaning up copied files...")

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

@@ -130,8 +130,8 @@ class SubfolderBuildConfig:
         The package name (with hyphens) is converted to the import name (with underscores).
         For example: 'ml-drawing-assistant-data' -> 'ml_drawing_assistant_data'
         
-        The temporary directory is created in the project root and contains a copy
-        of the source directory contents.
+        The temporary directory is created in the project root with the import name directly.
+        This way, hatchling will install it with the correct name without needing force-include.
         """
         if not self.package_name:
             return
@@ -140,20 +140,42 @@ class SubfolderBuildConfig:
         # PyPI package names use hyphens, but Python import names use underscores
         import_name = self.package_name.replace("-", "_")
         
-        # Create temporary directory name
-        temp_dir_name = f".temp_package_{import_name}"
-        temp_package_dir = self.project_root / temp_dir_name
+        # Create temporary directory with the import name directly
+        # This way, hatchling will install it with the correct name
+        import_name_dir = self.project_root / import_name
         
-        # Remove if it already exists (from a previous failed build)
-        if temp_package_dir.exists():
-            shutil.rmtree(temp_package_dir)
+        # 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
+            return
+        
+        # Remove if it already exists (from a previous build)
+        if import_name_dir.exists():
+            shutil.rmtree(import_name_dir)
+        
+        # Copy the entire source directory contents directly to the import name directory
+        # Check if src_dir exists and is a directory before copying
+        if not self.src_dir.exists():
+            print(
+                f"Warning: Source directory does not exist: {self.src_dir}",
+                file=sys.stderr,
+            )
+            self._temp_package_dir = None
+            return
+        
+        if not self.src_dir.is_dir():
+            print(
+                f"Warning: Source path is not a directory: {self.src_dir}",
+                file=sys.stderr,
+            )
+            self._temp_package_dir = None
+            return
         
-        # Copy the entire source directory contents to the temporary directory
         try:
-            shutil.copytree(self.src_dir, temp_package_dir)
-            self._temp_package_dir = temp_package_dir
+            shutil.copytree(self.src_dir, import_name_dir)
+            self._temp_package_dir = import_name_dir
             print(
-                f"Created temporary package directory: {temp_package_dir} "
+                f"Created temporary package directory: {import_name_dir} "
                 f"(import name: {import_name})"
             )
         except Exception as e:
@@ -344,6 +366,116 @@ class SubfolderBuildConfig:
         if not self.version:
             raise ValueError("Version is required for subfolder builds")
 
+        # Check if pyproject.toml exists in subfolder FIRST
+        # This allows us to handle subfolder pyproject.toml even when parent doesn't exist
+        # But first ensure src_dir exists
+        if not self.src_dir.exists() or not self.src_dir.is_dir():
+            # If src_dir doesn't exist, we can't proceed
+            print(
+                f"Warning: Source directory does not exist or is not a directory: {self.src_dir}",
+                file=sys.stderr,
+            )
+            return None
+        
+        subfolder_pyproject = self.src_dir / "pyproject.toml"
+        if subfolder_pyproject.exists() and subfolder_pyproject.is_file():
+            # Read the subfolder pyproject.toml content IMMEDIATELY after checking it exists
+            # This prevents any issues if the file is affected by subsequent operations
+            try:
+                subfolder_content = subfolder_pyproject.read_text(encoding="utf-8")
+            except (FileNotFoundError, OSError) as e:
+                # File was deleted or inaccessible between check and read
+                print(
+                    f"Warning: Could not read subfolder pyproject.toml at {subfolder_pyproject}: {e}. "
+                    "Falling back to creating from parent.",
+                    file=sys.stderr,
+                )
+                subfolder_content = None
+            
+            if subfolder_content is not None:
+                # Ensure src_dir is a package (has __init__.py) before creating temp directory
+                # This way the __init__.py will be copied to the temp directory
+                init_file = self.src_dir / "__init__.py"
+                if not init_file.exists():
+                    # Create a temporary __init__.py to make it a package
+                    init_file.write_text("# Temporary __init__.py for build\n", encoding="utf-8")
+                    self._temp_init_created = True
+                else:
+                    self._temp_init_created = False
+
+                # Create temporary package directory with correct import name
+                # This will copy the __init__.py we just created (if any)
+                self._create_temp_package_directory()
+                
+                # 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
+                print(f"Using existing pyproject.toml from subfolder: {subfolder_pyproject}")
+                self._used_subfolder_pyproject = True
+
+                # Store reference to original project root pyproject.toml
+                original_pyproject = self.project_root / "pyproject.toml"
+                self.original_pyproject_path = original_pyproject
+
+                # Create temporary pyproject.toml file
+                temp_pyproject_path = self.project_root / "pyproject.toml.temp"
+
+                # Adjust packages path to be relative to project root
+                adjusted_content = self._adjust_subfolder_pyproject_packages_path(subfolder_content)
+                
+                # Read exclude patterns from root pyproject.toml and inject them (if it exists)
+                exclude_patterns = []
+                if original_pyproject.exists():
+                    exclude_patterns = read_exclude_patterns(original_pyproject)
+                    print(
+                        f"INFO: Read exclude patterns from {original_pyproject}: {exclude_patterns}",
+                        file=sys.stderr,
+                    )
+                else:
+                    print(
+                        f"INFO: No parent pyproject.toml found at {original_pyproject}, skipping exclude patterns",
+                        file=sys.stderr,
+                    )
+                if exclude_patterns:
+                    adjusted_content = self._inject_exclude_patterns(adjusted_content, exclude_patterns)
+
+                # Write adjusted content to temporary file
+                temp_pyproject_path.write_text(adjusted_content, encoding="utf-8")
+                self.temp_pyproject = temp_pyproject_path
+
+                # Print the temporary pyproject.toml content for debugging
+                print("\n" + "=" * 80)
+                print("Temporary pyproject.toml content (from subfolder pyproject.toml):")
+                print("=" * 80)
+                print(adjusted_content)
+                print("=" * 80 + "\n")
+
+                # If original pyproject.toml exists, temporarily move it
+                if original_pyproject.exists():
+                    backup_path = self.project_root / "pyproject.toml.original"
+                    # Remove backup if it already exists (from previous failed test or run)
+                    if backup_path.exists():
+                        backup_path.unlink()
+                    original_pyproject.rename(backup_path)
+                    self.original_pyproject_backup = backup_path
+
+                # Move temp file to pyproject.toml for the build
+                temp_pyproject_path.rename(original_pyproject)
+                self.temp_pyproject = original_pyproject
+
+                # Handle README file
+                self._handle_readme()
+
+                # Exclude files matching exclude patterns
+                if exclude_patterns:
+                    self._exclude_files_by_patterns(exclude_patterns)
+
+                return original_pyproject
+
+        # No pyproject.toml in subfolder, create one from parent
+        self._used_subfolder_pyproject = False
+        print("No pyproject.toml found in subfolder, creating temporary one from parent")
+
         # Ensure src_dir is a package (has __init__.py) before creating temp directory
         # This way the __init__.py will be copied to the temp directory
         init_file = self.src_dir / "__init__.py"
@@ -361,71 +493,6 @@ class SubfolderBuildConfig:
         # 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
 
-        # Check if pyproject.toml exists in subfolder
-        subfolder_pyproject = self.src_dir / "pyproject.toml"
-        if subfolder_pyproject.exists():
-            # Use the subfolder's pyproject.toml
-            print(f"Using existing pyproject.toml from subfolder: {subfolder_pyproject}")
-            self._used_subfolder_pyproject = True
-
-            # Store reference to original project root pyproject.toml
-            original_pyproject = self.project_root / "pyproject.toml"
-            self.original_pyproject_path = original_pyproject
-
-            # Create temporary pyproject.toml file
-            temp_pyproject_path = self.project_root / "pyproject.toml.temp"
-
-            # Read and adjust the subfolder pyproject.toml
-            subfolder_content = subfolder_pyproject.read_text(encoding="utf-8")
-            # Adjust packages path to be relative to project root
-            adjusted_content = self._adjust_subfolder_pyproject_packages_path(subfolder_content)
-            
-            # Read exclude patterns from root pyproject.toml and inject them
-            exclude_patterns = read_exclude_patterns(original_pyproject)
-            print(
-                f"INFO: Read exclude patterns from {original_pyproject}: {exclude_patterns}",
-                file=sys.stderr,
-            )
-            if exclude_patterns:
-                adjusted_content = self._inject_exclude_patterns(adjusted_content, exclude_patterns)
-
-            # Write adjusted content to temporary file
-            temp_pyproject_path.write_text(adjusted_content, encoding="utf-8")
-            self.temp_pyproject = temp_pyproject_path
-
-            # Print the temporary pyproject.toml content for debugging
-            print("\n" + "=" * 80)
-            print("Temporary pyproject.toml content (from subfolder pyproject.toml):")
-            print("=" * 80)
-            print(adjusted_content)
-            print("=" * 80 + "\n")
-
-            # If original pyproject.toml exists, temporarily move it
-            if original_pyproject.exists():
-                backup_path = self.project_root / "pyproject.toml.original"
-                # Remove backup if it already exists (from previous failed test or run)
-                if backup_path.exists():
-                    backup_path.unlink()
-                original_pyproject.rename(backup_path)
-                self.original_pyproject_backup = backup_path
-
-            # Move temp file to pyproject.toml for the build
-            temp_pyproject_path.rename(original_pyproject)
-            self.temp_pyproject = original_pyproject
-
-            # Handle README file
-            self._handle_readme()
-
-            # Exclude files matching exclude patterns
-            if exclude_patterns:
-                self._exclude_files_by_patterns(exclude_patterns)
-
-            return original_pyproject
-
-        # No pyproject.toml in subfolder, create one from parent
-        self._used_subfolder_pyproject = False
-        print("No pyproject.toml found in subfolder, creating temporary one from parent")
-
         # Read the original pyproject.toml
         original_pyproject = self.project_root / "pyproject.toml"
         if not original_pyproject.exists():

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

@@ -2,11 +2,16 @@
 
 from __future__ import annotations
 
+import subprocess
+import sys
+import tempfile
+import venv
+import zipfile
 from pathlib import Path
 
 import pytest
 
-from python_package_folder import SubfolderBuildConfig
+from python_package_folder import BuildManager, SubfolderBuildConfig
 
 
 @pytest.fixture
@@ -683,8 +688,8 @@ class TestSubfolderBuildTemporaryPyprojectCreation:
         assert "[tool.hatch.version]" not in content
         assert "[tool.uv-dynamic-versioning]" not in content
 
-        # Verify packages path is set correctly (should use temp package directory)
-        assert '.temp_package_my_custom_package' in content
+        # Verify packages path is set correctly (should use import name, not temp directory name)
+        assert '"my_custom_package"' in content or "'my_custom_package'" in content
 
         # Verify backup was created
         assert (project_root / "pyproject.toml.original").exists()
@@ -734,8 +739,9 @@ class TestSubfolderBuildTemporaryPyprojectCreation:
         # Verify only-include is present
         assert "only-include = [" in content
 
-        # Verify the temp package directory is included (not the original subfolder)
-        assert '.temp_package_test_package' in content
+        # Verify the import name is used in packages configuration (not the original subfolder)
+        # The temp directory is renamed to the import name, so packages should use that
+        assert '"test_package"' in content or "'test_package'" in content
 
         # Verify necessary files are included
         assert '"pyproject.toml"' in content
@@ -975,8 +981,9 @@ class TestTemporaryPackageDirectory:
         # Create temp pyproject (which creates temp package directory)
         config.create_temp_pyproject()
 
-        # Temp package directory should exist with import name (underscores)
-        temp_package_dir = project_root / ".temp_package_test_package_subfolder"
+        # Temp package directory should exist with import name (underscores, no temp prefix)
+        import_name = "test_package_subfolder"  # Import name from "test-package-subfolder"
+        temp_package_dir = project_root / import_name
         assert temp_package_dir.exists()
         assert config._temp_package_dir == temp_package_dir
 
@@ -1003,8 +1010,9 @@ class TestTemporaryPackageDirectory:
 
         config.create_temp_pyproject()
 
-        # Temp directory should use underscores (import name)
-        temp_package_dir = project_root / ".temp_package_my_custom_package"
+        # Temp directory should use underscores (import name, no temp prefix)
+        import_name = "my_custom_package"  # Import name from "my-custom-package"
+        temp_package_dir = project_root / import_name
         assert temp_package_dir.exists()
         assert config._temp_package_dir == temp_package_dir
 
@@ -1055,9 +1063,9 @@ class TestTemporaryPackageDirectory:
 
         content = pyproject_path.read_text()
 
-        # Packages configuration should use temp directory path
-        # Temp directory name is ".temp_package_test_package_subfolder"
-        assert ".temp_package_test_package_subfolder" in content
+        # Packages configuration should use import name (temp directory is renamed to import name)
+        # Import name is "test_package_subfolder" (from "test-package-subfolder")
+        assert '"test_package_subfolder"' in content or "'test_package_subfolder'" in content
 
         config.restore()
 
@@ -1098,8 +1106,9 @@ class TestTemporaryPackageDirectory:
         subfolder = project_root / "subfolder"
         (subfolder / "module.py").write_text("def func(): pass")
 
-        # Create a directory that would conflict
-        existing_temp_dir = project_root / ".temp_package_test_package_subfolder"
+        # Create a directory that would conflict (using import name directly)
+        import_name = "test_package_subfolder"  # Import name from "test-package-subfolder"
+        existing_temp_dir = project_root / import_name
         existing_temp_dir.mkdir()
         (existing_temp_dir / "old_file.py").write_text("# Old file")
 
@@ -1119,4 +1128,229 @@ class TestTemporaryPackageDirectory:
         assert (temp_package_dir / "module.py").exists()
         assert not (temp_package_dir / "old_file.py").exists()
 
-        config.restore()
+        config.restore()
+
+
+class TestWheelPackaging:
+    """Tests to verify that wheels are correctly packaged with the right directory structure."""
+
+    def test_wheel_contains_package_directory_with_correct_name(self, tmp_path: Path) -> None:
+        """Test that a built wheel contains the package directory with the correct import name."""
+        project_root = tmp_path / "test_project"
+        project_root.mkdir()
+
+        # Create 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 package name that has hyphens
+        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'")
+        (subfolder / "utils.py").write_text("def util(): return 'helper'")
+
+        # 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=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:
+            # run_build will call prepare_build internally, so we don't need to call it explicitly
+            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:
+            # Get all file names in the wheel
+            file_names = wheel.namelist()
+            
+            # Debug: Print all files to understand what's in the wheel
+            print(f"\nWheel contents ({len(file_names)} files):")
+            for f in sorted(file_names)[:20]:
+                print(f"  {f}")
+            if len(file_names) > 20:
+                print(f"  ... and {len(file_names) - 20} more files")
+            
+            # Verify the package directory exists with the correct import name
+            # The package should be installed as ml_drawing_assistant_data/, not .temp_package_ml_drawing_assistant_data/
+            package_dir_prefix = f"{import_name}/"
+            package_files = [f for f in file_names if f.startswith(package_dir_prefix)]
+            
+            # Also check for temp directory name (should NOT be present)
+            temp_dir_prefix = ".temp_package_"
+            temp_dir_files = [f for f in file_names if temp_dir_prefix in f and ".dist-info" not in f]
+            
+            assert len(package_files) > 0, (
+                f"Wheel should contain files in {import_name}/ directory. "
+                f"Found {len(file_names)} total files. "
+                f"Files with '/' in name: {[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"
+            )
+            assert f"{import_name}/utils.py" in file_names, (
+                f"Wheel should contain {import_name}/utils.py"
+            )
+            
+            # Verify the .dist-info folder exists
+            dist_info_files = [f for f in file_names if ".dist-info" in f]
+            assert len(dist_info_files) > 0, "Wheel should contain .dist-info files"
+            
+            # Verify the temp directory name is NOT in the wheel
+            assert len(temp_dir_files) == 0, (
+                f"Wheel should not contain temp directory files. Found: {temp_dir_files[:5]}"
+            )
+            
+            # Verify the original subfolder name is NOT in the wheel (if different from import name)
+            if "data/" in file_names and import_name != "data":
+                # Only check if data/ would be different from the 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"
+                )
+
+    def test_wheel_installs_with_correct_package_directory(self, tmp_path: Path) -> None:
+        """Test that a built wheel can be installed and the package directory exists."""
+        project_root = tmp_path / "test_project"
+        project_root.mkdir()
+
+        # Create 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 package name that has hyphens
+        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'")
+        (subfolder / "utils.py").write_text("def util(): return 'helper'")
+
+        # 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=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]
+        
+        # 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=True,
+        )
+        
+        # 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
+        assert (package_dir / "__init__.py").exists(), f"{import_name}/__init__.py should exist"
+        assert (package_dir / "module.py").exists(), f"{import_name}/module.py should exist"
+        assert (package_dir / "utils.py").exists(), f"{import_name}/utils.py should exist"
+        
+        # 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}"