python-package-folder 3.1.0__tar.gz → 3.1.2__tar.gz

{python_package_folder-3.1.0 → python_package_folder-3.1.2}/PKG-INFO

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

@@ -88,6 +88,8 @@ class BuildManager:
         self.subfolder_config: SubfolderBuildConfig | None = None
         # Cache for package name lookups (expensive operation)
         self._packages_distributions_cache: dict[str, list[str]] | None = None
+        # Track files with modified imports and their original content
+        self._modified_import_files: dict[Path, str] = {}
 
         # 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():
@@ -270,6 +272,10 @@ class BuildManager:
         for dep in external_deps:
             self._copy_dependency(dep)
 
+        # For subfolder builds, convert absolute imports of copied dependencies to relative imports
+        if self._is_subfolder_build() and external_deps:
+            self._convert_copied_dependency_imports_to_relative(python_files, external_deps)
+
         # 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
@@ -629,6 +635,147 @@ class BuildManager:
 
         return sorted(list(third_party_packages))
 
+    def _convert_copied_dependency_imports_to_relative(
+        self, python_files: list[Path], external_deps: list[ExternalDependency]
+    ) -> None:
+        """
+        Convert absolute imports of copied dependencies to relative imports.
+
+        For subfolder builds, when external dependencies are copied into the subfolder,
+        imports in the subfolder's files need to be converted from absolute to relative
+        so they work correctly when the package is installed.
+
+        Args:
+            python_files: List of Python files in the source directory
+            external_deps: List of external dependencies that were copied
+        """
+        import ast
+        import re
+
+        # Build a set of import names that were copied (e.g., "_shared", "_globals", "empty_drawing_detection_config")
+        copied_import_names: set[str] = set()
+        for dep in external_deps:
+            # Get the root module name (first part of the import)
+            root_module = dep.import_name.split(".")[0]
+            copied_import_names.add(root_module)
+            # Also add the full module name for nested imports
+            copied_import_names.add(dep.import_name)
+
+        if not copied_import_names:
+            return
+
+        # Only modify files that are in the original subfolder (not the copied dependencies)
+        for file_path in python_files:
+            # Skip files that are part of copied dependencies
+            is_copied_file = any(file_path.is_relative_to(dep.target_path) for dep in external_deps)
+            if is_copied_file:
+                continue
+
+            # Skip if file is not in src_dir (shouldn't happen, but safety check)
+            if not file_path.is_relative_to(self.src_dir):
+                continue
+
+            try:
+                content = file_path.read_text(encoding="utf-8")
+                original_content = content
+                lines = content.split("\n")
+                modified = False
+
+                # Parse the file with AST to find imports accurately
+                try:
+                    tree = ast.parse(content, filename=str(file_path))
+                except SyntaxError:
+                    # Skip files with syntax errors
+                    continue
+
+                # Track which lines need to be modified
+                lines_to_modify: dict[int, str] = {}
+
+                for node in ast.walk(tree):
+                    if isinstance(node, ast.ImportFrom):
+                        if node.module is None:
+                            continue
+
+                        # Check if this import matches a copied dependency
+                        root_module = node.module.split(".")[0]
+                        if (
+                            root_module not in copied_import_names
+                            and node.module not in copied_import_names
+                        ):
+                            continue
+
+                        # Get the line content
+                        line_num = node.lineno - 1  # Convert to 0-based index
+                        if line_num < 0 or line_num >= len(lines):
+                            continue
+
+                        original_line = lines[line_num]
+
+                        # Skip if already a relative import
+                        if original_line.strip().startswith("from ."):
+                            continue
+
+                        # Convert absolute import to relative import
+                        # from _shared.image_utils import ... -> from ._shared.image_utils import ...
+                        new_line = re.sub(
+                            rf"^(\s*)from\s+{re.escape(node.module)}\s+import",
+                            rf"\1from .{node.module} import",
+                            original_line,
+                        )
+
+                        if new_line != original_line:
+                            lines_to_modify[line_num] = new_line
+                            modified = True
+
+                    elif isinstance(node, ast.Import):
+                        # Handle "import X" statements
+                        for alias in node.names:
+                            root_module = alias.name.split(".")[0]
+                            if root_module not in copied_import_names:
+                                continue
+
+                            line_num = node.lineno - 1
+                            if line_num < 0 or line_num >= len(lines):
+                                continue
+
+                            original_line = lines[line_num]
+
+                            # Skip if already a relative import
+                            if original_line.strip().startswith("import ."):
+                                continue
+
+                            # Convert "import _shared" to "from . import _shared"
+                            # This is more complex, so we'll use a regex replacement
+                            new_line = re.sub(
+                                rf"^(\s*)import\s+{re.escape(alias.name)}\b",
+                                rf"\1from . import {alias.name}",
+                                original_line,
+                            )
+
+                            if new_line != original_line:
+                                lines_to_modify[line_num] = new_line
+                                modified = True
+
+                # Apply modifications
+                if modified:
+                    for line_num, new_line in lines_to_modify.items():
+                        lines[line_num] = new_line
+
+                    new_content = "\n".join(lines)
+                    # Store original content for restoration
+                    if file_path not in self._modified_import_files:
+                        self._modified_import_files[file_path] = original_content
+
+                    # Write modified content
+                    file_path.write_text(new_content, encoding="utf-8")
+                    print(f"Converted imports to relative in: {file_path}")
+
+            except Exception as e:
+                print(
+                    f"Warning: Could not modify imports in {file_path}: {e}",
+                    file=sys.stderr,
+                )
+
     def _report_ambiguous_imports(self, python_files: list[Path]) -> None:
         """
         Report any ambiguous imports that couldn't be resolved.
@@ -708,6 +855,19 @@ class BuildManager:
         self.copied_files.clear()
         self.copied_dirs.clear()
 
+        # Restore files with modified imports
+        for file_path, original_content in self._modified_import_files.items():
+            if file_path.exists():
+                try:
+                    file_path.write_text(original_content, encoding="utf-8")
+                    print(f"Restored original imports in: {file_path}")
+                except Exception as e:
+                    print(
+                        f"Warning: Could not restore imports in {file_path}: {e}",
+                        file=sys.stderr,
+                    )
+        self._modified_import_files.clear()
+
         # Remove all .egg-info directories in src_dir and project_root
         self._cleanup_egg_info_dirs()
 

{python_package_folder-3.1.0 → python_package_folder-3.1.2}/src/python_package_folder/subfolder_build.py

@@ -141,8 +141,9 @@ class SubfolderBuildConfig:
         result = []
         in_hatch_build = False
         in_hatch_build_section = False
+        in_sdist_section = False
         packages_set = False
-        paths_exclude_set = False
+        only_include_set = False
 
         for line in lines:
             # Detect hatch build section
@@ -165,10 +166,20 @@ class SubfolderBuildConfig:
                 # End of hatch build section
                 in_hatch_build_section = False
                 result.append(line)
+            elif line.strip().startswith("[tool.hatch.build.targets.sdist]"):
+                in_sdist_section = True
+                result.append(line)
+                continue
+            elif line.strip().startswith("[") and in_sdist_section:
+                # End of sdist section
+                in_sdist_section = False
+                result.append(line)
+            elif in_sdist_section:
+                # Track if only-include already exists
+                if re.match(r"^\s*only-include\s*=", line):
+                    only_include_set = True
+                result.append(line)
             elif in_hatch_build_section:
-                # Track if paths-exclude already exists
-                if re.match(r"^\s*paths-exclude\s*=", line):
-                    paths_exclude_set = True
                 result.append(line)
             elif in_hatch_build:
                 # Modify packages path if found
@@ -209,42 +220,21 @@ class SubfolderBuildConfig:
                 packages_str = f'"{correct_packages_path}"'
                 result.append(f"packages = [{packages_str}]")
 
-        # Add file exclusion patterns to prevent including non-package files
-        # Only add if paths-exclude wasn't already set (we merged it above)
-        if not paths_exclude_set:
+        # Use only-include for source distributions to ensure only the subfolder is included
+        # This prevents including files from the project root
+        if correct_packages_path and not only_include_set:
             result.append("")
-            result.append("[tool.hatch.build]")
-            result.append("paths-exclude = [")
-            result.append('    ".cursor/**",')
-            result.append('    ".github/**",')
-            result.append('    ".vscode/**",')
-            result.append('    ".idea/**",')
-            result.append('    "data/**",')
-            result.append('    "docs/**",')
-            result.append('    "references/**",')
-            result.append('    "reports/**",')
-            result.append('    "scripts/**",')
-            result.append('    "tests/**",')
-            result.append('    "test/**",')
-            result.append('    "dist/**",')
-            result.append('    "build/**",')
-            result.append('    "*.egg-info/**",')
-            result.append('    "__pycache__/**",')
-            result.append('    ".pytest_cache/**",')
-            result.append('    ".mypy_cache/**",')
-            result.append('    ".venv/**",')
-            result.append('    "venv/**",')
-            result.append('    ".git/**",')
-            result.append('    ".gitignore",')
-            result.append('    ".gitattributes",')
-            result.append('    "Dockerfile",')
-            result.append('    ".dockerignore",')
-            result.append('    ".pylintrc",')
-            result.append('    "pyrightconfig.json",')
-            result.append('    "git-filter-repo",')
-            result.append('    "pyproject.toml.original",')
-            result.append('    "README.md.backup",')
-            result.append("]")
+            result.append("[tool.hatch.build.targets.sdist]")
+            # Include only the subfolder directory and necessary files
+            only_include_paths = [correct_packages_path]
+            # Also include pyproject.toml and README if they exist
+            only_include_paths.append("pyproject.toml")
+            only_include_paths.append("README.md")
+            only_include_paths.append("README.rst")
+            only_include_paths.append("README.txt")
+            only_include_paths.append("README")
+            only_include_str = ", ".join(f'"{p}"' for p in only_include_paths)
+            result.append(f"only-include = [{only_include_str}]")
 
         return "\n".join(result)
 
@@ -584,41 +574,21 @@ class SubfolderBuildConfig:
             packages_str = ", ".join(f'"{p}"' for p in package_dirs)
             result.append(f"packages = [{packages_str}]")
 
-        # Add file exclusion patterns to prevent including non-package files
-        # This ensures only the subfolder code is included, not project root files
-        result.append("")
-        result.append("[tool.hatch.build]")
-        result.append("paths-exclude = [")
-        result.append('    ".cursor/**",')
-        result.append('    ".github/**",')
-        result.append('    ".vscode/**",')
-        result.append('    ".idea/**",')
-        result.append('    "data/**",')
-        result.append('    "docs/**",')
-        result.append('    "references/**",')
-        result.append('    "reports/**",')
-        result.append('    "scripts/**",')
-        result.append('    "tests/**",')
-        result.append('    "test/**",')
-        result.append('    "dist/**",')
-        result.append('    "build/**",')
-        result.append('    "*.egg-info/**",')
-        result.append('    "__pycache__/**",')
-        result.append('    ".pytest_cache/**",')
-        result.append('    ".mypy_cache/**",')
-        result.append('    ".venv/**",')
-        result.append('    "venv/**",')
-        result.append('    ".git/**",')
-        result.append('    ".gitignore",')
-        result.append('    ".gitattributes",')
-        result.append('    "Dockerfile",')
-        result.append('    ".dockerignore",')
-        result.append('    ".pylintrc",')
-        result.append('    "pyrightconfig.json",')
-        result.append('    "git-filter-repo",')
-        result.append('    "pyproject.toml.original",')
-        result.append('    "README.md.backup",')
-        result.append("]")
+        # Use only-include for source distributions to ensure only the subfolder is included
+        # This prevents including files from the project root
+        if package_dirs:
+            result.append("")
+            result.append("[tool.hatch.build.targets.sdist]")
+            # Include only the subfolder directory and necessary files
+            only_include_paths = [package_dirs[0]]
+            # Also include pyproject.toml and README if they exist
+            only_include_paths.append("pyproject.toml")
+            only_include_paths.append("README.md")
+            only_include_paths.append("README.rst")
+            only_include_paths.append("README.txt")
+            only_include_paths.append("README")
+            only_include_str = ", ".join(f'"{p}"' for p in only_include_paths)
+            result.append(f"only-include = [{only_include_str}]")
 
         # Add dependency group if specified
         if dependency_group:

{python_package_folder-3.1.0 → python_package_folder-3.1.2}/tests/test_build_with_external_deps.py

@@ -363,6 +363,94 @@ class TestBuildManager:
         assert len(manager.copied_files) == 0
         assert len(manager.copied_dirs) == 0
 
+    def test_convert_copied_dependency_imports_to_relative(self, tmp_path: Path) -> None:
+        """Test that absolute imports of copied dependencies are converted to relative imports for subfolder builds."""
+        project_root = tmp_path / "test_project"
+        project_root.mkdir()
+
+        # Create pyproject.toml
+        (project_root / "pyproject.toml").write_text(
+            """[project]
+name = "test-package"
+version = "0.1.0"
+"""
+        )
+
+        # Create external dependency _shared
+        shared_dir = project_root / "_shared"
+        shared_dir.mkdir()
+        (shared_dir / "__init__.py").write_text("")
+        (shared_dir / "image_utils.py").write_text("def save_PIL_image(): pass")
+        (shared_dir / "file_utils.py").write_text("def get_filepaths_config(): pass")
+
+        # Create external dependency _globals
+        (project_root / "_globals.py").write_text("is_testing = False")
+
+        # Create subfolder to build
+        subfolder = project_root / "src" / "integration" / "empty_drawing_detection"
+        subfolder.mkdir(parents=True)
+        (subfolder / "__init__.py").write_text("")
+
+        # Create a file in subfolder that imports copied dependencies with absolute imports
+        test_file = subfolder / "detect_empty_drawings.py"
+        original_content = """from pathlib import Path
+from _shared.image_utils import save_PIL_image
+from _shared.file_utils import get_filepaths_config
+from _globals import is_testing
+
+def analyze_folder():
+    save_PIL_image()
+    get_filepaths_config()
+    return is_testing
+"""
+        test_file.write_text(original_content)
+
+        # Create another file with different import style
+        test_file2 = subfolder / "config.py"
+        original_content2 = """import _globals
+
+def get_config():
+    return _globals.is_testing
+"""
+        test_file2.write_text(original_content2)
+
+        manager = BuildManager(project_root, subfolder)
+
+        try:
+            # Prepare build - this should copy dependencies and convert imports
+            external_deps = manager.prepare_build(version="1.0.0", package_name="test-package")
+
+            # Verify dependencies were copied
+            assert len(external_deps) >= 2
+            assert (subfolder / "_shared").exists()
+            assert (subfolder / "_globals.py").exists()
+
+            # Verify imports were converted to relative
+            modified_content = test_file.read_text()
+            assert "from ._shared.image_utils import save_PIL_image" in modified_content
+            assert "from ._shared.file_utils import get_filepaths_config" in modified_content
+            assert "from ._globals import is_testing" in modified_content
+            # Verify stdlib import was not changed
+            assert "from pathlib import Path" in modified_content
+
+            # Verify import statement conversion
+            modified_content2 = test_file2.read_text()
+            assert "from . import _globals" in modified_content2
+
+            # Cleanup should restore original imports
+            manager.cleanup()
+
+            restored_content = test_file.read_text()
+            assert restored_content == original_content
+
+            restored_content2 = test_file2.read_text()
+            assert restored_content2 == original_content2
+
+        finally:
+            # Ensure cleanup even if test fails
+            if manager._modified_import_files:
+                manager.cleanup()
+
 
 class TestRealFolderStructure:
     """Tests using the real folder_structure from tests directory."""

{python_package_folder-3.1.0 → python_package_folder-3.1.2}/tests/test_subfolder_build.py

@@ -711,30 +711,24 @@ class TestSubfolderBuildTemporaryPyprojectCreation:
         assert pyproject_path.exists()
         content = pyproject_path.read_text()
 
-        # Verify [tool.hatch.build] section exists
-        assert "[tool.hatch.build]" in content
-
-        # Verify paths-exclude is present
-        assert "paths-exclude = [" in content
-
-        # Verify common exclusion patterns are included
-        assert '".cursor/**"' in content
-        assert '".github/**"' in content
-        assert '".vscode/**"' in content
-        assert '"data/**"' in content
-        assert '"docs/**"' in content
-        assert '"references/**"' in content
-        assert '"reports/**"' in content
-        assert '"scripts/**"' in content
-        assert '"tests/**"' in content
-        assert '"dist/**"' in content
-        assert '"build/**"' in content
-        assert '"*.egg-info/**"' in content
-        assert '"__pycache__/**"' in content
-        assert '".pytest_cache/**"' in content
-        assert '".git/**"' in content
-        assert '"Dockerfile"' in content
-        assert '".gitignore"' in content
+        # Verify [tool.hatch.build.targets.sdist] section exists
+        assert "[tool.hatch.build.targets.sdist]" in content
+
+        # Verify only-include is present
+        assert "only-include = [" in content
+
+        # Verify the subfolder is included
+        assert '"subfolder"' in content
+
+        # Verify necessary files are included
+        assert '"pyproject.toml"' in content
+        assert '"README.md"' in content
+
+        # Verify non-package directories are NOT explicitly included
+        assert '".cursor"' not in content or '".cursor"' not in content.split("only-include")[1]
+        assert '".github"' not in content or '".github"' not in content.split("only-include")[1]
+        assert '"data"' not in content or '"data"' not in content.split("only-include")[1]
+        assert '"docs"' not in content or '"docs"' not in content.split("only-include")[1]
 
         # Cleanup
         config.restore()
@@ -771,18 +765,17 @@ description = "Subfolder package"
         assert pyproject_path.exists()
         content = pyproject_path.read_text()
 
-        # Verify [tool.hatch.build] section exists
-        assert "[tool.hatch.build]" in content
+        # Verify [tool.hatch.build.targets.sdist] section exists
+        assert "[tool.hatch.build.targets.sdist]" in content
+
+        # Verify only-include is present
+        assert "only-include = [" in content
 
-        # Verify paths-exclude is present
-        assert "paths-exclude = [" in content
+        # Verify the subfolder is included
+        assert '"subfolder-package"' in content or '"subfolder"' in content
 
-        # Verify common exclusion patterns are included
-        assert '".cursor/**"' in content
-        assert '"data/**"' in content
-        assert '"docs/**"' in content
-        assert '"dist/**"' in content
-        assert '"build/**"' in content
+        # Verify necessary files are included
+        assert '"pyproject.toml"' in content
 
         # Cleanup
         config.restore()