pymelos 0.1.3__py3-none-any.whl

pymelos/config/schema.py

@@ -0,0 +1,236 @@
+"""Pydantic models for pymelos.yaml configuration."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Annotated, Any
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+
+class CommitFormat(str, Enum):
+    """Supported commit message formats."""
+
+    CONVENTIONAL = "conventional"
+    ANGULAR = "angular"
+
+
+class ScriptConfig(BaseModel):
+    """Configuration for a script command."""
+
+    run: str = Field(..., description="Command to execute")
+    description: str | None = Field(default=None, description="Human-readable description")
+    env: dict[str, str] = Field(default_factory=dict, description="Environment variables")
+    scope: str | None = Field(default=None, description="Package scope filter")
+    fail_fast: bool = Field(default=False, description="Stop on first failure")
+    topological: bool = Field(default=True, description="Respect dependency order")
+    pre: list[str] = Field(default_factory=list, description="Commands to run before")
+    post: list[str] = Field(default_factory=list, description="Commands to run after")
+
+
+class BootstrapHook(BaseModel):
+    """Configuration for a bootstrap hook."""
+
+    name: str = Field(..., description="Hook name for display")
+    run: str = Field(..., description="Command to execute")
+    scope: str | None = Field(default=None, description="Package scope filter")
+    run_once: bool = Field(default=False, description="Run only at workspace root")
+
+
+class BootstrapConfig(BaseModel):
+    """Bootstrap command configuration."""
+
+    hooks: list[BootstrapHook] = Field(default_factory=list, description="Post-sync hooks")
+
+
+class CleanConfig(BaseModel):
+    """Clean command configuration."""
+
+    patterns: list[str] = Field(
+        default_factory=lambda: [
+            "__pycache__",
+            "*.pyc",
+            "*.pyo",
+            ".pytest_cache",
+            ".mypy_cache",
+            ".ruff_cache",
+            "*.egg-info",
+            "dist",
+            "build",
+            ".coverage",
+            "htmlcov",
+        ],
+        description="Glob patterns to clean",
+    )
+    protected: list[str] = Field(
+        default_factory=lambda: [".venv", "venv", ".git", "node_modules"],
+        description="Patterns to never clean",
+    )
+
+
+class ChangelogSection(BaseModel):
+    """Changelog section configuration."""
+
+    type: str = Field(..., description="Commit type (feat, fix, etc.)")
+    title: str = Field(..., description="Section title in changelog")
+    hidden: bool = Field(default=False, description="Hide from changelog")
+
+
+class ChangelogConfig(BaseModel):
+    """Changelog generation configuration."""
+
+    enabled: bool = Field(default=True, description="Generate changelogs")
+    filename: str = Field(default="CHANGELOG.md", description="Changelog filename")
+    sections: list[ChangelogSection] = Field(
+        default_factory=lambda: [
+            ChangelogSection(type="feat", title="Features"),
+            ChangelogSection(type="fix", title="Bug Fixes"),
+            ChangelogSection(type="perf", title="Performance"),
+            ChangelogSection(type="refactor", title="Refactoring"),
+            ChangelogSection(type="docs", title="Documentation", hidden=True),
+        ],
+        description="Changelog sections",
+    )
+
+
+class VersioningConfig(BaseModel):
+    """Version/release configuration."""
+
+    commit_format: CommitFormat = Field(
+        default=CommitFormat.CONVENTIONAL,
+        description="Commit message format",
+    )
+    changelog: ChangelogConfig = Field(
+        default_factory=ChangelogConfig,
+        description="Changelog configuration",
+    )
+    tag_format: str = Field(
+        default="{name}@{version}",
+        description="Git tag format (use {name} and {version})",
+    )
+    commit_message: str = Field(
+        default="chore(release): {packages}",
+        description="Release commit message",
+    )
+    pre_release_checks: list[str] = Field(
+        default_factory=list,
+        description="Commands to run before release",
+    )
+
+
+class PublishConfig(BaseModel):
+    """Publishing configuration."""
+
+    registry: str = Field(
+        default="https://upload.pypi.org/legacy/",
+        description="PyPI registry URL",
+    )
+    private: list[str] = Field(
+        default_factory=list,
+        description="Package patterns to never publish",
+    )
+
+
+class CommandDefaults(BaseModel):
+    """Default settings for commands."""
+
+    concurrency: Annotated[int, Field(ge=1, le=32)] = Field(
+        default=4,
+        description="Default parallel jobs",
+    )
+    fail_fast: bool = Field(default=False, description="Stop on first failure")
+    topological: bool = Field(default=True, description="Respect dependency order")
+
+
+class VSCodeConfig(BaseModel):
+    """VS Code specific settings."""
+
+    model_config = {"extra": "allow"}
+
+
+class IDEConfig(BaseModel):
+    """IDE integration configuration."""
+
+    vscode: VSCodeConfig = Field(default_factory=VSCodeConfig)
+
+
+class PyMelosConfig(BaseModel):
+    """Root configuration model for pymelos.yaml."""
+
+    name: str = Field(..., description="Workspace name")
+    packages: list[str] = Field(..., description="Package glob patterns (e.g., ['packages/*'])")
+    ignore: list[str] = Field(
+        default_factory=list,
+        description="Patterns to exclude from package discovery",
+    )
+    scripts: dict[str, ScriptConfig | str | dict[str, Any]] = Field(
+        default_factory=dict,
+        description="Scripts that can be run with 'pymelos run <name>'",
+    )
+    command_defaults: CommandDefaults = Field(
+        default_factory=CommandDefaults,
+        description="Default command settings",
+    )
+    bootstrap: BootstrapConfig = Field(
+        default_factory=BootstrapConfig,
+        description="Bootstrap configuration",
+    )
+    clean: CleanConfig = Field(
+        default_factory=CleanConfig,
+        description="Clean configuration",
+    )
+    versioning: VersioningConfig = Field(
+        default_factory=VersioningConfig,
+        description="Versioning/release configuration",
+    )
+    publish: PublishConfig = Field(
+        default_factory=PublishConfig,
+        description="Publishing configuration",
+    )
+    ide: IDEConfig = Field(
+        default_factory=IDEConfig,
+        description="IDE integration settings",
+    )
+    env: dict[str, str] = Field(
+        default_factory=dict,
+        description="Environment variables for all commands",
+    )
+
+    @field_validator("scripts", mode="before")
+    @classmethod
+    def normalize_scripts(cls, v: dict[str, Any]) -> dict[str, ScriptConfig]:
+        """Convert simple string scripts to ScriptConfig."""
+        if not isinstance(v, dict):
+            return v
+        result: dict[str, ScriptConfig] = {}
+        for name, config in v.items():
+            if isinstance(config, str):
+                result[name] = ScriptConfig(run=config)
+            elif isinstance(config, dict):
+                result[name] = ScriptConfig(**config)
+            else:
+                result[name] = config
+        return result
+
+    @model_validator(mode="after")
+    def validate_config(self) -> PyMelosConfig:
+        """Validate the complete configuration."""
+        if not self.packages:
+            raise ValueError("At least one package pattern is required")
+        return self
+
+    def get_script(self, name: str) -> ScriptConfig | None:
+        """Get a script configuration by name."""
+        script = self.scripts.get(name)
+        if script is None:
+            return None
+        if isinstance(script, str):
+            return ScriptConfig(run=script)
+        if isinstance(script, dict):
+            return ScriptConfig(**script)
+        return script
+
+    @property
+    def script_names(self) -> list[str]:
+        """Get all defined script names."""
+        return list(self.scripts.keys())

pymelos/errors.py

@@ -0,0 +1,139 @@
+"""Exception hierarchy for pymelos.
+
+All exceptions inherit from pymelosError to allow catching all pymelos-related
+errors with a single except clause.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+class PyMelosError(Exception):
+    """Base exception for all pymelos errors."""
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+        super().__init__(message)
+
+
+class ConfigurationError(PyMelosError):
+    """Error in pymelos.yaml configuration."""
+
+    def __init__(self, message: str, path: Path | None = None) -> None:
+        self.path = path
+        if path:
+            message = f"{path}: {message}"
+        super().__init__(message)
+
+
+class WorkspaceNotFoundError(PyMelosError):
+    """No pymelos.yaml found in directory tree."""
+
+    def __init__(self, search_path: Path) -> None:
+        self.search_path = search_path
+        super().__init__(
+            f"No pymelos.yaml found in {search_path} or any parent directory. "
+            "Run 'pymelos init' to create a workspace."
+        )
+
+
+class PackageNotFoundError(PyMelosError):
+    """Requested package does not exist in workspace."""
+
+    def __init__(self, name: str, available: list[str] | None = None) -> None:
+        self.name = name
+        self.available = available or []
+        message = f"Package '{name}' not found in workspace."
+        if self.available:
+            message += f" Available packages: {', '.join(sorted(self.available))}"
+        super().__init__(message)
+
+
+class CyclicDependencyError(PyMelosError):
+    """Circular dependency detected in package graph."""
+
+    def __init__(self, cycle: list[str]) -> None:
+        self.cycle = cycle
+        cycle_str = " -> ".join(cycle + [cycle[0]])
+        super().__init__(f"Cyclic dependency detected: {cycle_str}")
+
+
+class ScriptNotFoundError(PyMelosError):
+    """Requested script is not defined in pymelos.yaml."""
+
+    def __init__(self, name: str, available: list[str] | None = None) -> None:
+        self.name = name
+        self.available = available or []
+        message = f"Script '{name}' not defined in pymelos.yaml."
+        if self.available:
+            message += f" Available scripts: {', '.join(sorted(self.available))}"
+        super().__init__(message)
+
+
+class ExecutionError(PyMelosError):
+    """Error during command execution."""
+
+    def __init__(
+        self,
+        message: str,
+        package_name: str | None = None,
+        exit_code: int | None = None,
+        stderr: str | None = None,
+    ) -> None:
+        self.package_name = package_name
+        self.exit_code = exit_code
+        self.stderr = stderr
+        if package_name:
+            message = f"[{package_name}] {message}"
+        if exit_code is not None:
+            message += f" (exit code: {exit_code})"
+        super().__init__(message)
+
+
+class BootstrapError(PyMelosError):
+    """Error during workspace bootstrap."""
+
+    pass
+
+
+class GitError(PyMelosError):
+    """Error during git operations."""
+
+    def __init__(self, message: str, command: str | None = None) -> None:
+        self.command = command
+        if command:
+            message = f"Git command failed: {command}\n{message}"
+        super().__init__(message)
+
+
+class ReleaseError(PyMelosError):
+    """Error during release operations."""
+
+    def __init__(self, message: str, package_name: str | None = None) -> None:
+        self.package_name = package_name
+        if package_name:
+            message = f"[{package_name}] {message}"
+        super().__init__(message)
+
+
+class PublishError(PyMelosError):
+    """Error during package publishing."""
+
+    def __init__(self, message: str, package_name: str, registry: str | None = None) -> None:
+        self.package_name = package_name
+        self.registry = registry
+        full_message = f"Failed to publish {package_name}"
+        if registry:
+            full_message += f" to {registry}"
+        full_message += f": {message}"
+        super().__init__(full_message)
+
+
+class ValidationError(PyMelosError):
+    """Validation errors, typically multiple issues."""
+
+    def __init__(self, errors: list[str]) -> None:
+        self.errors = errors
+        message = "Validation failed:\n" + "\n".join(f"  - {e}" for e in errors)
+        super().__init__(message)

pymelos/execution/__init__.py

@@ -0,0 +1,32 @@
+"""Command execution engine."""
+
+from pymelos.execution.parallel import (
+    ParallelExecutor,
+    execute_parallel,
+    execute_topological,
+)
+from pymelos.execution.results import (
+    BatchResult,
+    ExecutionResult,
+    ExecutionStatus,
+)
+from pymelos.execution.runner import (
+    run_command,
+    run_command_sync,
+    run_in_package,
+)
+
+__all__ = [
+    # Results
+    "ExecutionResult",
+    "ExecutionStatus",
+    "BatchResult",
+    # Runner
+    "run_command",
+    "run_command_sync",
+    "run_in_package",
+    # Parallel
+    "ParallelExecutor",
+    "execute_parallel",
+    "execute_topological",
+]

pymelos/execution/parallel.py

@@ -0,0 +1,249 @@
+"""Parallel command execution with concurrency control."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator, Iterator
+from typing import TYPE_CHECKING
+
+from pymelos.execution.results import BatchResult, ExecutionResult, ExecutionStatus
+from pymelos.execution.runner import run_in_package
+
+if TYPE_CHECKING:
+    from pymelos.workspace.package import Package
+
+
+class ParallelExecutor:
+    """Execute commands across packages with controlled parallelism.
+
+    Supports topological ordering and fail-fast behavior.
+
+    Attributes:
+        concurrency: Maximum number of concurrent executions.
+        fail_fast: Stop on first failure.
+    """
+
+    def __init__(
+        self,
+        concurrency: int = 4,
+        fail_fast: bool = False,
+    ) -> None:
+        """Initialize executor.
+
+        Args:
+            concurrency: Maximum parallel executions.
+            fail_fast: Stop on first failure.
+        """
+        self.concurrency = max(1, concurrency)
+        self.fail_fast = fail_fast
+        self._cancelled = False
+
+    async def execute(
+        self,
+        packages: list[Package],
+        command: str,
+        *,
+        env: dict[str, str] | None = None,
+        timeout: float | None = None,
+    ) -> BatchResult:
+        """Execute command across packages in parallel.
+
+        Args:
+            packages: Packages to run command in.
+            command: Shell command to execute.
+            env: Environment variables.
+            timeout: Per-package timeout in seconds.
+
+        Returns:
+            Batch result with all execution results.
+        """
+        results: list[ExecutionResult] = []
+        self._cancelled = False
+
+        semaphore = asyncio.Semaphore(self.concurrency)
+
+        async def run_one(pkg: Package) -> ExecutionResult:
+            if self._cancelled:
+                return ExecutionResult(
+                    package_name=pkg.name,
+                    status=ExecutionStatus.CANCELLED,
+                    exit_code=-1,
+                )
+
+            async with semaphore:
+                if self._cancelled:
+                    return ExecutionResult(
+                        package_name=pkg.name,
+                        status=ExecutionStatus.CANCELLED,
+                        exit_code=-1,
+                    )
+
+                result = await run_in_package(pkg, command, env=env, timeout=timeout)
+
+                if self.fail_fast and result.failed:
+                    self._cancelled = True
+
+                return result
+
+        tasks = [asyncio.create_task(run_one(pkg)) for pkg in packages]
+        results = await asyncio.gather(*tasks)
+
+        return BatchResult(results=list(results))
+
+    async def execute_batches(
+        self,
+        batches: Iterator[list[Package]],
+        command: str,
+        *,
+        env: dict[str, str] | None = None,
+        timeout: float | None = None,
+    ) -> BatchResult:
+        """Execute command across package batches (topological order).
+
+        Each batch is executed in parallel, but batches are sequential.
+
+        Args:
+            batches: Iterator of package batches (from parallel_batches).
+            command: Shell command to execute.
+            env: Environment variables.
+            timeout: Per-package timeout in seconds.
+
+        Returns:
+            Batch result with all execution results.
+        """
+        all_results: list[ExecutionResult] = []
+        self._cancelled = False
+
+        for batch in batches:
+            if self._cancelled:
+                # Mark remaining as cancelled
+                for pkg in batch:
+                    all_results.append(
+                        ExecutionResult(
+                            package_name=pkg.name,
+                            status=ExecutionStatus.CANCELLED,
+                            exit_code=-1,
+                        )
+                    )
+                continue
+
+            batch_result = await self.execute(
+                batch,
+                command,
+                env=env,
+                timeout=timeout,
+            )
+            all_results.extend(batch_result.results)
+
+            if self.fail_fast and batch_result.any_failure:
+                self._cancelled = True
+
+        return BatchResult(results=all_results)
+
+    async def stream(
+        self,
+        packages: list[Package],
+        command: str,
+        *,
+        env: dict[str, str] | None = None,
+        timeout: float | None = None,
+    ) -> AsyncIterator[ExecutionResult]:
+        """Stream execution results as they complete.
+
+        Args:
+            packages: Packages to run command in.
+            command: Shell command to execute.
+            env: Environment variables.
+            timeout: Per-package timeout in seconds.
+
+        Yields:
+            Execution results as they complete.
+        """
+        self._cancelled = False
+        semaphore = asyncio.Semaphore(self.concurrency)
+
+        async def run_one(pkg: Package) -> ExecutionResult:
+            if self._cancelled:
+                return ExecutionResult(
+                    package_name=pkg.name,
+                    status=ExecutionStatus.CANCELLED,
+                    exit_code=-1,
+                )
+
+            async with semaphore:
+                return await run_in_package(pkg, command, env=env, timeout=timeout)
+
+        tasks = {asyncio.create_task(run_one(pkg)): pkg for pkg in packages}
+        pending = set(tasks.keys())
+
+        while pending:
+            done, pending = await asyncio.wait(
+                pending,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+
+            for task in done:
+                result = task.result()
+                yield result
+
+                if self.fail_fast and result.failed:
+                    self._cancelled = True
+                    # Cancel pending tasks
+                    for p in pending:
+                        p.cancel()
+
+    def cancel(self) -> None:
+        """Cancel ongoing executions."""
+        self._cancelled = True
+
+
+async def execute_parallel(
+    packages: list[Package],
+    command: str,
+    *,
+    concurrency: int = 4,
+    fail_fast: bool = False,
+    env: dict[str, str] | None = None,
+    timeout: float | None = None,
+) -> BatchResult:
+    """Convenience function for parallel execution.
+
+    Args:
+        packages: Packages to run command in.
+        command: Shell command to execute.
+        concurrency: Maximum parallel executions.
+        fail_fast: Stop on first failure.
+        env: Environment variables.
+        timeout: Per-package timeout in seconds.
+
+    Returns:
+        Batch result with all execution results.
+    """
+    executor = ParallelExecutor(concurrency=concurrency, fail_fast=fail_fast)
+    return await executor.execute(packages, command, env=env, timeout=timeout)
+
+
+async def execute_topological(
+    batches: Iterator[list[Package]],
+    command: str,
+    *,
+    concurrency: int = 4,
+    fail_fast: bool = False,
+    env: dict[str, str] | None = None,
+    timeout: float | None = None,
+) -> BatchResult:
+    """Execute command in topological order.
+
+    Args:
+        batches: Package batches from workspace.parallel_batches().
+        command: Shell command to execute.
+        concurrency: Maximum parallel executions per batch.
+        fail_fast: Stop on first failure.
+        env: Environment variables.
+        timeout: Per-package timeout in seconds.
+
+    Returns:
+        Batch result with all execution results.
+    """
+    executor = ParallelExecutor(concurrency=concurrency, fail_fast=fail_fast)
+    return await executor.execute_batches(batches, command, env=env, timeout=timeout)