python-package-folder 5.1.1__tar.gz → 5.1.2__tar.gz

{python_package_folder-5.1.1 → python_package_folder-5.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 5.1.1
+Version: 5.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-5.1.1 → python_package_folder-5.1.2}/pyproject.toml

@@ -43,7 +43,7 @@ dependencies = [
 
 # ---- Dev dependencies ----
 
-version = "5.1.1"
+version = "5.1.2"
 [dependency-groups]
 dev = [
     "pytest>=8.3.5",
@@ -154,7 +154,5 @@ testpaths = [
     "src",
     "tests",
 ]
-# Ignore build hooks - they're not test files and require hatchling which isn't in test deps
-ignore = ["_hatch_build.py"]
 norecursedirs = []
 filterwarnings = []

{python_package_folder-5.1.1 → python_package_folder-5.1.2}/src/python_package_folder/subfolder_build.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import re
 import shutil
 import sys
+import tempfile
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -75,6 +76,8 @@ class SubfolderBuildConfig:
         self.temp_readme: Path | None = None
         self.original_readme_backup: Path | None = None
         self._used_subfolder_pyproject = False
+        self._excluded_files: list[tuple[Path, Path]] = []  # List of (original_path, temp_path) tuples
+        self._exclude_temp_dir: Path | None = None
 
     def _derive_package_name(self) -> str:
         """Derive package name from source directory name."""
@@ -205,80 +208,13 @@ class SubfolderBuildConfig:
         has_build_system = any(line.strip().startswith("[build-system]") for line in result)
         if not has_build_system:
             # Insert build-system at the very beginning of the file
-            # Include python-package-folder in requires so the build hook is available
             build_system_lines = [
                 "[build-system]",
-                'requires = ["hatchling", "python-package-folder"]',
+                'requires = ["hatchling"]',
                 'build-backend = "hatchling.build"',
                 "",
             ]
             result = build_system_lines + result
-        else:
-            # Ensure python-package-folder is in requires for build hook availability
-            in_build_system = False
-            for i, line in enumerate(result):
-                if line.strip().startswith("[build-system]"):
-                    in_build_system = True
-                elif in_build_system and line.strip().startswith("requires"):
-                    # Check if python-package-folder is already in requires
-                    if "python-package-folder" not in line:
-                        # Add python-package-folder to requires
-                        if "]" in line:
-                            # Single-line requires
-                            result[i] = line.rstrip().rstrip("]") + ', "python-package-folder"]'
-                        else:
-                            # Multi-line requires, find the closing bracket
-                            for j in range(i + 1, len(result)):
-                                if "]" in result[j]:
-                                    # Insert before closing
-                                    # Determine indentation from the previous line (last item in list)
-                                    if j > i + 1:
-                                        # Look at the previous line to get indentation
-                                        prev_line = result[j - 1]
-                                        # Extract leading whitespace from previous line
-                                        indent = len(prev_line) - len(prev_line.lstrip())
-                                        indent_str = " " * indent
-                                    else:
-                                        # Fallback: use standard 4-space indent
-                                        indent_str = "    "
-                                    result.insert(j, f'{indent_str}"python-package-folder",')
-                                    break
-                    break
-                elif in_build_system and line.strip().startswith("[") and not line.strip().startswith("[build-system"):
-                    # End of build-system section
-                    break
-
-        # Register the build hook to enable exclude patterns
-        build_hook_registered = any(
-            "[tool.hatch.build.hooks.custom]" in line for line in result
-        )
-        if not build_hook_registered:
-            # Add build hook registration after [tool.hatch.build.targets.wheel] section
-            hook_insert_index = len(result)
-            for i, line in enumerate(result):
-                if line.strip().startswith("[tool.hatch.build.targets.wheel]"):
-                    # Find the end of this section
-                    for j in range(i + 1, len(result)):
-                        if result[j].strip().startswith("[") and not result[j].strip().startswith(
-                            "[tool.hatch.build.targets"
-                        ):
-                            hook_insert_index = j
-                            break
-                    if hook_insert_index == len(result):
-                        # Insert after packages line if section continues
-                        for j in range(i + 1, len(result)):
-                            if result[j].strip().startswith("["):
-                                hook_insert_index = j
-                                break
-                    break
-
-            # Insert build hook registration
-            hook_lines = [
-                "",
-                "[tool.hatch.build.hooks.custom]",
-                'path = "python_package_folder._hatch_build:CustomBuildHook"',
-            ]
-            result[hook_insert_index:hook_insert_index] = hook_lines
 
         # Ensure hatch build section exists if packages path is needed
         if not packages_set and correct_packages_path:
@@ -390,6 +326,10 @@ class SubfolderBuildConfig:
             # Handle README file
             self._handle_readme()
 
+            # Exclude files matching exclude patterns
+            if exclude_patterns:
+                self._exclude_files_by_patterns(exclude_patterns)
+
             return original_pyproject
 
         # No pyproject.toml in subfolder, create one from parent
@@ -497,6 +437,10 @@ class SubfolderBuildConfig:
         # Handle README file
         self._handle_readme()
 
+        # Exclude files matching exclude patterns
+        if exclude_patterns:
+            self._exclude_files_by_patterns(exclude_patterns)
+
         return original_pyproject
 
     def _modify_pyproject_string(
@@ -637,54 +581,13 @@ class SubfolderBuildConfig:
         has_build_system = any(line.strip().startswith("[build-system]") for line in result)
         if not has_build_system:
             # Insert build-system at the very beginning of the file
-            # Include python-package-folder in requires so the build hook is available
             build_system_lines = [
                 "[build-system]",
-                'requires = ["hatchling", "python-package-folder"]',
+                'requires = ["hatchling"]',
                 'build-backend = "hatchling.build"',
                 "",
             ]
             result = build_system_lines + result
-        else:
-            # Ensure python-package-folder is in requires for build hook availability
-            in_build_system = False
-            requires_modified = False
-            for i, line in enumerate(result):
-                if line.strip().startswith("[build-system]"):
-                    in_build_system = True
-                elif in_build_system and line.strip().startswith("requires"):
-                    # Check if python-package-folder is already in requires
-                    if "python-package-folder" not in line:
-                        # Add python-package-folder to requires
-                        if "]" in line:
-                            # Single-line requires (may have closing bracket on same line)
-                            if line.strip().endswith("]"):
-                                result[i] = line.rstrip().rstrip("]") + ', "python-package-folder"]'
-                            else:
-                                # Closing bracket might be on same line but not at end
-                                result[i] = line.rstrip().rstrip("]") + ', "python-package-folder"]'
-                        else:
-                            # Multi-line requires, find the closing bracket
-                            for j in range(i + 1, len(result)):
-                                if "]" in result[j]:
-                                    # Insert before closing
-                                    # Determine indentation from the previous line (last item in list)
-                                    if j > i + 1:
-                                        # Look at the previous line to get indentation
-                                        prev_line = result[j - 1]
-                                        # Extract leading whitespace from previous line
-                                        indent = len(prev_line) - len(prev_line.lstrip())
-                                        indent_str = " " * indent
-                                    else:
-                                        # Fallback: use standard 4-space indent
-                                        indent_str = "    "
-                                    result.insert(j, f'{indent_str}"python-package-folder",')
-                                    break
-                        requires_modified = True
-                    break
-                elif in_build_system and line.strip().startswith("[") and not line.strip().startswith("[build-system"):
-                    # End of build-system section
-                    break
 
         # Ensure packages is always set for subfolder builds
         if not packages_set and package_dirs:
@@ -695,65 +598,42 @@ class SubfolderBuildConfig:
             packages_str = ", ".join(f'"{p}"' for p in package_dirs)
             result.append(f"packages = [{packages_str}]")
 
-        # Register the build hook to enable exclude patterns
-        # Always register the build hook if exclude patterns are present, or if we want to support them
-        # Check if build hook is already registered
-        build_hook_registered = any(
-            "[tool.hatch.build.hooks.custom]" in line for line in result
-        )
-
-        if not build_hook_registered:
-            # Add build hook registration after [tool.hatch.build.targets.wheel] section
-            hook_insert_index = len(result)
-            wheel_section_found = False
-            for i, line in enumerate(result):
-                if line.strip().startswith("[tool.hatch.build.targets.wheel]"):
-                    wheel_section_found = True
-                    # Find the end of this section
-                    for j in range(i + 1, len(result)):
-                        if result[j].strip().startswith("[") and not result[j].strip().startswith(
-                            "[tool.hatch.build.targets"
-                        ):
-                            hook_insert_index = j
-                            break
-                    if hook_insert_index == len(result):
-                        # Insert after packages line if section continues
-                        for j in range(i + 1, len(result)):
-                            if result[j].strip().startswith("["):
-                                hook_insert_index = j
-                                break
-                    break
-
-            # If wheel section not found, insert before sdist section or at end
-            if not wheel_section_found:
-                for i, line in enumerate(result):
-                    if line.strip().startswith("[tool.hatch.build.targets.sdist]"):
-                        hook_insert_index = i
-                        break
-
-            # Insert build hook registration
-            hook_lines = [
-                "",
-                "[tool.hatch.build.hooks.custom]",
-                'path = "python_package_folder._hatch_build:CustomBuildHook"',
-            ]
-            result[hook_insert_index:hook_insert_index] = hook_lines
-
         # 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}]")
+            # Check if sdist section already exists
+            sdist_section_exists = any(
+                line.strip().startswith("[tool.hatch.build.targets.sdist]")
+                for line in result
+            )
+            # Check if only-include is already set in the sdist section
+            only_include_set = False
+            if sdist_section_exists:
+                in_sdist_section = False
+                for line in result:
+                    if line.strip().startswith("[tool.hatch.build.targets.sdist]"):
+                        in_sdist_section = True
+                    elif line.strip().startswith("[") and in_sdist_section:
+                        in_sdist_section = False
+                    elif in_sdist_section and re.match(r"^\s*only-include\s*=", line):
+                        only_include_set = True
+                        break
+
+            if not sdist_section_exists or not only_include_set:
+                if not sdist_section_exists:
+                    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)
+                if not only_include_set:
+                    result.append(f"only-include = [{only_include_str}]")
 
         # Add dependency group if specified
         if dependency_group:
@@ -1085,6 +965,110 @@ class SubfolderBuildConfig:
             target_readme.write_text(readme_content, encoding="utf-8")
             self.temp_readme = target_readme
 
+    def _exclude_files_by_patterns(self, exclude_patterns: list[str]) -> None:
+        """
+        Temporarily move files matching exclude patterns out of the source directory.
+
+        Files are moved to a temporary directory and will be restored in restore().
+        This ensures excluded files are not included in the build.
+
+        Args:
+            exclude_patterns: List of regex patterns to match against path components
+        """
+        if not exclude_patterns:
+            return
+
+        # Compile regex patterns for efficiency
+        compiled_patterns = [re.compile(pattern) for pattern in exclude_patterns]
+
+        def should_exclude(path: Path) -> bool:
+            """Check if a path should be excluded based on patterns."""
+            # Check each component of the path
+            for part in path.parts:
+                # Check if any part matches any pattern
+                for pattern in compiled_patterns:
+                    if pattern.search(part):
+                        return True
+            return False
+
+        # Create temporary directory for excluded files
+        if self._exclude_temp_dir is None:
+            self._exclude_temp_dir = Path(tempfile.mkdtemp(prefix="python-package-folder-excluded-"))
+
+        # Find all files and directories in src_dir that match exclude patterns
+        excluded_items: list[Path] = []
+        
+        # Walk through src_dir and find matching items
+        # Sort by depth (shallow first) so we can skip children of excluded directories
+        all_items = sorted(self.src_dir.rglob("*"), key=lambda p: len(p.parts))
+        
+        for item in all_items:
+            # Skip if already excluded (parent was excluded)
+            if any(
+                excluded.is_dir() and (item == excluded or item.is_relative_to(excluded))
+                for excluded in excluded_items
+            ):
+                continue
+            
+            # Check if this item should be excluded
+            try:
+                rel_path = item.relative_to(self.src_dir)
+                if should_exclude(rel_path):
+                    excluded_items.append(item)
+            except ValueError:
+                # Path is not relative to src_dir, skip
+                continue
+
+        # Move excluded items to temporary directory
+        for item in excluded_items:
+            try:
+                # Calculate relative path from src_dir
+                rel_path = item.relative_to(self.src_dir)
+                # Create corresponding path in temp directory
+                temp_path = self._exclude_temp_dir / rel_path
+                # Create parent directories if needed
+                temp_path.parent.mkdir(parents=True, exist_ok=True)
+                
+                # Move the item
+                if item.exists():
+                    shutil.move(str(item), str(temp_path))
+                    self._excluded_files.append((item, temp_path))
+                    print(f"Excluded {rel_path} from build", file=sys.stderr)
+            except Exception as e:
+                print(
+                    f"Warning: Could not exclude {item}: {e}",
+                    file=sys.stderr,
+                )
+
+    def _restore_excluded_files(self) -> None:
+        """Restore files that were excluded by _exclude_files_by_patterns."""
+        # Restore files in reverse order (to handle nested directories correctly)
+        for original_path, temp_path in reversed(self._excluded_files):
+            try:
+                if temp_path.exists():
+                    # Ensure parent directory exists
+                    original_path.parent.mkdir(parents=True, exist_ok=True)
+                    # Move back
+                    shutil.move(str(temp_path), str(original_path))
+            except Exception as e:
+                print(
+                    f"Warning: Could not restore excluded file {original_path}: {e}",
+                    file=sys.stderr,
+                )
+
+        # Clean up temporary directory
+        if self._exclude_temp_dir and self._exclude_temp_dir.exists():
+            try:
+                shutil.rmtree(self._exclude_temp_dir)
+            except Exception as e:
+                print(
+                    f"Warning: Could not remove temporary exclude directory {self._exclude_temp_dir}: {e}",
+                    file=sys.stderr,
+                )
+
+        self._excluded_files.clear()
+        self._exclude_temp_dir = None
+
     def restore(self) -> None:
         """
         Restore the original pyproject.toml and remove temporary __init__.py if created.
@@ -1094,6 +1078,9 @@ class SubfolderBuildConfig:
         This method removes the temporary pyproject.toml and restores the original from
         the backup location, ensuring the original file is never modified.
         """
+        # Restore excluded files first
+        self._restore_excluded_files()
+
         # Remove temporary __init__.py if we created it
         if self._temp_init_created:
             init_file = self.src_dir / "__init__.py"

{python_package_folder-5.1.1 → python_package_folder-5.1.2}/tests/test_subfolder_build.py

@@ -661,7 +661,7 @@ class TestSubfolderBuildTemporaryPyprojectCreation:
 
         # Verify build-system section is added (required for hatchling)
         assert "[build-system]" in content
-        assert 'requires = ["hatchling", "python-package-folder"]' in content
+        assert 'requires = ["hatchling"]' in content
         assert 'build-backend = "hatchling.build"' in content
         assert "[tool.hatch.version]" not in content
         assert "[tool.uv-dynamic-versioning]" not in content
@@ -894,7 +894,7 @@ description = "Subfolder package"
 
             # Verify build-system section uses hatchling, not setuptools
             assert "[build-system]" in content
-            assert 'requires = ["hatchling", "python-package-folder"]' in content
+            assert 'requires = ["hatchling"]' in content
             assert 'build-backend = "hatchling.build"' in content
             assert "setuptools" not in content or 'build-backend = "setuptools' not in content
 
@@ -929,7 +929,7 @@ description = "Subfolder package"
 
         # Verify build-system section is added
         assert "[build-system]" in content
-        assert 'requires = ["hatchling", "python-package-folder"]' in content
+        assert 'requires = ["hatchling"]' in content
         assert 'build-backend = "hatchling.build"' in content
 
         config.restore()

python_package_folder-5.1.1/src/python_package_folder/_hatch_build.py

@@ -1,173 +0,0 @@
-"""
-Hatch build hook to automatically include all files from the scripts directory.
-
-This hook ensures all non-Python files in the scripts directory are included
-in the wheel without creating duplicates, and automatically includes any new
-files added to the directory without requiring manual configuration updates.
-
-Also filters files based on exclude patterns from pyproject.toml.
-"""
-
-import re
-import sys
-from pathlib import Path
-from typing import Any
-
-from hatchling.builders.hooks.plugin.interface import BuildHookInterface
-
-from .utils import read_exclude_patterns
-
-
-class CustomBuildHook(BuildHookInterface):
-    """Build hook to include all files from the scripts directory and filter exclude patterns."""
-
-    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
-        """Initialize the build hook and add scripts directory files."""
-        # Debug: Print to stderr so it shows in build output
-        print(f"[DEBUG] Build hook called. Root: {self.root}", file=sys.stderr)
-        
-        # Read exclude patterns from pyproject.toml
-        pyproject_path = Path(self.root) / "pyproject.toml"
-        exclude_patterns = read_exclude_patterns(pyproject_path)
-        
-        if exclude_patterns:
-            print(f"[DEBUG] Found {len(exclude_patterns)} exclude pattern(s): {exclude_patterns}", file=sys.stderr)
-            # Filter build_data entries based on exclude patterns
-            self._filter_build_data(build_data, exclude_patterns)
-        
-        # Try multiple possible locations for the scripts directory
-        # 1. Source layout: src/python_package_folder/scripts
-        # 2. Sdist layout: python_package_folder/scripts (after extraction)
-        # 3. Alternative sdist layout: scripts/ (if extracted differently)
-        possible_scripts_dirs = [
-            Path(self.root) / "src" / "python_package_folder" / "scripts",
-            Path(self.root) / "python_package_folder" / "scripts",
-            Path(self.root) / "scripts",
-        ]
-        
-        scripts_dir = None
-        for possible_dir in possible_scripts_dirs:
-            if possible_dir.exists() and possible_dir.is_dir():
-                scripts_dir = possible_dir
-                print(f"[DEBUG] Found scripts dir at: {scripts_dir}", file=sys.stderr)
-                break
-        
-        if scripts_dir is None:
-            print(f"[DEBUG] Scripts directory not found. Tried: {[str(d) for d in possible_scripts_dirs]}", file=sys.stderr)
-            return
-
-        # If scripts directory exists, include all files from it
-        if scripts_dir.exists() and scripts_dir.is_dir():
-            # Add all files from scripts directory to force-include
-            # This ensures they're included in the wheel at the correct location
-            for script_file in scripts_dir.iterdir():
-                if script_file.is_file():
-                    # Calculate relative paths from project root
-                    try:
-                        source_path = script_file.relative_to(self.root)
-                    except ValueError:
-                        # If relative_to fails, try to construct path manually
-                        # This can happen with sdist layouts
-                        if "python_package_folder" in str(script_file):
-                            # Extract the part after python_package_folder
-                            parts = script_file.parts
-                            try:
-                                idx = parts.index("python_package_folder")
-                                source_path = Path(*parts[idx:])
-                            except (ValueError, IndexError):
-                                # Fallback: use the filename
-                                source_path = Path("python_package_folder") / "scripts" / script_file.name
-                        else:
-                            source_path = Path("python_package_folder") / "scripts" / script_file.name
-                    
-                    # Target path inside the wheel package (always the same)
-                    target_path = f"python_package_folder/scripts/{script_file.name}"
-
-                    print(f"[DEBUG] Adding {source_path} -> {target_path}", file=sys.stderr)
-
-                    # Add to force-include (hatchling will handle this)
-                    # We need to add it to build_data['force_include']
-                    if "force_include" not in build_data:
-                        build_data["force_include"] = {}
-                    build_data["force_include"][str(source_path)] = target_path
-            
-            print(f"[DEBUG] force_include now has {len(build_data.get('force_include', {}))} entries", file=sys.stderr)
-
-    def _filter_build_data(self, build_data: dict[str, Any], exclude_patterns: list[str]) -> None:
-        """
-        Filter build_data entries based on exclude patterns.
-
-        Removes files/directories that match any of the exclude patterns from
-        build_data. Patterns are matched against any path component using regex.
-
-        Args:
-            build_data: Hatchling build data dictionary
-            exclude_patterns: List of regex patterns to match against paths
-        """
-        # Compile regex patterns for efficiency
-        compiled_patterns = [re.compile(pattern) for pattern in exclude_patterns]
-
-        def should_exclude(path_str: str) -> bool:
-            """Check if a path should be excluded based on patterns."""
-            # Check each component of the path
-            path = Path(path_str)
-            for part in path.parts:
-                # Check if any part matches any pattern
-                for pattern in compiled_patterns:
-                    if pattern.search(part):
-                        return True
-            return False
-
-        # Filter force_include entries
-        if "force_include" in build_data and isinstance(build_data["force_include"], dict):
-            original_count = len(build_data["force_include"])
-            filtered = {
-                source: target
-                for source, target in build_data["force_include"].items()
-                if not should_exclude(source) and not should_exclude(target)
-            }
-            build_data["force_include"] = filtered
-            excluded_count = original_count - len(filtered)
-            if excluded_count > 0:
-                print(
-                    f"[DEBUG] Excluded {excluded_count} file(s) from force_include based on exclude patterns",
-                    file=sys.stderr,
-                )
-
-        # Filter other file collections that might exist
-        # Hatchling may store files in different keys depending on the build target
-        for key in ["shared_data", "artifacts"]:
-            if key in build_data and isinstance(build_data[key], dict):
-                original_count = len(build_data[key])
-                filtered = {
-                    source: target
-                    for source, target in build_data[key].items()
-                    if not should_exclude(source) and not should_exclude(target)
-                }
-                build_data[key] = filtered
-                excluded_count = original_count - len(filtered)
-                if excluded_count > 0:
-                    print(
-                        f"[DEBUG] Excluded {excluded_count} file(s) from {key} based on exclude patterns",
-                        file=sys.stderr,
-                    )
-
-        # Filter files list if it exists (for sdist)
-        if "files" in build_data and isinstance(build_data["files"], list):
-            original_count = len(build_data["files"])
-            filtered = [
-                file_entry
-                for file_entry in build_data["files"]
-                if not should_exclude(str(file_entry))
-            ]
-            build_data["files"] = filtered
-            excluded_count = original_count - len(filtered)
-            if excluded_count > 0:
-                print(
-                    f"[DEBUG] Excluded {excluded_count} file(s) from files list based on exclude patterns",
-                    file=sys.stderr,
-                )
-
-
-# Export the hook class (hatchling might need this)
-__all__ = ["CustomBuildHook"]