python-package-folder 3.1.3__py3-none-any.whl → 4.1.0__py3-none-any.whl

python_package_folder/_hatch_build.py

@@ -0,0 +1,39 @@
+"""
+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.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+
+class CustomBuildHook(BuildHookInterface):
+    """Build hook to include all files from the scripts directory."""
+
+    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
+        """Initialize the build hook and add scripts directory files."""
+        # Get the source directory for the package
+        source_dir = Path(self.root) / "src" / "python_package_folder"
+        scripts_dir = source_dir / "scripts"
+
+        # 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
+                    source_path = script_file.relative_to(self.root)
+                    # Target path inside the wheel package
+                    target_path = f"python_package_folder/scripts/{script_file.name}"
+
+                    # 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

python_package_folder/python_package_folder.py

@@ -14,10 +14,157 @@ import subprocess
 import sys
 from pathlib import Path
 
+try:
+    from importlib import resources
+except ImportError:
+    import importlib_resources as resources  # type: ignore[no-redef]
+
 from .manager import BuildManager
 from .utils import find_project_root, find_source_directory
 
 
+def resolve_version_via_semantic_release(
+    project_root: Path,
+    subfolder_path: Path | None = None,
+    package_name: str | None = None,
+    repository: str | None = None,
+    repository_url: str | None = None,
+) -> str | None:
+    """
+    Resolve the next version using semantic-release via Node.js script.
+
+    Args:
+        project_root: Root directory of the project
+        subfolder_path: Optional path to subfolder (relative to project_root) for Workflow 1
+        package_name: Optional package name for subfolder builds
+        repository: Optional target repository ('pypi', 'testpypi', or 'azure')
+        repository_url: Optional repository URL (required for Azure Artifacts)
+
+    Returns:
+        Version string if a release is determined, None if no release or error
+    """
+    # Try to find the script in multiple locations:
+    # 1. Project root / scripts (for development or when script is in repo)
+    # 2. Package installation directory / scripts (for installed package)
+    #    - For normal installs: direct file path
+    #    - For zip/pex installs: extract to temporary file using as_file()
+
+    # Track temporary file context for cleanup
+    temp_script_context = None
+
+    try:
+        # First, try project root (development)
+        dev_script = project_root / "scripts" / "get-next-version.cjs"
+        if dev_script.exists():
+            script_path = dev_script
+        else:
+            # Try to locate script in installed package using importlib.resources
+            script_path = None
+            try:
+                package = resources.files("python_package_folder")
+                script_resource = package / "scripts" / "get-next-version.cjs"
+                if script_resource.is_file():
+                    # Try direct path conversion first (normal file system install)
+                    try:
+                        script_path_candidate = Path(str(script_resource))
+                        if script_path_candidate.exists():
+                            script_path = script_path_candidate
+                    except (TypeError, ValueError):
+                        pass
+
+                    # If direct path didn't work, try as_file() for zip/pex installs
+                    if script_path is None:
+                        try:
+                            temp_script_context = resources.as_file(script_resource)
+                            script_path = temp_script_context.__enter__()
+                        except (TypeError, ValueError, OSError):
+                            pass
+            except (ImportError, ModuleNotFoundError, TypeError, AttributeError, OSError):
+                pass
+
+            # Fallback: try relative to package directory
+            if script_path is None:
+                package_dir = Path(__file__).parent
+                fallback_script = package_dir / "scripts" / "get-next-version.cjs"
+                if fallback_script.exists():
+                    script_path = fallback_script
+
+        if not script_path:
+            return None
+
+        # Build command arguments
+        cmd = ["node", str(script_path), str(project_root)]
+        if subfolder_path and package_name:
+            # Workflow 1: subfolder build
+            rel_path = (
+                subfolder_path.relative_to(project_root)
+                if subfolder_path.is_absolute()
+                else subfolder_path
+            )
+            cmd.extend([str(rel_path), package_name])
+        elif package_name:
+            # Main package build with package_name (for registry queries)
+            # Pass null for subfolder_path, then package_name
+            cmd.extend(["", package_name])
+        # Workflow 2: main package without package_name (no additional args needed)
+        
+        # Add repository information if provided
+        if repository:
+            cmd.append(repository)
+            if repository_url:
+                cmd.append(repository_url)
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            cwd=project_root,
+            check=False,
+        )
+
+        if result.returncode != 0:
+            # Log error details for debugging
+            if result.stderr:
+                print(
+                    f"Warning: semantic-release version resolution failed: {result.stderr}",
+                    file=sys.stderr,
+                )
+            elif result.stdout:
+                print(
+                    f"Warning: semantic-release version resolution failed: {result.stdout}",
+                    file=sys.stderr,
+                )
+            return None
+
+        version = result.stdout.strip()
+        if version and version != "none":
+            return version
+
+        return None
+    except FileNotFoundError:
+        # Node.js not found
+        print(
+            "Warning: Node.js not found. Cannot resolve version via semantic-release.",
+            file=sys.stderr,
+        )
+        return None
+    except Exception as e:
+        # Other errors (e.g., permission issues, script not found)
+        print(
+            f"Warning: Error resolving version via semantic-release: {e}",
+            file=sys.stderr,
+        )
+        return None
+    finally:
+        # Clean up temporary file if we extracted from zip/pex
+        # This must be at function level to ensure cleanup even on early return
+        if temp_script_context is not None:
+            try:
+                temp_script_context.__exit__(None, None, None)
+            except Exception:
+                pass
+
+
 def main() -> int:
     """
     Main entry point for the build script.
@@ -77,7 +224,7 @@ def main() -> int:
     )
     parser.add_argument(
         "--version",
-        help="Set a specific version before building (PEP 440 format, e.g., '1.2.3'). Required for subfolder builds.",
+        help="Set a specific version before building (PEP 440 format, e.g., '1.2.3'). Optional: if omitted, version will be resolved via semantic-release when needed.",
     )
     parser.add_argument(
         "--package-name",
@@ -151,18 +298,81 @@ def main() -> int:
                 sys.exit(result.returncode)
 
         # Check if building a subfolder (not the main src/)
-        is_subfolder = not src_dir.is_relative_to(project_root / "src") or (
-            src_dir != project_root / "src" and src_dir != project_root
+        # A subfolder must be within the project root but not the main src/ directory
+        is_subfolder = (
+            src_dir.is_relative_to(project_root)
+            and src_dir != project_root / "src"
+            and src_dir != project_root
         )
 
-        # For subfolder builds, version is required
-        if is_subfolder and not args.version and (not args.analyze_only):
-            print(
-                "Error: --version is required when building from a subfolder.\n"
-                "Subfolders must be built as separate packages with their own version.",
-                file=sys.stderr,
-            )
-            return 1
+        # Resolve version via semantic-release if not provided and needed
+        resolved_version = args.version
+        if not resolved_version and not args.analyze_only:
+            # Version is needed for subfolder builds or when publishing main package
+            if is_subfolder or args.publish:
+                print("No --version provided, attempting to resolve via semantic-release...")
+                # Get repository info if publishing
+                repository = args.publish if args.publish else None
+                repository_url = args.repository_url if args.publish else None
+                
+                if is_subfolder:
+                    # Workflow 1: subfolder build
+                    # src_dir is guaranteed to be relative to project_root due to is_subfolder check
+                    package_name = args.package_name or src_dir.name.replace("_", "-").replace(
+                        " ", "-"
+                    ).lower().strip("-")
+                    subfolder_rel_path = src_dir.relative_to(project_root)
+                    resolved_version = resolve_version_via_semantic_release(
+                        project_root,
+                        subfolder_rel_path,
+                        package_name,
+                        repository=repository,
+                        repository_url=repository_url,
+                    )
+                else:
+                    # Workflow 2: main package
+                    # For main package, we need package_name from pyproject.toml for registry queries
+                    package_name_for_registry = None
+                    if repository:
+                        try:
+                            import tomllib
+                            pyproject_path = project_root / "pyproject.toml"
+                            if pyproject_path.exists():
+                                with open(pyproject_path, "rb") as f:
+                                    data = tomllib.load(f)
+                                    package_name_for_registry = data.get("project", {}).get("name")
+                        except Exception:
+                            pass
+                    
+                    resolved_version = resolve_version_via_semantic_release(
+                        project_root,
+                        subfolder_path=None,
+                        package_name=package_name_for_registry,
+                        repository=repository,
+                        repository_url=repository_url,
+                    )
+
+                if resolved_version:
+                    print(f"Resolved version via semantic-release: {resolved_version}")
+                else:
+                    error_msg = (
+                        "Could not resolve version via semantic-release.\n"
+                        "This could mean:\n"
+                        "  - No release is needed (no relevant commits)\n"
+                        "  - semantic-release is not installed or configured\n"
+                        "  - Node.js is not available\n\n"
+                        "Please either:\n"
+                        "  - Install semantic-release: npm install -g semantic-release"
+                    )
+                    if is_subfolder:
+                        error_msg += "\n  - Install semantic-release-commit-filter: npm install -g semantic-release-commit-filter"
+                    error_msg += "\n  - Or provide --version explicitly"
+                    print(f"Error: {error_msg}", file=sys.stderr)
+                    return 1
+
+        # Use resolved version for the rest of the flow
+        if resolved_version:
+            args.version = resolved_version
 
         if args.publish:
             manager.build_and_publish(

{python_package_folder-3.1.3.dist-info → python_package_folder-4.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-package-folder
-Version: 3.1.3
+Version: 4.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>
@@ -75,6 +75,9 @@ cd src/api_package
 # Build and publish to TestPyPI with version 1.2.0
 python-package-folder --publish testpypi --version 1.2.0
 
+# Or publish to PyPI with automatic version resolution via semantic-release
+python-package-folder --publish pypi
+
 # Or publish to PyPI with a custom package name
 python-package-folder --publish pypi --version 1.2.0 --package-name "my-api-package"
 
@@ -169,6 +172,13 @@ uv add twine
 
 **For secure credential storage**: `keyring` is optional but recommended (install with `pip install keyring`)
 
+**For automatic version resolution**: When using `--version` optional mode (automatic version resolution via semantic-release), you'll need:
+- Node.js and npm (or npx)
+- semantic-release: `npm install -g semantic-release`
+- For subfolder builds: semantic-release-commit-filter: `npm install -g semantic-release-commit-filter`
+
+Alternatively, install these as devDependencies in your project's `package.json`.
+
 
 ## Quick Start
 
@@ -182,9 +192,13 @@ Useful for monorepos containing many subfolders that may need publishing as stan
 # First cd to the specific subfolder
 cd src/subfolder_to_build_and_publish
 
-# Build and publish any subdirectory of your repo to TestPyPi (https://test.pypi.org/) 
+# Build and publish any subdirectory of your repo to TestPyPi (https://test.pypi.org/)
+# Version can be provided explicitly or resolved automatically via semantic-release
 python-package-folder --publish testpypi --version 0.0.2
 
+# Or let semantic-release determine the next version automatically (requires semantic-release setup)
+python-package-folder --publish testpypi
+
 # Only analyse (no building)
 cd src/subfolder_to_build_and_publish
 python-package-folder --analyze-only
@@ -457,33 +471,89 @@ The `--version` option:
 **Version Format**: Versions must follow PEP 440 (e.g., `1.2.3`, `1.2.3a1`, `1.2.3.post1`, `1.2.3.dev1`)
 
 
+### Automatic Version Resolution (semantic-release)
+
+When `--version` is not provided, the tool can automatically determine the next version using semantic-release. This requires Node.js, npm, and semantic-release to be installed.
+
+**Version Detection:**
+- **Baseline version**:
+  - **Registry Query (Preferred)**: When publishing to a repository (PyPI, TestPyPI, or Azure Artifacts), the tool queries the target registry for the latest published version and uses it as the baseline for version calculation. This ensures version calculations are based on what's actually published, not just git tags.
+  - **Git Tags (Fallback)**: If the package doesn't exist on the registry yet (first release) or if registry query fails, the tool falls back to using git tags to determine the starting version.
+- **New version to publish**: After determining the baseline version, [`semantic-release`](https://semantic-release.gitbook.io/semantic-release/) analyzes commits since that version to calculate the next version bump (major, minor, or patch) based on [_conventional commit_](https://www.conventionalcommits.org/en/v1.0.0/) messages.
+
+**For subfolder builds (Workflow 1):**
+- Uses per-package tags: `{package-name}-v{version}` (e.g., `my-package-v1.2.3`)
+- Queries the target registry for the latest published version of the subfolder package
+- Filters commits to only those affecting the subfolder path
+- **Commit filtering behavior**: Only commits that modify files within the subfolder path are considered for version calculation. Commits that only target files outside the subfolder are excluded. For example:
+  - `fix: update my_subfolder/foo.py` → **Included** (affects subfolder)
+  - `feat: add feature to other_package/bar.py` → **Excluded** (doesn't affect subfolder)
+  - `fix: update my_subfolder/baz.py and shared/utils.py` → **Included** (affects subfolder, even if it also touches files outside)
+- Requires `semantic-release-commit-filter` plugin
+
+**For main package builds (Workflow 2):**
+- Uses repo-level tags: `v{version}` (e.g., `v1.2.3`)
+- Queries the target registry for the latest published version when publishing
+- Analyzes all commits in the repository
+
+**Registry Support:**
+- **PyPI**: Fully supported via JSON API (`https://pypi.org/pypi/{package-name}/json`)
+- **TestPyPI**: Fully supported via JSON API (`https://test.pypi.org/pypi/{package-name}/json`)
+- **Azure Artifacts**: Basic support with fallback to git tags. Azure Artifacts uses a different API format and may require authentication, so if the query fails, the tool automatically falls back to git tags.
+
+**Setup:**
+```bash
+# Install semantic-release globally
+npm install -g semantic-release
+
+# For subfolder builds, also install semantic-release-commit-filter
+npm install -g semantic-release-commit-filter
+```
+
+**Usage:**
+```bash
+# Subfolder build - version resolved automatically
+cd src/my_subfolder
+python-package-folder --publish pypi
+
+# Main package - version resolved automatically
+python-package-folder --publish pypi
+```
+
+**Requirements:**
+- Conventional commits (e.g., `fix:`, `feat:`, `BREAKING CHANGE:`) are required for semantic-release to determine version bumps
+- The tool will fall back to requiring `--version` explicitly if semantic-release is not available or determines no release is needed
+
 ### Subfolder Versioning
 
 When building from a subdirectory (not the main `src/` directory), the tool automatically detects the subfolder and sets up the build configuration:
 
 ```bash
-# Build a subfolder as a separate package (version recommended but not required)
+# Build a subfolder as a separate package with explicit version
 cd my_project/subfolder_to_build
 python-package-folder --version "1.0.0" --publish pypi
 
+# Or let semantic-release determine the version automatically
+python-package-folder --publish pypi
+
 # With custom package name
 python-package-folder --version "1.0.0" --package-name "my-custom-name" --publish pypi
-
-# Version defaults to "0.0.0" if not specified (with a warning)
-python-package-folder --publish pypi
 ```
 
 For subfolder builds:
 - **Automatic detection**: The tool automatically detects subfolder builds
+- **Version resolution**: 
+  - If `--version` is provided: Uses the explicit version
+  - If `--version` is omitted: Attempts to resolve via semantic-release (requires setup)
+  - If semantic-release is unavailable or determines no release: Requires `--version` explicitly
 - **pyproject.toml handling**:
   - If `pyproject.toml` exists in subfolder: Uses that file (copied to project root temporarily)
   - If no `pyproject.toml` in subfolder: Creates temporary one with correct package structure
-- **Version**: Recommended but not required when creating temporary pyproject.toml. If not provided, defaults to `0.0.0` with a warning. Ignored if subfolder has its own `pyproject.toml`.
 - **Package name**: Automatically derived from the subfolder name (e.g., `subfolder_to_build` → `subfolder-to-build`). Only used when creating temporary pyproject.toml.
 - **Restoration**: Original `pyproject.toml` is restored after build
 - **Temporary configuration**: Creates a temporary `pyproject.toml` with:
   - Custom package name (from `--package-name` or derived)
-  - Specified version
+  - Specified or resolved version
   - Correct package path for hatchling
   - Dependency group from parent (if `--dependency-group` is specified)
 - **Package initialization**: Automatically creates `__init__.py` if the subfolder doesn't have one (required for hatchling)
@@ -686,7 +756,8 @@ options:
   --password PASSWORD   Password/token for publishing (will prompt if not provided)
   --skip-existing       Skip files that already exist on the repository
   --version VERSION     Set a specific version before building (PEP 440 format).
-                        Required for subfolder builds.
+                        Optional: if omitted, version will be resolved via
+                        semantic-release (requires Node.js and semantic-release setup).
   --package-name PACKAGE_NAME
                         Package name for subfolder builds (default: derived from
                         source directory name)

{python_package_folder-3.1.3.dist-info → python_package_folder-4.1.0.dist-info}/RECORD

@@ -1,17 +1,18 @@
 python_package_folder/__init__.py,sha256=DQt-uldOEKfh0MUqCvKdeNKOnpuOvpb7blYvXMyO9Wc,719
 python_package_folder/__main__.py,sha256=a-__-VLhYw-J7S7CsHdhtEvQr3RiAZxiYDvKhKTgMX4,291
+python_package_folder/_hatch_build.py,sha256=HNuhBz5e6uoDNVPKHFcX-8H23u6qyXNM8KO9DgRGXMM,1844
 python_package_folder/analyzer.py,sha256=cmTNUDCWBIh3XZ_mShlQVG1P9NN_oe3FUBTirVtYfTQ,16709
 python_package_folder/finder.py,sha256=RPidZ7LKCFuQ_KgCFIZdHWPXsZIDor3M4C0hKeYW7EI,11799
 python_package_folder/manager.py,sha256=Z9RPg0ZQ7jZhmEXfCzX9OrD_oiA5p2Pnm5Y9tgW3ObQ,55970
 python_package_folder/publisher.py,sha256=TSjdOvxvnWLbJCnduTK_xZBRfvsrq9kpEH-sfebeWkU,13507
 python_package_folder/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_package_folder/python_package_folder.py,sha256=RPsqRcIy_LjzzTHdp4qdtFJ4-4xhtR_0YLIC0RlUxFo,8841
+python_package_folder/python_package_folder.py,sha256=xSMUD_uiCOVHDDT4WNso9AxAYNyqhKI103G2rJztaXw,17907
 python_package_folder/subfolder_build.py,sha256=oH_KKLJIMByUZCl8y3AyohUO6Om0OvsIQ7Xg1fkd3jE,38782
 python_package_folder/types.py,sha256=3yeSRR5p_3PDKEAaehW_RJ7NwJHexOIeA08bGaT1iSY,2368
 python_package_folder/utils.py,sha256=lIkWsFKeAYAJ9TDUM99T4pUBHJVbUvCdUgkWQN-LUho,3111
 python_package_folder/version.py,sha256=kIDP6S9trEfs9gj7lBYGxrWm4RPssRla24UtlO9Jkh4,9111
-python_package_folder-3.1.3.dist-info/METADATA,sha256=dkCtq6nLmfiygTwYXzgVomMejX4AfQTM1U3LYdev8zQ,33282
-python_package_folder-3.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-python_package_folder-3.1.3.dist-info/entry_points.txt,sha256=ttu4wAhoYSHGhWQNercLz9IVTTpXxhVlRA9vSTvaLe0,91
-python_package_folder-3.1.3.dist-info/licenses/LICENSE,sha256=vNgRJh8YiecqZoZld7TtwPI5I72HIymKD9g32fiJjCE,1073
-python_package_folder-3.1.3.dist-info/RECORD,,
+python_package_folder-4.1.0.dist-info/METADATA,sha256=yk49H6KBuadlyqKiHeC589X6pBvUTBVd4YXs6idsnYE,37517
+python_package_folder-4.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_package_folder-4.1.0.dist-info/entry_points.txt,sha256=ttu4wAhoYSHGhWQNercLz9IVTTpXxhVlRA9vSTvaLe0,91
+python_package_folder-4.1.0.dist-info/licenses/LICENSE,sha256=vNgRJh8YiecqZoZld7TtwPI5I72HIymKD9g32fiJjCE,1073
+python_package_folder-4.1.0.dist-info/RECORD,,

{python_package_folder-3.1.3.dist-info → python_package_folder-4.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: hatchling 1.29.0
 Root-Is-Purelib: true
 Tag: py3-none-any