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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 8.1.0
+Version: 8.3.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.3.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">67%</text>
-    <text x="81" y="14">67%</text>
+    <text x="81" y="15" fill="#010101" fill-opacity=".3">66%</text>
+    <text x="81" y="14">66%</text>
   </g>
 </svg>

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

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

{python_package_folder-8.1.0 → python_package_folder-8.3.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.3.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}"
@@ -773,6 +777,9 @@ class BuildManager:
         1. Imports of copied dependencies (e.g., `from _shared.image_utils` -> `from ._shared.image_utils`)
         2. Imports of local files within the subfolder (e.g., `from detect_empty_drawings_utils` -> `from .detect_empty_drawings_utils`)
 
+        Only imports classified as "external" or "local" are converted. Imports classified
+        as "ambiguous", "third_party", or "stdlib" are left unchanged.
+
         Args:
             python_files: List of Python files in the source directory
             external_deps: List of external dependencies that were copied
@@ -780,6 +787,9 @@ class BuildManager:
         import ast
         import re
 
+        # Create analyzer for classifying imports
+        analyzer = ImportAnalyzer(self.project_root)
+
         # Build a set of import names that were copied
         copied_import_names: set[str] = set()
         for dep in external_deps:
@@ -834,7 +844,22 @@ class BuildManager:
                         if node.module is None:
                             continue
 
+                        # Classify the import to determine if it should be converted
+                        import_info = ImportInfo(
+                            module_name=node.module,
+                            import_type="from",
+                            line_number=node.lineno,
+                            file_path=file_path,
+                        )
+                        analyzer.classify_import(import_info, self.src_dir)
+
+                        # Only convert imports classified as "external" or "local"
+                        # Skip ambiguous, third_party, and stdlib imports
+                        if import_info.classification not in ("external", "local"):
+                            continue
+
                         # Check if this import matches a copied dependency or a local file
+                        # (additional safety check, but classification takes precedence)
                         root_module = node.module.split(".")[0]
                         is_copied_dependency = (
                             root_module in copied_import_names or node.module in copied_import_names
@@ -870,6 +895,22 @@ class BuildManager:
                     elif isinstance(node, ast.Import):
                         # Handle "import X" statements
                         for alias in node.names:
+                            # Classify the import to determine if it should be converted
+                            import_info = ImportInfo(
+                                module_name=alias.name,
+                                import_type="import",
+                                line_number=node.lineno,
+                                file_path=file_path,
+                            )
+                            analyzer.classify_import(import_info, self.src_dir)
+
+                            # Only convert imports classified as "external" or "local"
+                            # Skip ambiguous, third_party, and stdlib imports
+                            if import_info.classification not in ("external", "local"):
+                                continue
+
+                            # Check if this import matches a copied dependency or a local file
+                            # (additional safety check, but classification takes precedence)
                             root_module = alias.name.split(".")[0]
                             is_copied_dependency = root_module in copied_import_names
                             is_local_file = root_module in local_file_names

{python_package_folder-8.1.0 → python_package_folder-8.3.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."""
@@ -1821,4 +1909,193 @@ only-include = ["src/data", "pyproject.toml", "README.md"]
             # 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
+            # The wheel packaging verification above is the main test
+
+
+class TestImportConversion:
+    """Tests to verify that import conversion respects classification."""
+
+    def test_third_party_imports_not_converted_to_relative(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """
+        Test that third-party imports (like torch, torchvision) are NOT converted
+        to relative imports, even if they match local file names.
+        """
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+
+        # Create a module that imports third-party packages
+        (subfolder / "__init__.py").write_text("# Package init")
+        (subfolder / "module.py").write_text(
+            """import torch
+import torch.utils.data
+from torchvision import datasets
+import numpy as np
+from PIL import Image
+"""
+        )
+
+        # Build the subfolder
+        manager = BuildManager(project_root=project_root, src_dir=subfolder)
+
+        try:
+            manager.prepare_build(version="1.0.0", package_name="my-package")
+
+            # 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()
+
+            # Read the modified file
+            modified_content = (temp_dir / "module.py").read_text(encoding="utf-8")
+
+            # Verify third-party imports were NOT converted to relative imports
+            assert "import torch" in modified_content, (
+                "torch import should remain absolute, not converted to relative"
+            )
+            assert "import torch.utils.data" in modified_content or "from torch.utils import data" in modified_content, (
+                "torch.utils.data import should remain absolute"
+            )
+            assert "from torchvision import datasets" in modified_content, (
+                "torchvision import should remain absolute, not converted to relative"
+            )
+            assert "import numpy as np" in modified_content, (
+                "numpy import should remain absolute"
+            )
+            assert "from PIL import Image" in modified_content, (
+                "PIL import should remain absolute"
+            )
+
+            # Verify NO relative imports were added for these third-party packages
+            assert "from . import torch" not in modified_content, (
+                "torch should NOT be converted to relative import"
+            )
+            assert "from .torchvision import" not in modified_content, (
+                "torchvision should NOT be converted to relative import"
+            )
+            assert "from . import numpy" not in modified_content, (
+                "numpy should NOT be converted to relative import"
+            )
+
+        finally:
+            manager.cleanup()
+
+    def test_ambiguous_imports_not_converted_to_relative(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """
+        Test that ambiguous imports (like time, math) are NOT converted
+        to relative imports, even if they match local file names.
+        """
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+
+        # Create a module that imports standard library modules
+        # (which may be classified as ambiguous if not in stdlib list)
+        (subfolder / "__init__.py").write_text("# Package init")
+        (subfolder / "module.py").write_text(
+            """import time
+import math
+from datetime import datetime
+import os
+import sys
+"""
+        )
+
+        # Build the subfolder
+        manager = BuildManager(project_root=project_root, src_dir=subfolder)
+
+        try:
+            manager.prepare_build(version="1.0.0", package_name="my-package")
+
+            # 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()
+
+            # Read the modified file
+            modified_content = (temp_dir / "module.py").read_text(encoding="utf-8")
+
+            # Verify stdlib/ambiguous imports were NOT converted to relative imports
+            assert "import time" in modified_content, (
+                "time import should remain absolute, not converted to relative"
+            )
+            assert "import math" in modified_content, (
+                "math import should remain absolute, not converted to relative"
+            )
+            assert "from datetime import datetime" in modified_content, (
+                "datetime import should remain absolute"
+            )
+            assert "import os" in modified_content, (
+                "os import should remain absolute"
+            )
+            assert "import sys" in modified_content, (
+                "sys import should remain absolute"
+            )
+
+            # Verify NO relative imports were added for these stdlib modules
+            assert "from . import time" not in modified_content, (
+                "time should NOT be converted to relative import"
+            )
+            assert "from . import math" not in modified_content, (
+                "math should NOT be converted to relative import"
+            )
+            assert "from .datetime import" not in modified_content, (
+                "datetime should NOT be converted to relative import"
+            )
+
+        finally:
+            manager.cleanup()
+
+    def test_external_imports_are_converted_to_relative(
+        self, test_project_with_pyproject: Path
+    ) -> None:
+        """
+        Test that external imports (from copied dependencies) ARE converted
+        to relative imports.
+        """
+        project_root = test_project_with_pyproject
+        subfolder = project_root / "subfolder"
+
+        # Create an external dependency
+        external_dir = project_root / "src" / "_shared"
+        external_dir.mkdir(parents=True)
+        (external_dir / "__init__.py").write_text("# External shared module")
+        (external_dir / "utils.py").write_text("def helper(): return 'help'")
+
+        # Create a module that imports the external dependency
+        (subfolder / "__init__.py").write_text("# Package init")
+        (subfolder / "module.py").write_text(
+            "from _shared.utils import helper\n\ndef func(): return helper()"
+        )
+
+        # 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 external dependency was found and copied
+            assert len(external_deps) > 0, "External dependency should be found"
+
+            # 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()
+
+            # Read the modified file
+            modified_content = (temp_dir / "module.py").read_text(encoding="utf-8")
+
+            # Verify external import WAS converted to relative import
+            assert "from ._shared.utils import helper" in modified_content, (
+                "External import should be converted to relative import"
+            )
+            assert "from _shared.utils import helper" not in modified_content or (
+                "from ._shared.utils import helper" in modified_content
+            ), (
+                "Original absolute import should be replaced with relative import"
+            )
+
+        finally:
+            manager.cleanup()