python-package-folder 8.0.0__tar.gz → 8.2.0__tar.gz

{python_package_folder-8.0.0 → python_package_folder-8.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 8.0.0
+Version: 8.2.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-8.0.0 → python_package_folder-8.2.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">66%</text>
-    <text x="81" y="14">66%</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-8.0.0 → python_package_folder-8.2.0}/pyproject.toml

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

{python_package_folder-8.0.0 → python_package_folder-8.2.0}/src/python_package_folder/finder.py

@@ -29,18 +29,26 @@ class ExternalDependencyFinder:
     """
 
     def __init__(
-        self, project_root: Path, src_dir: Path, exclude_patterns: list[str] | None = None
+        self,
+        project_root: Path,
+        src_dir: Path,
+        exclude_patterns: list[str] | None = None,
+        original_src_dir: Path | None = None,
     ) -> None:
         """
         Initialize the dependency finder.
 
         Args:
             project_root: Root directory of the project
-            src_dir: Source directory to analyze
+            src_dir: Source directory to analyze (may be temp directory for subfolder builds)
             exclude_patterns: Additional patterns to exclude (default: common sandbox patterns)
+            original_src_dir: Original source directory before any changes (e.g., before temp directory creation).
+                Used for relative path checks. If not provided, uses src_dir.
         """
         self.project_root = project_root.resolve()
         self.src_dir = src_dir.resolve()
+        # Store original src_dir for relative path checks (important for subfolder builds)
+        self.original_src_dir = (original_src_dir or src_dir).resolve()
         self.analyzer = ImportAnalyzer(project_root)
         # Patterns for directories/files to exclude (sandbox, skip, etc.)
         default_patterns = [
@@ -90,34 +98,43 @@ class ExternalDependencyFinder:
                     if source_path.is_file():
                         parent_dir = source_path.parent
 
-                        # Only copy parent directory if:
-                        # 1. It's a package (has __init__.py), OR
-                        # 2. Files from it are actually imported (which is the case here)
-                        # But only copy the immediate parent, not entire directory trees
-                        parent_is_package = (parent_dir / "__init__.py").exists()
-                        files_are_imported = True  # Always true when processing an import
-
-                        # Only copy immediate parent directory, not grandparent directories
-                        # This prevents copying entire trees like models/Information_extraction
-                        # when we only need models/Information_extraction/_shared_ie
-                        should_copy_dir = (
-                            not self._should_exclude_path(parent_dir)
-                            and (
-                                parent_is_package or files_are_imported
-                            )  # Package OR files imported
-                            and not parent_dir.is_relative_to(self.src_dir)
-                            and not self.src_dir.is_relative_to(parent_dir)
-                            and parent_dir != self.project_root
-                            and parent_dir != self.project_root.parent
-                        )
-
-                        if should_copy_dir:
-                            # Copy the directory instead of just the file
-                            track_path = parent_dir
-                            source_path = parent_dir
-                        else:
-                            # Copy just the file
+                        # Never copy the src/ directory itself - only copy individual files at its root
+                        # This prevents copying the entire src/ directory (with all subdirectories)
+                        # when only a file like _globals.py is needed
+                        if parent_dir == self.project_root / "src":
+                            # For files at root of src/, only copy the file, not the directory
                             track_path = source_path
+                        else:
+                            # Only copy parent directory if:
+                            # 1. It's a package (has __init__.py), OR
+                            # 2. Files from it are actually imported (which is the case here)
+                            # But only copy the immediate parent, not entire directory trees
+                            parent_is_package = (parent_dir / "__init__.py").exists()
+                            files_are_imported = True  # Always true when processing an import
+
+                            # Only copy immediate parent directory, not grandparent directories
+                            # This prevents copying entire trees like models/Information_extraction
+                            # when we only need models/Information_extraction/_shared_ie
+                            # Use original_src_dir for relative path checks to correctly handle
+                            # subfolder builds where src_dir may point to temp directory
+                            should_copy_dir = (
+                                not self._should_exclude_path(parent_dir)
+                                and (
+                                    parent_is_package or files_are_imported
+                                )  # Package OR files imported
+                                and not parent_dir.is_relative_to(self.src_dir)
+                                and not self.original_src_dir.is_relative_to(parent_dir)
+                                and parent_dir != self.project_root
+                                and parent_dir != self.project_root.parent
+                            )
+
+                            if should_copy_dir:
+                                # Copy the directory instead of just the file
+                                track_path = parent_dir
+                                source_path = parent_dir
+                            else:
+                                # Copy just the file
+                                track_path = source_path
                     elif source_path.is_dir():
                         # Don't copy directories that contain src_dir
                         if self.src_dir.is_relative_to(source_path):

{python_package_folder-8.0.0 → python_package_folder-8.2.0}/src/python_package_folder/manager.py

@@ -71,6 +71,8 @@ class BuildManager:
                 src_dir = self.project_root / "src"
 
         self.src_dir = Path(src_dir).resolve()
+        # Store original src_dir before any changes (e.g., when temp directory is created)
+        self.original_src_dir = self.src_dir
 
         # Validate source directory
         if not self.src_dir.exists():
@@ -280,10 +282,12 @@ class BuildManager:
                     # Update src_dir to point to temp package directory
                     self.src_dir = self.subfolder_config._temp_package_dir
                     # Recreate finder with updated src_dir so it calculates target paths correctly
+                    # Pass original_src_dir for relative path checks to prevent copying entire src/ directory
                     self.finder = ExternalDependencyFinder(
                         self.project_root,
                         self.src_dir,
                         exclude_patterns=self.exclude_patterns,
+                        original_src_dir=self.original_src_dir,
                     )
                     print(
                         f"Using temporary package directory for build: {self.src_dir}"
@@ -1153,12 +1157,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-8.0.0 → python_package_folder-8.2.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
@@ -518,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-8.0.0 → python_package_folder-8.2.0}/tests/test_subfolder_build.py

@@ -1130,6 +1130,173 @@ 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()
+
+    def test_only_globals_file_copied_not_entire_src_directory(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """
+        Test that when a subfolder imports a file from src/ root (like _globals.py),
+        only that file is copied, not the entire src/ directory.
+        
+        This is a regression test for the bug where the entire src/ directory
+        (including features/, integration/, docs/, infrastructure/) was being
+        copied when only _globals.py was needed.
+        """
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+        
+        # Create a file in subfolder that imports _globals
+        (subfolder / "__init__.py").write_text("# Package init")
+        (subfolder / "module.py").write_text(
+            "from _globals import IS_TESTING\n\ndef func(): return IS_TESTING"
+        )
+        
+        # Create _globals.py at root of src/ (outside subfolder)
+        src_dir = project_root / "src"
+        src_dir.mkdir(exist_ok=True)
+        (src_dir / "_globals.py").write_text("IS_TESTING = False")
+        
+        # Create other directories in src/ that should NOT be copied
+        (src_dir / "features").mkdir()
+        (src_dir / "features" / "__init__.py").write_text("# Features")
+        (src_dir / "features" / "feature.py").write_text("def feature(): pass")
+        
+        (src_dir / "integration").mkdir()
+        (src_dir / "integration" / "__init__.py").write_text("# Integration")
+        (src_dir / "integration" / "integration.py").write_text("def integration(): pass")
+        
+        (src_dir / "docs").mkdir()
+        (src_dir / "docs" / "readme.md").write_text("# Docs")
+        
+        (src_dir / "infrastructure").mkdir()
+        (src_dir / "infrastructure" / "__init__.py").write_text("# Infrastructure")
+        
+        # Build the subfolder
+        manager = BuildManager(project_root=project_root, src_dir=subfolder)
+        
+        try:
+            external_deps = manager.prepare_build(version="1.0.0", package_name="my-package")
+            
+            # Verify _globals.py was found as an external dependency
+            globals_deps = [d for d in external_deps if d.source_path.name == "_globals.py"]
+            assert len(globals_deps) > 0, "_globals.py should be found as an external dependency"
+            
+            # Verify the temp package directory exists
+            assert manager.subfolder_config is not None
+            temp_dir = manager.subfolder_config._temp_package_dir
+            assert temp_dir is not None and temp_dir.exists()
+            
+            # Verify _globals.py was copied to temp directory
+            assert (temp_dir / "_globals.py").exists(), "_globals.py should be copied to temp directory"
+            
+            # Verify other directories from src/ were NOT copied
+            assert not (temp_dir / "features").exists(), (
+                "features/ directory should NOT be copied (not imported)"
+            )
+            assert not (temp_dir / "integration").exists(), (
+                "integration/ directory should NOT be copied (not imported)"
+            )
+            assert not (temp_dir / "docs").exists(), (
+                "docs/ directory should NOT be copied (not imported)"
+            )
+            assert not (temp_dir / "infrastructure").exists(), (
+                "infrastructure/ directory should NOT be copied (not imported)"
+            )
+            
+            # Verify only _globals.py and subfolder contents are in temp directory
+            all_items = list(temp_dir.iterdir())
+            item_names = [item.name for item in all_items]
+            
+            # Should have _globals.py, __init__.py, module.py, and possibly pyproject.toml
+            # But NOT features/, integration/, docs/, infrastructure/
+            unexpected_dirs = {"features", "integration", "docs", "infrastructure"}
+            found_unexpected = unexpected_dirs.intersection(set(item_names))
+            assert len(found_unexpected) == 0, (
+                f"Found unexpected directories in temp package: {found_unexpected}. "
+                f"Only _globals.py should be copied, not the entire src/ directory."
+            )
+            
+        finally:
+            manager.cleanup()
+
 
 class TestWheelPackaging:
     """Tests to verify that wheels are correctly packaged with the right directory structure."""