python-package-folder 2.0.7__tar.gz → 3.0.0__tar.gz

{python_package_folder-2.0.7 → python_package_folder-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 2.0.7
+Version: 3.0.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-2.0.7 → python_package_folder-3.0.0}/src/python_package_folder/finder.py

@@ -151,8 +151,8 @@ class ExternalDependencyFinder:
         """
         Determine where an external file should be copied within src_dir.
 
-        For files, attempts to maintain the module structure. For directories,
-        places them directly in src_dir with their original name.
+        Preserves the original directory structure relative to project_root or src
+        to maintain import paths like `from models. ...` or `from data. ...`.
 
         Args:
             source_path: Path to the source file or directory
@@ -164,31 +164,69 @@ class ExternalDependencyFinder:
         if not source_path.exists():
             return None
 
-        # Always create target within src_dir
         module_parts = module_name.split(".")
 
-        if source_path.is_file():
-            # For a file, create the directory structure based on module name
-            if len(module_parts) > 1:
-                # It's a submodule, create the directory structure
-                target = self.src_dir / "/".join(module_parts[:-1]) / source_path.name
+        # Determine the base directory for calculating relative paths
+        # If source is under src/, use src/ as base to preserve structure
+        src_base = self.project_root / "src"
+        if src_base.exists() and source_path.is_relative_to(src_base):
+            # Source is under src/, preserve the path structure relative to src/
+            # This ensures imports like `from models. ...` work correctly
+            try:
+                relative_path = source_path.relative_to(src_base)
+                target = self.src_dir / relative_path
+                return target
+            except ValueError:
+                pass
+
+        # For sources not under src/, try to preserve structure based on module name
+        # Check if the module name structure matches the source path structure
+        if len(module_parts) > 1:
+            # For directories, check if the module path (excluding the last part for files) matches
+            if source_path.is_dir():
+                # For directories, check if module parts match the directory structure
+                # e.g., module "folder_structure.utility_folder.some_utility" with dir "folder_structure/utility_folder"
+                # should preserve "folder_structure/utility_folder" structure
+                # Calculate relative path from project_root
+                try:
+                    relative_path = source_path.relative_to(self.project_root)
+                    # If the module starts with the same parts as the relative path, preserve structure
+                    relative_parts = list(relative_path.parts)
+                    # Check if module_parts[:-1] (excluding the file/module name) matches relative_parts
+                    if len(module_parts) > len(relative_parts):
+                        # Module has more parts (includes the file name), check if the directory parts match
+                        module_dir_parts = module_parts[: len(relative_parts)]
+                        if module_dir_parts == relative_parts:
+                            # Preserve the full structure
+                            target = self.src_dir / relative_path
+                            return target
+                    # Try matching from the end
+                    if len(relative_parts) <= len(module_parts):
+                        # Check if the last parts of module match the relative path
+                        for i in range(1, min(len(relative_parts), len(module_parts)) + 1):
+                            if module_parts[-i:] == relative_parts[-i:]:
+                                # Match found, preserve structure based on module name
+                                target = self.src_dir / "/".join(
+                                    module_parts[: -i + 1 if i > 1 else len(module_parts)]
+                                )
+                                return target
+                except ValueError:
+                    pass
+                # Fallback: preserve structure based on module name (excluding last part for files)
+                target = self.src_dir / "/".join(module_parts[:-1])
+                return target
             else:
-                # Top-level module - try to find the main package directory
-                # or create a matching structure
-                main_pkg = self._find_main_package()
-                if main_pkg:
-                    target = main_pkg / source_path.name
-                else:
-                    target = self.src_dir / source_path.name
-            return target
-
-        # If it's a directory, copy the whole directory
-        if source_path.is_dir():
-            # Use the directory name directly in src_dir
-            target = self.src_dir / source_path.name
-            return target
+                # For files, preserve structure based on module name (excluding filename)
+                target = self.src_dir / "/".join(module_parts[:-1]) / source_path.name
+                return target
 
-        return None
+        # Simple top-level import - copy directly to src_dir
+        # This handles cases like `from some_globals import ...`
+        if source_path.is_file():
+            target = self.src_dir / source_path.name
+        else:
+            target = self.src_dir / source_path.name
+        return target
 
     def _should_exclude_path(self, path: Path) -> bool:
         """

{python_package_folder-2.0.7 → python_package_folder-3.0.0}/tests/test_build_with_external_deps.py

@@ -219,11 +219,15 @@ class TestBuildManager:
         assert len(external_deps) >= 2
 
         # Check that files were copied
+        # some_globals is a simple import, so it should be copied directly
         copied_some_globals = src_dir / "some_globals.py"
         assert copied_some_globals.exists()
 
-        copied_utility = src_dir / "utility_folder"
-        assert copied_utility.exists()
+        # utility_folder is imported as folder_structure.utility_folder, so structure should be preserved
+        copied_utility = src_dir / "folder_structure" / "utility_folder"
+        assert copied_utility.exists(), (
+            f"utility_folder should be copied with structure at {copied_utility}"
+        )
         assert (copied_utility / "some_utility.py").exists()
 
     def test_prepare_build_idempotent(self, test_project_root: Path) -> None:
@@ -265,7 +269,8 @@ class TestBuildManager:
 
         # Verify files were copied
         copied_file = src_dir / "some_globals.py"
-        copied_dir = src_dir / "utility_folder"
+        # utility_folder is imported as folder_structure.utility_folder, so structure should be preserved
+        copied_dir = src_dir / "folder_structure" / "utility_folder"
         assert copied_file.exists()
         assert copied_dir.exists()
 
@@ -481,9 +486,9 @@ class TestExclusionPatterns:
 
         manager.prepare_build()
 
-        # Verify utility_folder was copied
-        copied_utility = src_dir / "utility_folder"
-        assert copied_utility.exists(), "utility_folder should be copied"
+        # Verify utility_folder was copied (with structure preserved)
+        copied_utility = src_dir / "folder_structure" / "utility_folder"
+        assert copied_utility.exists(), "utility_folder should be copied with structure"
         assert (copied_utility / "some_utility.py").exists(), "some_utility.py should be copied"
 
         # Verify _SS directory was NOT copied
@@ -631,9 +636,10 @@ from some_globals import SOME_GLOBAL_VARIABLE
 
         manager.prepare_build()
 
-        # Verify nested_package was copied
-        copied_nested = src_dir / "nested_package"
-        assert copied_nested.exists(), "nested_package should be copied"
+        # Verify nested_package was copied (with structure preserved)
+        # Import is "folder_structure.nested_package.module", so structure should be preserved
+        copied_nested = src_dir / "folder_structure" / "nested_package"
+        assert copied_nested.exists(), "nested_package should be copied with structure"
         assert (copied_nested / "module.py").exists(), "module.py should be copied"
 
         # Verify nested _SS directory was NOT copied

python_package_folder-3.0.0/tests/test_preserve_directory_structure.py

@@ -0,0 +1,177 @@
+"""Tests for preserving directory structure when copying external dependencies."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from python_package_folder import BuildManager, ExternalDependencyFinder
+
+
+@pytest.fixture
+def test_project_with_models_structure(tmp_path: Path) -> Path:
+    """Create a test project with models/ structure under src/."""
+    project_root = tmp_path / "test_project"
+    project_root.mkdir()
+
+    # Create src directory
+    src_dir = project_root / "src"
+    src_dir.mkdir()
+
+    # Create models/Information_extraction/_shared_ie/ structure
+    models_dir = src_dir / "models"
+    models_dir.mkdir()
+    info_extraction_dir = models_dir / "Information_extraction"
+    info_extraction_dir.mkdir()
+    shared_ie_dir = info_extraction_dir / "_shared_ie"
+    shared_ie_dir.mkdir()
+    (shared_ie_dir / "__init__.py").write_text("")
+    (shared_ie_dir / "ie_enums.py").write_text(
+        """from enum import Enum
+
+class TitleblockPlacement(Enum):
+    TOP = "top"
+    BOTTOM = "bottom"
+
+class EmptyDrawingLikelihood(Enum):
+    HIGH = "high"
+    LOW = "low"
+"""
+    )
+
+    # Create data/spreadsheet_creation/ structure
+    data_dir = src_dir / "data"
+    data_dir.mkdir()
+    spreadsheet_creation_dir = data_dir / "spreadsheet_creation"
+    spreadsheet_creation_dir.mkdir()
+    (spreadsheet_creation_dir / "spreadsheet_formatting_dataclasses.py").write_text(
+        """class DataClass:
+    pass
+"""
+    )
+
+    # Create subfolder_to_build
+    subfolder = src_dir / "integration" / "empty_drawing_detection"
+    subfolder.mkdir(parents=True)
+    (subfolder / "detect_empty_drawings.py").write_text(
+        """from models.Information_extraction._shared_ie.ie_enums import (
+    TitleblockPlacement,
+    EmptyDrawingLikelihood,
+)
+from data.spreadsheet_creation.spreadsheet_formatting_dataclasses import DataClass
+
+def analyze_folder():
+    return TitleblockPlacement.TOP, EmptyDrawingLikelihood.HIGH, DataClass()
+"""
+    )
+
+    return project_root
+
+
+class TestPreserveDirectoryStructure:
+    """Tests for preserving directory structure when copying external dependencies."""
+
+    def test_models_structure_preserved(self, test_project_with_models_structure: Path) -> None:
+        """Test that models/ structure is preserved when copying."""
+        project_root = test_project_with_models_structure
+        src_dir = project_root / "src" / "integration" / "empty_drawing_detection"
+
+        finder = ExternalDependencyFinder(project_root, src_dir)
+
+        # Test target path for models file
+        source_file = (
+            project_root
+            / "src"
+            / "models"
+            / "Information_extraction"
+            / "_shared_ie"
+            / "ie_enums.py"
+        )
+        target = finder._determine_target_path(
+            source_file, "models.Information_extraction._shared_ie.ie_enums"
+        )
+
+        assert target is not None
+        assert target.is_relative_to(src_dir)
+        # Should preserve the structure: models/Information_extraction/_shared_ie/ie_enums.py
+        assert "models" in str(target)
+        assert "Information_extraction" in str(target)
+        assert "_shared_ie" in str(target)
+        assert target.name == "ie_enums.py"
+        # Full path should be: src/integration/empty_drawing_detection/models/Information_extraction/_shared_ie/ie_enums.py
+        expected_parts = ["models", "Information_extraction", "_shared_ie", "ie_enums.py"]
+        for part in expected_parts:
+            assert part in str(target)
+
+    def test_data_structure_preserved(self, test_project_with_models_structure: Path) -> None:
+        """Test that data/ structure is preserved when copying."""
+        project_root = test_project_with_models_structure
+        src_dir = project_root / "src" / "integration" / "empty_drawing_detection"
+
+        finder = ExternalDependencyFinder(project_root, src_dir)
+
+        # Test target path for data file
+        source_file = (
+            project_root
+            / "src"
+            / "data"
+            / "spreadsheet_creation"
+            / "spreadsheet_formatting_dataclasses.py"
+        )
+        target = finder._determine_target_path(
+            source_file, "data.spreadsheet_creation.spreadsheet_formatting_dataclasses"
+        )
+
+        assert target is not None
+        assert target.is_relative_to(src_dir)
+        # Should preserve the structure: data/spreadsheet_creation/spreadsheet_formatting_dataclasses.py
+        assert "data" in str(target)
+        assert "spreadsheet_creation" in str(target)
+        assert target.name == "spreadsheet_formatting_dataclasses.py"
+
+    def test_build_manager_preserves_structure(
+        self, test_project_with_models_structure: Path
+    ) -> None:
+        """Test that BuildManager preserves directory structure when copying."""
+        project_root = test_project_with_models_structure
+        src_dir = project_root / "src" / "integration" / "empty_drawing_detection"
+
+        # Create pyproject.toml for the test
+        (project_root / "pyproject.toml").write_text(
+            """[project]
+name = "test-package"
+version = "0.1.0"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/test_package"]
+"""
+        )
+
+        manager = BuildManager(project_root, src_dir)
+
+        # Prepare build
+        external_deps = manager.prepare_build(version="1.0.0", package_name="test-package")
+
+        # Should find models and data as external dependencies
+        models_deps = [dep for dep in external_deps if "models" in dep.import_name.lower()]
+        data_deps = [dep for dep in external_deps if "data" in dep.import_name.lower()]
+
+        assert len(models_deps) > 0, "models dependencies should be found"
+        assert len(data_deps) > 0, "data dependencies should be found"
+
+        # Verify models structure was copied with full path
+        models_path = src_dir / "models" / "Information_extraction" / "_shared_ie" / "ie_enums.py"
+        assert models_path.exists(), (
+            "models/Information_extraction/_shared_ie/ie_enums.py should be copied with full structure"
+        )
+
+        # Verify data structure was copied with full path
+        data_path = (
+            src_dir / "data" / "spreadsheet_creation" / "spreadsheet_formatting_dataclasses.py"
+        )
+        assert data_path.exists(), (
+            "data/spreadsheet_creation/spreadsheet_formatting_dataclasses.py should be copied with full structure"
+        )
+
+        manager.cleanup()

{python_package_folder-2.0.7 → python_package_folder-3.0.0}/tests/test_spreadsheet_creation_imports.py

@@ -137,9 +137,12 @@ packages = ["src/test_package"]
             "spreadsheet modules should be found as external dependencies"
         )
 
-        # Verify spreadsheet_creation directory was copied
-        copied_dir = src_dir / "spreadsheet_creation"
-        assert copied_dir.exists(), "spreadsheet_creation directory should be copied"
+        # Verify spreadsheet_creation directory was copied with full structure preserved
+        # Import is "data.spreadsheet_creation.spreadsheet_formatting_dataclasses", so structure should be preserved
+        copied_dir = src_dir / "data" / "spreadsheet_creation"
+        assert copied_dir.exists(), (
+            f"spreadsheet_creation directory should be copied with structure at {copied_dir}"
+        )
         assert (copied_dir / "spreadsheet_formatting_dataclasses.py").exists(), (
             "spreadsheet_formatting_dataclasses.py should be copied"
         )