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

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

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

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

{python_package_folder-5.0.0 → 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.0 → python_package_folder-5.1.0}/src/python_package_folder/python_package_folder.py

@@ -10,6 +10,8 @@ It can be invoked via:
 
 from __future__ import annotations
 
+import logging
+import os
 import subprocess
 import sys
 from pathlib import Path
@@ -18,6 +20,13 @@ from .manager import BuildManager
 from .utils import find_project_root, find_source_directory
 from .version_calculator import resolve_version
 
+# Configure logging for version resolution
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)s: %(message)s",
+    handlers=[logging.StreamHandler(sys.stderr)],
+)
+
 
 def is_github_actions() -> bool:
     """Check if running in GitHub Actions."""

{python_package_folder-5.0.0 → 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.0 → 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.0.0 → python_package_folder-5.1.0}/src/python_package_folder/version_calculator.py

@@ -10,12 +10,15 @@ Reference: https://semantic-release.gitbook.io/semantic-release/
 
 from __future__ import annotations
 
+import logging
 import re
 import subprocess
 from pathlib import Path
 
 import requests
 
+logger = logging.getLogger(__name__)
+
 
 def query_registry_version(
     package_name: str,
@@ -38,13 +41,26 @@ def query_registry_version(
 
     try:
         if repository in ("pypi", "testpypi"):
-            return _query_pypi_version(package_name, repository)
+            logger.info(f"Querying {repository} for package '{package_name}'")
+            version = _query_pypi_version(package_name, repository)
+            if version:
+                logger.info(f"Found version {version} on {repository}")
+            else:
+                logger.info(f"Package '{package_name}' not found on {repository} (first release)")
+            return version
         elif repository == "azure":
             if not repository_url:
+                logger.warning("Azure Artifacts repository URL not provided")
                 return None
-            return _query_azure_artifacts_version(package_name, repository_url)
-    except Exception:
-        # Log error but don't fail - fall back to git tags
+            logger.info(f"Querying Azure Artifacts for package '{package_name}' at {repository_url}")
+            version = _query_azure_artifacts_version(package_name, repository_url)
+            if version:
+                logger.info(f"Found version {version} on Azure Artifacts")
+            else:
+                logger.info(f"Could not retrieve version from Azure Artifacts for '{package_name}' (will fall back to git tags)")
+            return version
+    except Exception as e:
+        logger.warning(f"Error querying {repository} for package '{package_name}': {e}", exc_info=True)
         return None
 
     return None
@@ -68,6 +84,7 @@ def _query_pypi_version(package_name: str, registry: str) -> str | None:
         response = requests.get(url, timeout=10)
         if response.status_code == 404:
             # Package doesn't exist yet (first release)
+            logger.debug(f"Package '{package_name}' not found on {registry} (404)")
             return None
         if response.status_code == 200:
             json_data = response.json()
@@ -80,9 +97,16 @@ def _query_pypi_version(package_name: str, registry: str) -> str | None:
                     # Sort versions and get latest
                     versions = sorted(releases.keys(), key=_parse_version_for_sort)
                     version = versions[-1] if versions else None
+            if version:
+                logger.debug(f"Retrieved version {version} from {registry} for '{package_name}'")
             return version
+        logger.warning(f"Unexpected status code {response.status_code} from {registry} for '{package_name}'")
         return None
-    except Exception:
+    except requests.RequestException as e:
+        logger.warning(f"Network error querying {registry} for '{package_name}': {e}")
+        return None
+    except Exception as e:
+        logger.warning(f"Error parsing response from {registry} for '{package_name}': {e}", exc_info=True)
         return None
 
 
@@ -111,17 +135,35 @@ def _query_azure_artifacts_version(
             simple_index_url = repository_url.replace("/upload", f"/simple/{package_name}/")
         else:
             simple_index_url = repository_url.rstrip("/") + f"/simple/{package_name}/"
-    except Exception:
+        logger.debug(f"Constructed Azure Artifacts simple index URL: {simple_index_url}")
+    except Exception as e:
+        logger.warning(f"Error constructing Azure Artifacts URL for '{package_name}': {e}")
         return None
 
     try:
         response = requests.get(simple_index_url, timeout=5)
+        logger.debug(f"Azure Artifacts response status: {response.status_code}")
+        
+        if response.status_code == 401:
+            logger.warning(f"Authentication required for Azure Artifacts (401). Package '{package_name}' may require authentication to query.")
+        elif response.status_code == 403:
+            logger.warning(f"Access forbidden for Azure Artifacts (403). Package '{package_name}' may not be accessible or requires different permissions.")
+        elif response.status_code == 404:
+            logger.debug(f"Package '{package_name}' not found on Azure Artifacts (404) - first release")
+        elif response.status_code != 200:
+            logger.warning(f"Unexpected status code {response.status_code} from Azure Artifacts for '{package_name}'")
+        
         # Azure Artifacts simple index returns HTML, not JSON
         # Parsing HTML is complex and may require authentication
         # For now, we'll return None to fall back to git tags
         # This can be enhanced later with proper HTML parsing or API endpoint discovery
+        logger.info(f"Azure Artifacts version query not fully implemented (HTML parsing required). Falling back to git tags.")
         return None
-    except Exception:
+    except requests.RequestException as e:
+        logger.warning(f"Network error querying Azure Artifacts for '{package_name}': {e}")
+        return None
+    except Exception as e:
+        logger.warning(f"Unexpected error querying Azure Artifacts for '{package_name}': {e}", exc_info=True)
         return None
 
 
@@ -465,26 +507,91 @@ def resolve_version(
     # Step 1: Try to get baseline version from registry
     baseline_version = None
     if repository and package_name:
+        logger.info(f"Attempting to query {repository} for baseline version of '{package_name}'")
         baseline_version = query_registry_version(package_name, repository, repository_url)
 
     # Step 2: Fallback to git tags if registry query failed
     if not baseline_version:
+        logger.info(f"Registry query did not return a version, falling back to git tags")
+        if is_subfolder:
+            logger.debug(f"Looking for subfolder git tags matching '{package_name}-v*'")
+        else:
+            logger.debug("Looking for main package git tags matching 'v*'")
         baseline_version = get_latest_git_tag(project_root, package_name, is_subfolder)
+        if baseline_version:
+            logger.info(f"Found baseline version {baseline_version} from git tags")
+        else:
+            logger.info("No git tags found")
 
-    # Step 3: If still no baseline, we can't calculate next version
+    # Step 3: If still no baseline, this is likely the first release
+    # Default to 0.0.0 as the starting version (standard semantic-release behavior)
     if not baseline_version:
-        # This could be the first release - we'd need to decide on a starting version
-        # For now, return None to indicate we can't determine the version
-        return None, "No baseline version found (no registry version or git tags)"
-
-    # Step 4: Get commits since baseline
-    commits = get_commits_since(project_root, baseline_version, subfolder_path, package_name)
+        logger.info("No baseline version found (no registry version or git tags). Treating as first release (baseline: 0.0.0)")
+        baseline_version = "0.0.0"
+        # For first release, get all commits (no baseline to compare against)
+        # Use HEAD as the reference point to get all commits
+        try:
+            cmd = ["git", "log", "--format=%B", "HEAD"]
+            if subfolder_path:
+                # Convert to relative path from project root
+                if subfolder_path.is_absolute():
+                    rel_path = subfolder_path.relative_to(project_root)
+                else:
+                    rel_path = subfolder_path
+                cmd.append("--")
+                cmd.append(str(rel_path))
+            
+            result = subprocess.run(
+                cmd,
+                cwd=project_root,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            
+            commits = []
+            if result.returncode == 0:
+                # Split commits (they're separated by double newlines in --format=%B)
+                current_commit = []
+                for line in result.stdout.split("\n"):
+                    if line.strip() == "" and current_commit:
+                        commit_msg = "\n".join(current_commit).strip()
+                        if commit_msg:
+                            commits.append(commit_msg)
+                        current_commit = []
+                    else:
+                        current_commit.append(line)
+                
+                # Don't forget the last commit if there's no trailing newline
+                if current_commit:
+                    commit_msg = "\n".join(current_commit).strip()
+                    if commit_msg:
+                        commits.append(commit_msg)
+                logger.debug(f"Retrieved {len(commits)} commits for first release")
+        except Exception as e:
+            logger.warning(f"Error retrieving commits for first release: {e}", exc_info=True)
+            commits = []
+    else:
+        # Step 4: Get commits since baseline
+        logger.info(f"Retrieving commits since version {baseline_version}")
+        if subfolder_path:
+            logger.debug(f"Filtering commits for subfolder path: {subfolder_path}")
+        commits = get_commits_since(project_root, baseline_version, subfolder_path, package_name)
+        logger.debug(f"Found {len(commits)} commits since {baseline_version}")
 
     # Step 5: Calculate next version
+    logger.info(f"Calculating next version from baseline {baseline_version} and {len(commits)} commits")
     next_version = calculate_next_version(baseline_version, commits)
 
     if next_version:
+        logger.info(f"Calculated next version: {next_version}")
         return next_version, None
     else:
         # No relevant commits for version bump
+        # For first release (0.0.0), default to 0.1.0 if there are any commits
+        if baseline_version == "0.0.0" and commits:
+            # Even if commits don't match conventional format, start at 0.1.0 for first release
+            logger.info("No conventional commits found, but commits exist. Defaulting to 0.1.0 for first release")
+            return "0.1.0", None
+        logger.info("No version bump needed (no relevant conventional commits found)")
         return None, None

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()

{python_package_folder-5.0.0 → python_package_folder-5.1.0}/tests/test_version_calculator.py

@@ -414,14 +414,22 @@ class TestResolveVersion:
 
     @patch("python_package_folder.version_calculator.query_registry_version")
     @patch("python_package_folder.version_calculator.get_latest_git_tag")
+    @patch("python_package_folder.version_calculator.subprocess.run")
     def test_resolve_version_no_baseline(
         self,
+        mock_subprocess: MagicMock,
         mock_git_tag: MagicMock,
         mock_registry: MagicMock,
     ) -> None:
-        """Test error when no baseline version is found."""
+        """Test first release behavior when no baseline version is found."""
         mock_registry.return_value = None
         mock_git_tag.return_value = None
+        
+        # Mock git log for first release with conventional commits
+        mock_result = Mock()
+        mock_result.returncode = 0
+        mock_result.stdout = "feat: initial feature\n\n"
+        mock_subprocess.return_value = mock_result
 
         version, error = resolve_version(
             Path("/tmp/test"),
@@ -429,9 +437,9 @@ class TestResolveVersion:
             repository="pypi",
         )
 
-        assert version is None
-        assert error is not None
-        assert "baseline version" in error.lower()
+        # For first release with feat commit, should calculate 0.1.0 (0.0.0 + minor)
+        assert version == "0.1.0"
+        assert error is None
 
     @patch("python_package_folder.version_calculator.query_registry_version")
     @patch("python_package_folder.version_calculator.get_commits_since")