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

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

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

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

{python_package_folder-8.1.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.1.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}"

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

@@ -1209,6 +1209,94 @@ class TestTemporaryPackageDirectory:
         
         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."""