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

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

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

@@ -328,6 +328,79 @@ 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"]
+            for subdir_name in common_subdirs:
+                subdir = parent / subdir_name
+                if subdir.exists() and subdir.is_dir():
+                    # Check if module file exists 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")
+
         return None
 
     def is_third_party(self, module_name: str) -> bool:

{python_package_folder-2.0.5 → python_package_folder-2.0.7}/src/python_package_folder/manager.py

@@ -541,8 +541,16 @@ class BuildManager:
                 if root_module in stdlib_modules:
                     continue
 
+                # Skip if it's local or external (already copied, don't add as dependency)
+                if imp.classification in ("local", "external"):
+                    continue
+
                 # If classified as third_party, try to get actual package name
                 if imp.classification == "third_party":
+                    # Double-check: if it resolves to a file in src_dir, it's actually local
+                    # (might have been copied and now resolves locally)
+                    if imp.resolved_path and imp.resolved_path.is_relative_to(self.src_dir):
+                        continue  # Skip - it's a local file, not a third-party package
                     # Check cache first
                     if root_module not in package_name_cache:
                         package_name_cache[root_module] = self._get_package_name_from_import(
@@ -555,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.7/tests/test_shared_subdirectory_imports.py

@@ -0,0 +1,107 @@
+"""Tests for imports from _shared subdirectories."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from python_package_folder import BuildManager, ImportAnalyzer, ImportInfo
+
+
+@pytest.fixture
+def test_project_with_shared(tmp_path: Path) -> Path:
+    """Create a test project with _shared subdirectory."""
+    project_root = tmp_path / "test_project"
+    project_root.mkdir()
+
+    # Create src directory
+    src_dir = project_root / "src"
+    src_dir.mkdir()
+
+    # Create _shared directory with better_enum.py
+    shared_dir = src_dir / "_shared"
+    shared_dir.mkdir()
+    (shared_dir / "better_enum.py").write_text(
+        """class Enum:
+    pass
+"""
+    )
+
+    # Create subfolder_to_build
+    subfolder = src_dir / "integration" / "empty_drawing_detection"
+    subfolder.mkdir(parents=True)
+    (subfolder / "module.py").write_text(
+        """from better_enum import Enum
+
+def use_enum():
+    return Enum
+"""
+    )
+
+    return project_root
+
+
+class TestSharedSubdirectoryImports:
+    """Tests for imports from _shared subdirectories."""
+
+    def test_resolve_better_enum_from_shared(self, test_project_with_shared: Path) -> None:
+        """Test that better_enum is resolved from src/_shared/better_enum.py."""
+        project_root = test_project_with_shared
+        src_dir = project_root / "src" / "integration" / "empty_drawing_detection"
+
+        analyzer = ImportAnalyzer(project_root)
+
+        # Create import info for better_enum
+        import_info = ImportInfo(
+            module_name="better_enum",
+            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 == "better_enum.py"
+        # Should resolve to src/_shared/better_enum.py
+        assert "_shared" in str(import_info.resolved_path)
+        assert import_info.resolved_path.exists()
+
+    def test_better_enum_copied_not_added_as_dependency(
+        self, test_project_with_shared: Path
+    ) -> None:
+        """Test that better_enum is copied as external dependency, not added as third-party."""
+        project_root = test_project_with_shared
+        src_dir = project_root / "src" / "integration" / "empty_drawing_detection"
+
+        manager = BuildManager(project_root, src_dir)
+
+        # Prepare build
+        external_deps = manager.prepare_build(version="1.0.0", package_name="test-package")
+
+        # Should find better_enum as an external dependency to copy
+        better_enum_deps = [dep for dep in external_deps if "better_enum" in dep.import_name]
+        assert len(better_enum_deps) > 0, "better_enum should be found as external dependency"
+
+        # Verify _shared directory was copied (which contains better_enum.py)
+        copied_shared_dir = src_dir / "_shared"
+        assert copied_shared_dir.exists(), "_shared directory should be copied to subfolder"
+        copied_file = copied_shared_dir / "better_enum.py"
+        assert copied_file.exists(), "better_enum.py should be in copied _shared directory"
+
+        # 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 better-enum or better_enum in dependencies
+                # (it should be copied, not added as dependency)
+                assert '"better-enum"' not in content
+                assert '"better_enum"' not in content
+
+        manager.cleanup()

python_package_folder-2.0.7/tests/test_spreadsheet_creation_imports.py

@@ -0,0 +1,162 @@
+"""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
+        copied_dir = src_dir / "spreadsheet_creation"
+        assert copied_dir.exists(), "spreadsheet_creation directory should be copied"
+        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()