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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 2.0.4
+Version: 2.0.6
 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.4 → python_package_folder-2.0.6}/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">69%</text>
-    <text x="81" y="14">69%</text>
+    <text x="81" y="15" fill="#010101" fill-opacity=".3">68%</text>
+    <text x="81" y="14">68%</text>
   </g>
 </svg>

{python_package_folder-2.0.4 → python_package_folder-2.0.6}/src/python_package_folder/analyzer.py

@@ -328,6 +328,26 @@ class ImportAnalyzer:
             if potential_file.exists():
                 return potential_file
 
+            # 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.4 → python_package_folder-2.0.6}/src/python_package_folder/manager.py

@@ -86,6 +86,8 @@ class BuildManager:
             self.project_root, self.src_dir, exclude_patterns=exclude_patterns
         )
         self.subfolder_config: SubfolderBuildConfig | None = None
+        # Cache for package name lookups (expensive operation)
+        self._packages_distributions_cache: dict[str, list[str]] | None = None
 
         # Check if it's a valid Python package directory
         if not any(self.src_dir.glob("*.py")) and not (self.src_dir / "__init__.py").exists():
@@ -271,7 +273,9 @@ class BuildManager:
         # For subfolder builds, extract third-party dependencies and add to pyproject.toml
         if self._is_subfolder_build() and self.subfolder_config:
             # Re-analyze all Python files (including copied dependencies) to find third-party imports
+            print("Analyzing Python files for third-party dependencies...")
             all_python_files = analyzer.find_all_python_files(self.src_dir)
+            print(f"Found {len(all_python_files)} Python files to analyze")
             third_party_deps = self._extract_third_party_dependencies(all_python_files, analyzer)
             if third_party_deps:
                 print(
@@ -413,8 +417,12 @@ class BuildManager:
             import importlib.metadata as importlib_metadata
 
             # Use packages_distributions() if available (Python 3.10+)
+            # Cache the result since it's expensive to call
             if hasattr(importlib_metadata, "packages_distributions"):
-                packages_map = importlib_metadata.packages_distributions()
+                if self._packages_distributions_cache is None:
+                    # Cache the packages_distributions() result
+                    self._packages_distributions_cache = importlib_metadata.packages_distributions()
+                packages_map = self._packages_distributions_cache
                 # packages_map is a dict mapping module names to list of distribution names
                 if root_module in packages_map:
                     # Return the first distribution name (usually there's only one)
@@ -422,26 +430,45 @@ class BuildManager:
                     if dist_names:
                         return dist_names[0]
 
-            # Fallback: search all distributions
+            # Fallback: search all distributions (this can be slow, so limit search)
+            # Only check top-level package matches to speed up search
+            dist_count = 0
+            max_distributions_to_check = 1000  # Limit to prevent excessive searching
             for dist in importlib_metadata.distributions():
+                dist_count += 1
+                if dist_count > max_distributions_to_check:
+                    # Too many distributions, give up to avoid hanging
+                    break
                 try:
-                    # Check if this distribution provides the module
-                    # by looking at its files
-                    files = dist.files or []
-                    for file in files:
-                        file_str = str(file)
-                        # Check if file is the module itself or in a package directory
-                        if (
-                            file.suffix == ".py"
-                            and (file.stem == root_module or file.stem == "__init__")
-                        ) or (
-                            "/" in file_str
-                            and (
-                                file_str.startswith(f"{root_module}/")
-                                or file_str.startswith(f"{root_module.replace('_', '-')}/")
-                            )
-                        ):
-                            return dist.metadata["Name"]
+                    # Check distribution name first (fast check)
+                    dist_name = dist.metadata.get("Name", "")
+                    # If distribution name matches or contains the module name, check files
+                    if dist_name.lower().replace(
+                        "-", "_"
+                    ) == root_module.lower() or root_module.lower() in dist_name.lower().replace(
+                        "-", "_"
+                    ):
+                        # Check if this distribution provides the module by looking at its files
+                        files = dist.files or []
+                        # Limit file checking to first 100 files per distribution
+                        file_count = 0
+                        for file in files:
+                            file_count += 1
+                            if file_count > 100:
+                                break
+                            file_str = str(file)
+                            # Check if file is the module itself or in a package directory
+                            if (
+                                file.suffix == ".py"
+                                and (file.stem == root_module or file.stem == "__init__")
+                            ) or (
+                                "/" in file_str
+                                and (
+                                    file_str.startswith(f"{root_module}/")
+                                    or file_str.startswith(f"{root_module.replace('_', '-')}/")
+                                )
+                            ):
+                                return dist.metadata["Name"]
                 except Exception:
                     continue
 
@@ -494,8 +521,14 @@ class BuildManager:
             List of unique third-party package names (e.g., ["pypdf", "requests", "pymupdf"])
         """
         third_party_packages: set[str] = set()
+        # Cache package name lookups to avoid repeated expensive searches
+        package_name_cache: dict[str, str | None] = {}
+
+        total_files = len(python_files)
+        for idx, file_path in enumerate(python_files):
+            if idx > 0 and idx % 50 == 0:
+                print(f"  Analyzing file {idx}/{total_files}...", end="\r", flush=True)
 
-        for file_path in python_files:
             imports = analyzer.extract_imports(file_path)
             for imp in imports:
                 analyzer.classify_import(imp, self.src_dir)
@@ -508,10 +541,22 @@ 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":
-                    # Try to get the actual package name from metadata
-                    actual_package = self._get_package_name_from_import(imp.module_name)
+                    # 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(
+                            imp.module_name
+                        )
+                    actual_package = package_name_cache[root_module]
                     if actual_package:
                         third_party_packages.add(actual_package)
                     else:
@@ -522,15 +567,21 @@ class BuildManager:
                 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 get the actual package name from metadata
-                        # (might work if package is installed but module path is unusual)
-                        actual_package = self._get_package_name_from_import(imp.module_name)
+                        # 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]
                         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 total_files > 50:
+            print()  # New line after progress indicator
+
         return sorted(list(third_party_packages))
 
     def _report_ambiguous_imports(self, python_files: list[Path]) -> None:

python_package_folder-2.0.6/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()