pymelos 0.1.3__py3-none-any.whl

pymelos/commands/release.py

@@ -0,0 +1,258 @@
+"""Release command implementation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from pymelos.commands.base import Command, CommandContext
+from pymelos.versioning import (
+    BumpType,
+    Version,
+    determine_bump,
+    generate_changelog_entry,
+    parse_commit,
+    prepend_to_changelog,
+    update_all_versions,
+)
+
+if TYPE_CHECKING:
+    from pymelos.workspace import Package
+    from pymelos.workspace.workspace import Workspace
+
+
+@dataclass
+class PackageRelease:
+    """Information about a package release."""
+
+    name: str
+    old_version: str
+    new_version: str
+    bump_type: BumpType
+    changelog_entry: str
+    commits: list[str]
+    tag: str
+    published: bool = False
+
+
+@dataclass
+class ReleaseResult:
+    """Result of release command."""
+
+    releases: list[PackageRelease]
+    commit_sha: str | None = None
+    success: bool = True
+    error: str | None = None
+
+
+@dataclass
+class ReleaseOptions:
+    """Options for release command."""
+
+    scope: str | None = None
+    since: str | None = None
+    bump: BumpType | None = None  # Override auto-detection
+    prerelease: str | None = None  # e.g., "alpha", "beta"
+    dry_run: bool = False
+    publish: bool = False
+    no_git_tag: bool = False
+    no_changelog: bool = False
+    no_commit: bool = False
+
+
+class ReleaseCommand(Command[ReleaseResult]):
+    """Release packages with semantic versioning.
+
+    This command:
+    1. Determines which packages need release
+    2. Parses commits to determine bump type
+    3. Updates versions in pyproject.toml
+    4. Generates changelog entries
+    5. Creates git commit and tags
+    6. Optionally publishes to PyPI
+    """
+
+    def __init__(self, context: CommandContext, options: ReleaseOptions | None = None) -> None:
+        super().__init__(context)
+        self.options = options or ReleaseOptions()
+
+    @property
+    def is_dry_run(self) -> bool:
+        """Check if this is a dry run."""
+        return self.options.dry_run or self.context.dry_run
+
+    def get_packages_to_release(self) -> list[Package]:
+        """Get packages that need release (scope-filtered only)."""
+        from pymelos.filters import filter_by_scope
+
+        return filter_by_scope(list(self.workspace.packages.values()), self.options.scope)
+
+    def _prepare_package_release(self, pkg: Package) -> PackageRelease | None:
+        """Prepare release info for a single package. Returns None if package should be skipped."""
+        from pymelos.git import get_commits, get_latest_package_tag
+
+        last_tag = get_latest_package_tag(self.workspace.root, pkg.name)
+        since_ref = last_tag.name if last_tag else None
+
+        commits = get_commits(self.workspace.root, since=since_ref, path=pkg.path)
+
+        # Skip unchanged packages
+        if not commits:
+            return None
+
+        # Skip packages with only initial commit unless explicitly scoped
+        if not last_tag and len(commits) <= 1 and not self.options.scope:
+            return None
+
+        # Parse and filter conventional commits
+        parsed = [p for c in commits if (p := parse_commit(c)) is not None]
+
+        if not parsed and not self.options.bump:
+            return None
+
+        bump = self.options.bump or determine_bump(parsed)
+        if bump == BumpType.NONE:
+            return None
+
+        old_version = Version.parse(pkg.version)
+        new_version = old_version.bump(bump, self.options.prerelease)
+        tag_format = self.workspace.config.versioning.tag_format
+
+        changelog = generate_changelog_entry(str(new_version), parsed, package_name=pkg.name)
+
+        return PackageRelease(
+            name=pkg.name,
+            old_version=str(old_version),
+            new_version=str(new_version),
+            bump_type=bump,
+            changelog_entry=changelog,
+            commits=[c.sha[:7] for c in commits],
+            tag=tag_format.format(name=pkg.name, version=str(new_version)),
+        )
+
+    def _apply_release_changes(self, release: PackageRelease) -> None:
+        """Apply version and changelog changes for a release."""
+        pkg = self.workspace.get_package(release.name)
+        update_all_versions(pkg.path, pkg.name, release.new_version)
+
+        if not self.options.no_changelog:
+            prepend_to_changelog(pkg.path / "CHANGELOG.md", release.changelog_entry)
+
+    def _create_git_commit(self, releases: list[PackageRelease]) -> str | None:
+        """Create git commit for releases. Returns commit SHA."""
+        from pymelos.git import run_git_command
+
+        if self.options.no_commit:
+            return None
+
+        run_git_command(["add", "-A"], cwd=self.workspace.root)
+
+        pkg_versions = ", ".join(f"{r.name}@{r.new_version}" for r in releases)
+        commit_msg = self.workspace.config.versioning.commit_message.format(packages=pkg_versions)
+
+        run_git_command(["commit", "-m", commit_msg], cwd=self.workspace.root)
+        result = run_git_command(["rev-parse", "HEAD"], cwd=self.workspace.root)
+        return result.stdout.strip()
+
+    def _create_git_tags(self, releases: list[PackageRelease]) -> None:
+        """Create git tags for releases."""
+        from pymelos.git import create_tag
+
+        if self.options.no_git_tag:
+            return
+
+        for release in releases:
+            create_tag(
+                self.workspace.root,
+                release.tag,
+                message=f"Release {release.name}@{release.new_version}",
+            )
+
+    def _publish_releases(self, releases: list[PackageRelease]) -> str | None:
+        """Publish releases to PyPI. Returns error message on failure."""
+        from pymelos.uv import build_and_publish
+
+        if not self.options.publish:
+            return None
+
+        for release in releases:
+            pkg = self.workspace.get_package(release.name)
+            try:
+                build_and_publish(pkg.path, repository=self.workspace.config.publish.registry)
+                release.published = True
+            except Exception as e:
+                return str(e)
+        return None
+
+    async def execute(self) -> ReleaseResult:
+        """Execute the release command."""
+        packages = self.get_packages_to_release()
+        if not packages:
+            return ReleaseResult(releases=[], success=True)
+
+        # Prepare releases (filter out packages that shouldn't be released)
+        releases = [r for pkg in packages if (r := self._prepare_package_release(pkg)) is not None]
+
+        if not releases:
+            return ReleaseResult(releases=[], success=True)
+
+        # Apply changes if not dry run
+        if not self.is_dry_run:
+            for release in releases:
+                self._apply_release_changes(release)
+
+            commit_sha = self._create_git_commit(releases)
+            self._create_git_tags(releases)
+
+            if error := self._publish_releases(releases):
+                return ReleaseResult(
+                    releases=releases, commit_sha=commit_sha, success=False, error=error
+                )
+
+            return ReleaseResult(releases=releases, commit_sha=commit_sha, success=True)
+
+        return ReleaseResult(releases=releases, success=True)
+
+
+async def release(
+    workspace: Workspace,
+    *,
+    scope: str | None = None,
+    bump: BumpType | None = None,
+    prerelease: str | None = None,
+    dry_run: bool = False,
+    publish: bool = False,
+    no_git_tag: bool = False,
+    no_changelog: bool = False,
+    no_commit: bool = False,
+) -> ReleaseResult:
+    """Convenience function to release packages.
+
+    Args:
+        workspace: Workspace to release.
+        scope: Package scope filter.
+        bump: Override bump type.
+        prerelease: Prerelease tag.
+        dry_run: Show what would happen.
+        publish: Publish to PyPI.
+        no_git_tag: Skip creating git tags.
+        no_changelog: Skip changelog generation.
+        no_commit: Skip git commit.
+
+    Returns:
+        Release result.
+    """
+
+    context = CommandContext(workspace=workspace, dry_run=dry_run)
+    options = ReleaseOptions(
+        scope=scope,
+        bump=bump,
+        prerelease=prerelease,
+        dry_run=dry_run,
+        publish=publish,
+        no_git_tag=no_git_tag,
+        no_changelog=no_changelog,
+        no_commit=no_commit,
+    )
+    cmd = ReleaseCommand(context, options)
+    return await cmd.execute()

pymelos/commands/run.py

@@ -0,0 +1,160 @@
+"""Run command implementation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from pymelos.commands.base import Command, CommandContext
+from pymelos.errors import ScriptNotFoundError
+from pymelos.execution import BatchResult, ParallelExecutor
+
+if TYPE_CHECKING:
+    from pymelos.workspace import Package
+    from pymelos.workspace.workspace import Workspace
+
+
+@dataclass
+class RunOptions:
+    """Options for run command."""
+
+    script_name: str
+    scope: str | None = None
+    since: str | None = None
+    ignore: list[str] | None = None
+    concurrency: int = 4
+    fail_fast: bool = False
+    topological: bool = True
+    include_dependents: bool = False
+
+
+class RunCommand(Command[BatchResult]):
+    """Run a defined script across packages.
+
+    Scripts are defined in pymelos.yaml and can be filtered
+    by scope, git changes, or ignored patterns.
+    """
+
+    def __init__(self, context: CommandContext, options: RunOptions) -> None:
+        super().__init__(context)
+        self.options = options
+
+    def validate(self) -> list[str]:
+        """Validate the command."""
+        errors = super().validate()
+
+        script = self.workspace.config.get_script(self.options.script_name)
+        if not script:
+            errors.append(
+                f"Script '{self.options.script_name}' not found. "
+                f"Available: {', '.join(self.workspace.config.script_names)}"
+            )
+
+        return errors
+
+    def get_packages(self) -> list[Package]:
+        """Get packages to run script in."""
+        from pymelos.filters import apply_filters_with_since
+
+        packages = list(self.workspace.packages.values())
+
+        # Get script-specific scope if defined
+        script = self.workspace.config.get_script(self.options.script_name)
+        scope = self.options.scope
+        if not scope and script and script.scope:
+            scope = script.scope
+
+        return apply_filters_with_since(
+            packages,
+            self.workspace,
+            scope=scope,
+            since=self.options.since,
+            ignore=self.options.ignore,
+            include_dependents=self.options.include_dependents,
+        )
+
+    async def execute(self) -> BatchResult:
+        """Execute the script."""
+        # Validate first
+        errors = self.validate()
+        if errors:
+            raise ScriptNotFoundError(
+                self.options.script_name,
+                self.workspace.config.script_names,
+            )
+
+        script = self.workspace.config.get_script(self.options.script_name)
+        assert script is not None  # validate() already checked
+
+        # Get matching packages
+        packages = self.get_packages()
+        if not packages:
+            return BatchResult(results=[])
+
+        # Build environment
+        env = dict(self.context.env)
+        env.update(self.workspace.config.env)
+        env.update(script.env)
+
+        # Get execution settings
+        concurrency = self.options.concurrency
+        fail_fast = self.options.fail_fast or script.fail_fast
+        topological = self.options.topological and script.topological
+
+        executor = ParallelExecutor(
+            concurrency=concurrency,
+            fail_fast=fail_fast,
+        )
+
+        if topological:
+            # Execute in dependency order
+            batches = self.workspace.parallel_batches(packages)
+            return await executor.execute_batches(batches, script.run, env=env)
+        else:
+            # Execute all in parallel
+            return await executor.execute(
+                packages,
+                script.run,
+                env=env,
+            )
+
+
+async def run_script(
+    workspace: Workspace,
+    script_name: str,
+    *,
+    scope: str | None = None,
+    since: str | None = None,
+    ignore: list[str] | None = None,
+    concurrency: int = 4,
+    fail_fast: bool = False,
+    topological: bool = True,
+) -> BatchResult:
+    """Convenience function to run a script.
+
+    Args:
+        workspace: Workspace to run in.
+        script_name: Name of script to run.
+        scope: Package scope filter.
+        since: Git reference for change detection.
+        ignore: Patterns to exclude.
+        concurrency: Parallel jobs.
+        fail_fast: Stop on first failure.
+        topological: Respect dependency order.
+
+    Returns:
+        Batch result with all execution results.
+    """
+
+    context = CommandContext(workspace=workspace)
+    options = RunOptions(
+        script_name=script_name,
+        scope=scope,
+        since=since,
+        ignore=ignore,
+        concurrency=concurrency,
+        fail_fast=fail_fast,
+        topological=topological,
+    )
+    cmd = RunCommand(context, options)
+    return await cmd.execute()

pymelos/compat.py

@@ -0,0 +1,14 @@
+"""Compatibility layer for Python version differences."""
+
+from __future__ import annotations
+
+import sys
+
+# tomllib is only available in Python 3.11+
+# Use tomli for Python 3.10
+if sys.version_info >= (3, 11):
+    import tomllib  # type: ignore[import-not-found]
+else:
+    import tomli as tomllib  # type: ignore[import-not-found]
+
+__all__ = ["tomllib"]

pymelos/config/__init__.py

@@ -0,0 +1,47 @@
+"""Configuration loading and validation."""
+
+from pymelos.config.loader import (
+    CONFIG_FILENAME,
+    find_config_file,
+    get_workspace_root,
+    load_config,
+    load_yaml,
+)
+from pymelos.config.schema import (
+    BootstrapConfig,
+    BootstrapHook,
+    ChangelogConfig,
+    ChangelogSection,
+    CleanConfig,
+    CommandDefaults,
+    CommitFormat,
+    IDEConfig,
+    PublishConfig,
+    PyMelosConfig,
+    ScriptConfig,
+    VersioningConfig,
+    VSCodeConfig,
+)
+
+__all__ = [
+    # Loader
+    "CONFIG_FILENAME",
+    "find_config_file",
+    "get_workspace_root",
+    "load_config",
+    "load_yaml",
+    # Schema
+    "BootstrapConfig",
+    "BootstrapHook",
+    "ChangelogConfig",
+    "ChangelogSection",
+    "CleanConfig",
+    "CommandDefaults",
+    "CommitFormat",
+    "IDEConfig",
+    "PublishConfig",
+    "PyMelosConfig",
+    "ScriptConfig",
+    "VersioningConfig",
+    "VSCodeConfig",
+]

pymelos/config/loader.py

@@ -0,0 +1,132 @@
+"""Configuration file loading and discovery."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import ValidationError as PydanticValidationError
+
+from pymelos.config.schema import PyMelosConfig
+from pymelos.errors import ConfigurationError, WorkspaceNotFoundError
+
+CONFIG_FILENAME = "pymelos.yaml"
+ALT_CONFIG_FILENAME = "pymelos.yml"
+CONFIG_FILENAMES = (CONFIG_FILENAME, ALT_CONFIG_FILENAME)
+
+
+def find_config_file(start_path: Path | None = None) -> Path:
+    """Find pymelos.yaml by walking up from start_path.
+
+    Args:
+        start_path: Directory to start searching from. Defaults to cwd.
+
+    Returns:
+        Path to the pymelos.yaml file.
+
+    Raises:
+        WorkspaceNotFoundError: If no config file is found.
+    """
+    if start_path is None:
+        start_path = Path.cwd()
+    start_path = start_path.resolve()
+
+    current = start_path
+    while True:
+        # Check for both .yaml and .yml extensions
+        for filename in CONFIG_FILENAMES:
+            config_path = current / filename
+            if config_path.is_file():
+                return config_path
+
+        # Move to parent directory
+        parent = current.parent
+        if parent == current:
+            # Reached filesystem root
+            raise WorkspaceNotFoundError(start_path)
+        current = parent
+
+
+def load_yaml(path: Path) -> dict[str, Any]:
+    """Load and parse a YAML file.
+
+    Args:
+        path: Path to the YAML file.
+
+    Returns:
+        Parsed YAML content as a dictionary.
+
+    Raises:
+        ConfigurationError: If the file cannot be read or parsed.
+    """
+    try:
+        with open(path, encoding="utf-8") as f:
+            content = yaml.safe_load(f)
+            if content is None:
+                return {}
+            if not isinstance(content, dict):
+                raise ConfigurationError(
+                    "Configuration must be a YAML mapping (dictionary)",
+                    path=path,
+                )
+            return content
+    except yaml.YAMLError as e:
+        raise ConfigurationError(f"Invalid YAML syntax: {e}", path=path) from e
+    except OSError as e:
+        raise ConfigurationError(f"Cannot read file: {e}", path=path) from e
+
+
+def load_config(
+    path: Path | None = None,
+    *,
+    start_path: Path | None = None,
+) -> tuple[PyMelosConfig, Path]:
+    """Load and validate pymelos configuration.
+
+    Args:
+        path: Explicit path to config file. If provided, start_path is ignored.
+        start_path: Directory to search for config file. Defaults to cwd.
+
+    Returns:
+        Tuple of (validated config, path to config file).
+
+    Raises:
+        WorkspaceNotFoundError: If no config file is found.
+        ConfigurationError: If the config file is invalid.
+    """
+    if path is None:
+        path = find_config_file(start_path)
+    else:
+        path = path.resolve()
+        if not path.is_file():
+            raise ConfigurationError(f"Config file not found: {path}")
+
+    raw_config = load_yaml(path)
+
+    try:
+        config = PyMelosConfig(**raw_config)
+    except PydanticValidationError as e:
+        errors = []
+        for error in e.errors():
+            loc = ".".join(str(x) for x in error["loc"])
+            msg = error["msg"]
+            errors.append(f"  {loc}: {msg}")
+        raise ConfigurationError(
+            "Invalid configuration:\n" + "\n".join(errors),
+            path=path,
+        ) from e
+
+    return config, path
+
+
+def get_workspace_root(config_path: Path) -> Path:
+    """Get the workspace root directory from config file path.
+
+    Args:
+        config_path: Path to the pymelos.yaml file.
+
+    Returns:
+        Path to the workspace root directory.
+    """
+    return config_path.parent.resolve()