python-package-folder 5.0.1__tar.gz → 5.1.0__tar.gz

{python_package_folder-5.0.1 → python_package_folder-5.1.0}/PKG-INFO

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

{python_package_folder-5.0.1 → python_package_folder-5.1.0}/docs/REFERENCE.md

@@ -1,5 +1,28 @@
 # API Reference
 
+## Configuration
+
+### Exclude Patterns
+
+You can configure exclude patterns in `pyproject.toml` to prevent folders and files from being included in published packages (wheel/sdist). Patterns are matched using regex against any path component (directory or file name).
+
+```toml
+[tool.python-package-folder]
+exclude-patterns = ["_SS", "__SS", ".*_test.*", "sandbox"]
+```
+
+**Pattern Matching:**
+- Patterns are regex strings that match against any path component
+- If any component in a path matches any pattern, the entire path is excluded
+- Examples:
+  - `"_SS"` - Matches any path component containing `_SS` (e.g., `data_storage/_SS/...`)
+  - `".*_test.*"` - Matches any path component containing `_test` (e.g., `my_test_file.py`, `test_data/`)
+  - `"sandbox"` - Matches any path component containing `sandbox`
+
+**Subfolder Builds:**
+- Exclude patterns from the root `pyproject.toml` are automatically applied to subfolder builds
+- Patterns are injected into the temporary `pyproject.toml` created for subfolder builds
+
 ## Command Line Options
 
 ```

{python_package_folder-5.0.1 → python_package_folder-5.1.0}/docs/USAGE.md

@@ -46,6 +46,7 @@
    - Subfolder-specific package name (derived or custom)
    - Specified version
    - Correct package path for hatchling
+   - Exclude patterns from root `pyproject.toml` (if configured)
 6. **Build Execution**: Runs build command with all dependencies in place
 7. **Cleanup**: Restores original `pyproject.toml` and removes temporary `__init__.py`
 
@@ -114,6 +115,15 @@ python-package-folder --version "1.0.0" --dependency-group "dev" --publish pypi
 
 The specified dependency group will be copied from the parent `pyproject.toml`'s `[dependency-groups]` section into the temporary `pyproject.toml` used for the subfolder build.
 
+**Exclude Patterns**: You can configure exclude patterns in the root `pyproject.toml` to prevent certain folders/files from being included in published packages:
+
+```toml
+[tool.python-package-folder]
+exclude-patterns = ["_SS", "__SS", ".*_test.*"]
+```
+
+These patterns are automatically applied to both main package builds and subfolder builds. Patterns use regex matching against any path component (directory or file name). See the [API Reference](REFERENCE.md#exclude-patterns) for more details.
+
 ## Python API Usage
 
 You can also use the package programmatically:

{python_package_folder-5.0.1 → python_package_folder-5.1.0}/pyproject.toml

@@ -43,7 +43,7 @@ dependencies = [
 
 # ---- Dev dependencies ----
 
-version = "5.0.1"
+version = "5.1.0"
 [dependency-groups]
 dev = [
     "pytest>=8.3.5",

{python_package_folder-5.0.1 → python_package_folder-5.1.0}/src/python_package_folder/_hatch_build.py

@@ -4,23 +4,37 @@ 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."""
+    """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)
@@ -79,6 +93,81 @@ class CustomBuildHook(BuildHookInterface):
             
             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"]

{python_package_folder-5.0.1 → python_package_folder-5.1.0}/src/python_package_folder/subfolder_build.py

@@ -24,6 +24,8 @@ except ImportError:
     except ImportError:
         tomllib = None
 
+from .utils import read_exclude_patterns
+
 
 class SubfolderBuildConfig:
     """
@@ -288,6 +290,11 @@ class SubfolderBuildConfig:
             subfolder_content = subfolder_pyproject.read_text(encoding="utf-8")
             # Adjust packages path to be relative to project root
             adjusted_content = self._adjust_subfolder_pyproject_packages_path(subfolder_content)
+            
+            # Read exclude patterns from root pyproject.toml and inject them
+            exclude_patterns = read_exclude_patterns(original_pyproject)
+            if exclude_patterns:
+                adjusted_content = self._inject_exclude_patterns(adjusted_content, exclude_patterns)
 
             # Write adjusted content to temporary file
             temp_pyproject_path.write_text(adjusted_content, encoding="utf-8")
@@ -373,6 +380,9 @@ class SubfolderBuildConfig:
                     file=sys.stderr,
                 )
 
+        # Read exclude patterns from root pyproject.toml
+        exclude_patterns = read_exclude_patterns(original_pyproject)
+
         if data:
             # Modify using parsed data
             if "project" in data:
@@ -394,12 +404,12 @@ class SubfolderBuildConfig:
 
             # For now, use string manipulation (tomli-w not in stdlib)
             modified_content = self._modify_pyproject_string(
-                original_content, parent_dependency_group
+                original_content, parent_dependency_group, exclude_patterns
             )
         else:
             # Use string manipulation
             modified_content = self._modify_pyproject_string(
-                original_content, parent_dependency_group
+                original_content, parent_dependency_group, exclude_patterns
             )
 
         # Write the modified content to a temporary file
@@ -423,7 +433,10 @@ class SubfolderBuildConfig:
         return original_pyproject
 
     def _modify_pyproject_string(
-        self, content: str, dependency_group: dict[str, list[str]] | None = None
+        self,
+        content: str,
+        dependency_group: dict[str, list[str]] | None = None,
+        exclude_patterns: list[str] | None = None,
     ) -> str:
         """Modify pyproject.toml content using string manipulation."""
         lines = content.split("\n")
@@ -635,8 +648,112 @@ class SubfolderBuildConfig:
                     dep_lines.append("]")
                 result[insert_index:insert_index] = dep_lines
 
+        # Add exclude patterns if specified
+        if exclude_patterns:
+            # Find where to insert [tool.python-package-folder] section
+            # Usually after [dependency-groups] or at the end
+            insert_index = len(result)
+            tool_section_exists = False
+            for i, line in enumerate(result):
+                if line.strip() == "[tool.python-package-folder]":
+                    tool_section_exists = True
+                    insert_index = i
+                    break
+                elif line.strip().startswith("[tool.") and i > 0:
+                    # Insert before other tool sections
+                    insert_index = i
+                    break
+
+            # Format exclude patterns
+            patterns_str = ", ".join(f'"{p}"' for p in exclude_patterns)
+            exclude_lines = [
+                "",
+                "[tool.python-package-folder]",
+                f'exclude-patterns = [{patterns_str}]',
+            ]
+
+            if tool_section_exists:
+                # Replace or update existing section
+                end_index = insert_index + 1
+                while end_index < len(result) and not result[end_index].strip().startswith("["):
+                    end_index += 1
+                # Check if exclude-patterns already exists
+                has_exclude_patterns = any(
+                    "exclude-patterns" in result[i] for i in range(insert_index, end_index)
+                )
+                if has_exclude_patterns:
+                    # Update existing exclude-patterns line
+                    for i in range(insert_index, end_index):
+                        if "exclude-patterns" in result[i]:
+                            result[i] = f'exclude-patterns = [{patterns_str}]'
+                            break
+                else:
+                    # Add exclude-patterns to existing section
+                    result.insert(end_index - 1, f'exclude-patterns = [{patterns_str}]')
+            else:
+                # Insert new section
+                result[insert_index:insert_index] = exclude_lines
+
         return "\n".join(result)
 
+    def _inject_exclude_patterns(self, content: str, exclude_patterns: list[str]) -> str:
+        """
+        Inject exclude patterns into pyproject.toml content.
+
+        Adds or updates [tool.python-package-folder] exclude-patterns section.
+
+        Args:
+            content: pyproject.toml content
+            exclude_patterns: List of exclude patterns to inject
+
+        Returns:
+            Modified pyproject.toml content with exclude patterns
+        """
+        if not exclude_patterns:
+            return content
+
+        lines = content.split("\n")
+        result = []
+        tool_section_exists = False
+        tool_section_index = -1
+        tool_section_end = -1
+
+        # Find [tool.python-package-folder] section
+        for i, line in enumerate(lines):
+            if line.strip() == "[tool.python-package-folder]":
+                tool_section_exists = True
+                tool_section_index = i
+                # Find end of section
+                for j in range(i + 1, len(lines)):
+                    if lines[j].strip().startswith("["):
+                        tool_section_end = j
+                        break
+                if tool_section_end == -1:
+                    tool_section_end = len(lines)
+                break
+
+        if tool_section_exists:
+            # Update existing section
+            patterns_str = ", ".join(f'"{p}"' for p in exclude_patterns)
+            has_exclude_patterns = False
+            for i in range(tool_section_index + 1, tool_section_end):
+                if "exclude-patterns" in lines[i]:
+                    # Update existing line
+                    lines[i] = f'exclude-patterns = [{patterns_str}]'
+                    has_exclude_patterns = True
+                    break
+            if not has_exclude_patterns:
+                # Add exclude-patterns to existing section
+                lines.insert(tool_section_end, f'exclude-patterns = [{patterns_str}]')
+            return "\n".join(lines)
+        else:
+            # Add new section at the end
+            patterns_str = ", ".join(f'"{p}"' for p in exclude_patterns)
+            lines.append("")
+            lines.append("[tool.python-package-folder]")
+            lines.append(f'exclude-patterns = [{patterns_str}]')
+            return "\n".join(lines)
+
     def add_third_party_dependencies(self, dependencies: list[str]) -> None:
         """
         Add third-party dependencies to the temporary pyproject.toml.

{python_package_folder-5.0.1 → python_package_folder-5.1.0}/src/python_package_folder/utils.py

@@ -6,6 +6,14 @@ from __future__ import annotations
 
 from pathlib import Path
 
+try:
+    import tomllib
+except ImportError:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        tomllib = None
+
 
 def find_project_root(start_path: Path | None = None) -> Path | None:
     """
@@ -106,3 +114,64 @@ def is_python_package_directory(path: Path) -> bool:
         return True
 
     return False
+
+
+def read_exclude_patterns(pyproject_path: Path) -> list[str]:
+    """
+    Read exclude patterns from pyproject.toml.
+
+    Reads the exclude-patterns configuration from [tool.python-package-folder] section.
+    Returns an empty list if the section or option doesn't exist.
+
+    Args:
+        pyproject_path: Path to the pyproject.toml file
+
+    Returns:
+        List of exclude patterns (regex strings), or empty list if not found
+    """
+    if not pyproject_path.exists():
+        return []
+
+    try:
+        if tomllib:
+            content = pyproject_path.read_text(encoding="utf-8")
+            data = tomllib.loads(content)
+            tool_section = data.get("tool", {})
+            tool_config = tool_section.get("python-package-folder", {})
+            # TOML keys with hyphens are preserved as-is
+            patterns = tool_config.get("exclude-patterns", [])
+            if isinstance(patterns, list):
+                return [str(p) for p in patterns]
+            return []
+        else:
+            # Fallback: simple string parsing
+            content = pyproject_path.read_text(encoding="utf-8")
+            in_section = False
+            patterns = []
+            for line in content.split("\n"):
+                stripped = line.strip()
+                if stripped == "[tool.python-package-folder]":
+                    in_section = True
+                    continue
+                elif stripped.startswith("[") and in_section:
+                    # Moved to a different section
+                    break
+                elif in_section and stripped.startswith("exclude-patterns"):
+                    # Parse the array
+                    if "=" in stripped:
+                        value = stripped.split("=", 1)[1].strip()
+                        # Simple parsing for array of strings
+                        if value.startswith("[") and value.endswith("]"):
+                            # Remove brackets and split
+                            items = value[1:-1].split(",")
+                            for item in items:
+                                item = item.strip().strip('"').strip("'")
+                                if item:
+                                    patterns.append(item)
+                            break
+            return patterns
+    except Exception:
+        # If parsing fails, return empty list
+        return []
+
+    return []

python_package_folder-5.1.0/tests/test_exclude_patterns.py

@@ -0,0 +1,186 @@
+"""Tests for exclude patterns functionality."""
+
+from __future__ import annotations
+
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from python_package_folder import BuildManager, SubfolderBuildConfig
+from python_package_folder.utils import read_exclude_patterns
+
+
+@pytest.fixture
+def test_project_with_exclude_patterns(tmp_path: Path) -> Path:
+    """Create a test project with exclude patterns in pyproject.toml."""
+    project_root = tmp_path / "test_project"
+    project_root.mkdir()
+
+    # Create pyproject.toml with exclude patterns
+    pyproject_content = """[project]
+name = "test-package"
+version = "0.1.0"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/test_package"]
+
+[tool.python-package-folder]
+exclude-patterns = ["_SS", ".*_test.*", "sandbox"]
+"""
+    (project_root / "pyproject.toml").write_text(pyproject_content)
+
+    # Create source directory structure
+    src_dir = project_root / "src" / "test_package"
+    src_dir.mkdir(parents=True)
+
+    # Create regular files
+    (src_dir / "__init__.py").write_text("")
+    (src_dir / "module.py").write_text("def func(): pass")
+
+    # Create files that should be excluded
+    (src_dir / "module_test.py").write_text("# test file")
+    (src_dir / "test_data.py").write_text("# test data")
+
+    # Create directories that should be excluded
+    ss_dir = src_dir / "data_storage" / "_SS"
+    ss_dir.mkdir(parents=True)
+    (ss_dir / "file.py").write_text("# SS file")
+
+    sandbox_dir = src_dir / "sandbox"
+    sandbox_dir.mkdir()
+    (sandbox_dir / "file.py").write_text("# sandbox file")
+
+    # Create nested excluded directory
+    nested_ss = src_dir / "nested" / "_SS_nested"
+    nested_ss.mkdir(parents=True)
+    (nested_ss / "file.py").write_text("# nested SS file")
+
+    return project_root
+
+
+@pytest.fixture
+def test_subfolder_project(tmp_path: Path) -> Path:
+    """Create a test project with subfolder and exclude patterns."""
+    project_root = tmp_path / "test_project"
+    project_root.mkdir()
+
+    # Create pyproject.toml with exclude patterns
+    pyproject_content = """[project]
+name = "test-package"
+version = "0.1.0"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/test_package"]
+
+[tool.python-package-folder]
+exclude-patterns = ["_SS", ".*_test.*"]
+"""
+    (project_root / "pyproject.toml").write_text(pyproject_content)
+
+    # Create subfolder
+    subfolder = project_root / "subfolder"
+    subfolder.mkdir()
+    (subfolder / "__init__.py").write_text("")
+    (subfolder / "module.py").write_text("def func(): pass")
+
+    # Create files that should be excluded
+    (subfolder / "module_test.py").write_text("# test file")
+    ss_dir = subfolder / "_SS"
+    ss_dir.mkdir()
+    (ss_dir / "file.py").write_text("# SS file")
+
+    return project_root
+
+
+class TestReadExcludePatterns:
+    """Tests for reading exclude patterns from pyproject.toml."""
+
+    def test_read_exclude_patterns_exists(self, test_project_with_exclude_patterns: Path) -> None:
+        """Test reading exclude patterns when they exist."""
+        pyproject_path = test_project_with_exclude_patterns / "pyproject.toml"
+        patterns = read_exclude_patterns(pyproject_path)
+
+        assert len(patterns) == 3
+        assert "_SS" in patterns
+        assert ".*_test.*" in patterns
+        assert "sandbox" in patterns
+
+    def test_read_exclude_patterns_not_exists(self, tmp_path: Path) -> None:
+        """Test reading exclude patterns when section doesn't exist."""
+        pyproject_path = tmp_path / "pyproject.toml"
+        pyproject_path.write_text("[project]\nname = 'test'")
+
+        patterns = read_exclude_patterns(pyproject_path)
+        assert patterns == []
+
+    def test_read_exclude_patterns_file_not_exists(self, tmp_path: Path) -> None:
+        """Test reading exclude patterns when file doesn't exist."""
+        pyproject_path = tmp_path / "nonexistent.toml"
+        patterns = read_exclude_patterns(pyproject_path)
+        assert patterns == []
+
+
+class TestExcludePatternsInBuild:
+    """Tests for exclude patterns in build process."""
+
+    def test_exclude_patterns_in_temp_pyproject(
+        self, test_project_with_exclude_patterns: Path
+    ) -> None:
+        """Test that exclude patterns are injected into temporary pyproject.toml."""
+        project_root = test_project_with_exclude_patterns
+        src_dir = project_root / "src" / "test_package"
+
+        # This is detected as a subfolder build
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=src_dir,
+            package_name="test-package",
+            version="1.0.0",
+        )
+
+        temp_pyproject = config.create_temp_pyproject()
+        assert temp_pyproject is not None
+
+        # Check that exclude patterns are in the temporary pyproject.toml
+        content = temp_pyproject.read_text()
+        assert "[tool.python-package-folder]" in content
+        assert "exclude-patterns" in content
+        assert "_SS" in content
+        assert ".*_test.*" in content
+        assert "sandbox" in content
+
+        config.restore()
+
+    def test_exclude_patterns_subfolder_build(self, test_subfolder_project: Path) -> None:
+        """Test that exclude patterns from root are applied to subfolder builds."""
+        project_root = test_subfolder_project
+        subfolder = project_root / "subfolder"
+
+        config = SubfolderBuildConfig(
+            project_root=project_root,
+            src_dir=subfolder,
+            package_name="subfolder",
+            version="1.0.0",
+        )
+
+        # Create temporary pyproject.toml
+        temp_pyproject = config.create_temp_pyproject()
+        assert temp_pyproject is not None
+
+        # Check that exclude patterns are in the temporary pyproject.toml
+        content = temp_pyproject.read_text()
+        assert "[tool.python-package-folder]" in content
+        assert "exclude-patterns" in content
+        assert "_SS" in content
+        assert ".*_test.*" in content
+
+        config.restore()