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

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

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

@@ -328,6 +328,59 @@ class ImportAnalyzer:
             if potential_file.exists():
                 return potential_file
 
+            # Check all subdirectories in parent (not just common ones)
+            # This handles cases like src/data/spreadsheet_creation/spreadsheet_formatting_dataclasses.py
+            if parent.is_dir():
+                try:
+                    for subdir in parent.iterdir():
+                        if not subdir.is_dir():
+                            continue
+                        # Skip common excluded patterns
+                        if subdir.name.startswith("_SS") or subdir.name.startswith("__SS"):
+                            continue
+                        # Check if module file exists directly in subdirectory
+                        potential_subdir_file = subdir / f"{module_name.split('.')[-1]}.py"
+                        if potential_subdir_file.exists():
+                            return potential_subdir_file
+                        # Check if module directory exists in subdirectory
+                        potential_subdir_module = subdir / module_name.replace(".", "/")
+                        if (
+                            potential_subdir_module.is_dir()
+                            and (potential_subdir_module / "__init__.py").exists()
+                        ):
+                            return potential_subdir_module / "__init__.py"
+                        if potential_subdir_module.with_suffix(".py").is_file():
+                            return potential_subdir_module.with_suffix(".py")
+                        # Check nested subdirectories (e.g., data/spreadsheet_creation)
+                        # Recursively check subdirectories up to 2 levels deep
+                        try:
+                            for nested_subdir in subdir.iterdir():
+                                if not nested_subdir.is_dir():
+                                    continue
+                                # Check if module file exists in nested subdirectory
+                                potential_nested_file = (
+                                    nested_subdir / f"{module_name.split('.')[-1]}.py"
+                                )
+                                if potential_nested_file.exists():
+                                    return potential_nested_file
+                                # Check if module directory exists in nested subdirectory
+                                potential_nested_module = nested_subdir / module_name.replace(
+                                    ".", "/"
+                                )
+                                if (
+                                    potential_nested_module.is_dir()
+                                    and (potential_nested_module / "__init__.py").exists()
+                                ):
+                                    return potential_nested_module / "__init__.py"
+                                if potential_nested_module.with_suffix(".py").is_file():
+                                    return potential_nested_module.with_suffix(".py")
+                        except (OSError, PermissionError):
+                            # Skip nested directories we can't read
+                            continue
+                except (OSError, PermissionError):
+                    # Skip directories we can't read
+                    continue
+
             # Check common subdirectories in parent (e.g., _shared, shared, common)
             # This handles cases like src/_shared/better_enum.py
             common_subdirs = ["_shared", "shared", "common", "_common"]

{python_package_folder-2.0.6 → 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.6 → python_package_folder-3.0.0}/src/python_package_folder/manager.py

@@ -563,21 +563,23 @@ class BuildManager:
                         # Fallback to using the import name
                         third_party_packages.add(root_module)
                 # If it's ambiguous or unresolved, and not stdlib/local/external,
-                # it's likely a third-party package that needs to be declared
+                # only add as dependency if we can verify it's actually an installed package
                 elif imp.classification == "ambiguous" or imp.classification is None:
                     # Check if it's not a local or external module
                     if not imp.resolved_path:
+                        # Try to verify it's actually an installed package before adding
                         # Check cache first
                         if root_module not in package_name_cache:
                             package_name_cache[root_module] = self._get_package_name_from_import(
                                 imp.module_name
                             )
                         actual_package = package_name_cache[root_module]
+                        # Only add if we can verify it's an actual installed package
+                        # Don't add ambiguous imports that we can't verify
                         if actual_package:
                             third_party_packages.add(actual_package)
-                        else:
-                            # Fallback: use import name (will be normalized later)
-                            third_party_packages.add(root_module)
+                        # If we can't verify it's a package, don't add it
+                        # (it's likely a local file that wasn't resolved properly)
 
         if total_files > 50:
             print()  # New line after progress indicator

{python_package_folder-2.0.6 → 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-3.0.0/tests/test_spreadsheet_creation_imports.py

@@ -0,0 +1,165 @@
+"""Tests for imports from spreadsheet_creation subdirectory."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from python_package_folder import BuildManager, ImportAnalyzer, ImportInfo
+
+
+@pytest.fixture
+def test_project_with_spreadsheet_creation(tmp_path: Path) -> Path:
+    """Create a test project with spreadsheet_creation subdirectory."""
+    project_root = tmp_path / "test_project"
+    project_root.mkdir()
+
+    # Create src directory
+    src_dir = project_root / "src"
+    src_dir.mkdir()
+
+    # Create data/spreadsheet_creation directory with files
+    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
+"""
+    )
+    (spreadsheet_creation_dir / "spreadsheet_utils.py").write_text(
+        """def util_func():
+    pass
+"""
+    )
+
+    # Create subfolder_to_build
+    subfolder = src_dir / "integration" / "empty_drawing_detection"
+    subfolder.mkdir(parents=True)
+    (subfolder / "module.py").write_text(
+        """from spreadsheet_formatting_dataclasses import DataClass
+from spreadsheet_utils import util_func
+
+def use_spreadsheet():
+    return DataClass, util_func
+"""
+    )
+
+    return project_root
+
+
+class TestSpreadsheetCreationImports:
+    """Tests for imports from spreadsheet_creation subdirectory."""
+
+    def test_resolve_spreadsheet_formatting_dataclasses(
+        self, test_project_with_spreadsheet_creation: Path
+    ) -> None:
+        """Test that spreadsheet_formatting_dataclasses is resolved from data/spreadsheet_creation."""
+        project_root = test_project_with_spreadsheet_creation
+        src_dir = project_root / "src" / "integration" / "empty_drawing_detection"
+
+        analyzer = ImportAnalyzer(project_root)
+
+        # Create import info for spreadsheet_formatting_dataclasses
+        import_info = ImportInfo(
+            module_name="spreadsheet_formatting_dataclasses",
+            import_type="from",
+            line_number=1,
+            file_path=src_dir / "module.py",
+        )
+
+        # Classify the import
+        analyzer.classify_import(import_info, src_dir)
+
+        # Should be classified as external (not third_party)
+        assert import_info.classification == "external"
+        assert import_info.resolved_path is not None
+        assert import_info.resolved_path.name == "spreadsheet_formatting_dataclasses.py"
+        # Should resolve to src/data/spreadsheet_creation/spreadsheet_formatting_dataclasses.py
+        assert "spreadsheet_creation" in str(import_info.resolved_path)
+        assert import_info.resolved_path.exists()
+
+    def test_resolve_spreadsheet_utils(self, test_project_with_spreadsheet_creation: Path) -> None:
+        """Test that spreadsheet_utils is resolved from data/spreadsheet_creation."""
+        project_root = test_project_with_spreadsheet_creation
+        src_dir = project_root / "src" / "integration" / "empty_drawing_detection"
+
+        analyzer = ImportAnalyzer(project_root)
+
+        # Create import info for spreadsheet_utils
+        import_info = ImportInfo(
+            module_name="spreadsheet_utils",
+            import_type="from",
+            line_number=2,
+            file_path=src_dir / "module.py",
+        )
+
+        # Classify the import
+        analyzer.classify_import(import_info, src_dir)
+
+        # Should be classified as external (not third_party)
+        assert import_info.classification == "external"
+        assert import_info.resolved_path is not None
+        assert import_info.resolved_path.name == "spreadsheet_utils.py"
+        assert "spreadsheet_creation" in str(import_info.resolved_path)
+        assert import_info.resolved_path.exists()
+
+    def test_spreadsheet_modules_copied_not_added_as_dependencies(
+        self, test_project_with_spreadsheet_creation: Path
+    ) -> None:
+        """Test that spreadsheet modules are copied, not added as dependencies."""
+        project_root = test_project_with_spreadsheet_creation
+        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 spreadsheet modules as external dependencies to copy
+        spreadsheet_deps = [
+            dep for dep in external_deps if "spreadsheet" in dep.import_name.lower()
+        ]
+        assert len(spreadsheet_deps) > 0, (
+            "spreadsheet modules should be found as external dependencies"
+        )
+
+        # 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"
+        )
+        assert (copied_dir / "spreadsheet_utils.py").exists(), (
+            "spreadsheet_utils.py should be copied"
+        )
+
+        # Check that subfolder_config exists (for subfolder builds)
+        if manager.subfolder_config:
+            # Read the temporary pyproject.toml
+            pyproject_path = project_root / "pyproject.toml"
+            if pyproject_path.exists():
+                content = pyproject_path.read_text()
+                # Should NOT have spreadsheet-formatting-dataclasses or spreadsheet-utils in dependencies
+                assert '"spreadsheet-formatting-dataclasses"' not in content
+                assert '"spreadsheet-utils"' not in content
+                assert '"spreadsheet_formatting_dataclasses"' not in content
+                assert '"spreadsheet_utils"' not in content
+
+        manager.cleanup()