pymelos 0.1.3__py3-none-any.whl

pymelos/execution/results.py

@@ -0,0 +1,172 @@
+"""Execution result models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class ExecutionStatus(Enum):
+    """Status of a command execution."""
+
+    SUCCESS = "success"
+    FAILURE = "failure"
+    SKIPPED = "skipped"
+    CANCELLED = "cancelled"
+
+
+@dataclass(frozen=True, slots=True)
+class ExecutionResult:
+    """Result of executing a command on a package.
+
+    Attributes:
+        package_name: Name of the package the command ran in.
+        status: Execution status.
+        exit_code: Process exit code.
+        stdout: Standard output.
+        stderr: Standard error.
+        duration_ms: Execution duration in milliseconds.
+        error: Exception if any occurred.
+        command: The command that was executed.
+    """
+
+    package_name: str
+    status: ExecutionStatus
+    exit_code: int
+    stdout: str = ""
+    stderr: str = ""
+    duration_ms: int = 0
+    error: Exception | None = None
+    command: str = ""
+
+    @property
+    def success(self) -> bool:
+        """Check if execution was successful."""
+        return self.status == ExecutionStatus.SUCCESS
+
+    @property
+    def failed(self) -> bool:
+        """Check if execution failed."""
+        return self.status == ExecutionStatus.FAILURE
+
+    @property
+    def skipped(self) -> bool:
+        """Check if execution was skipped."""
+        return self.status == ExecutionStatus.SKIPPED
+
+    @classmethod
+    def success_result(
+        cls,
+        package_name: str,
+        stdout: str = "",
+        stderr: str = "",
+        duration_ms: int = 0,
+        command: str = "",
+    ) -> ExecutionResult:
+        """Create a success result."""
+        return cls(
+            package_name=package_name,
+            status=ExecutionStatus.SUCCESS,
+            exit_code=0,
+            stdout=stdout,
+            stderr=stderr,
+            duration_ms=duration_ms,
+            command=command,
+        )
+
+    @classmethod
+    def failure_result(
+        cls,
+        package_name: str,
+        exit_code: int,
+        stdout: str = "",
+        stderr: str = "",
+        duration_ms: int = 0,
+        error: Exception | None = None,
+        command: str = "",
+    ) -> ExecutionResult:
+        """Create a failure result."""
+        return cls(
+            package_name=package_name,
+            status=ExecutionStatus.FAILURE,
+            exit_code=exit_code,
+            stdout=stdout,
+            stderr=stderr,
+            duration_ms=duration_ms,
+            error=error,
+            command=command,
+        )
+
+    @classmethod
+    def skipped_result(
+        cls,
+        package_name: str,
+        reason: str = "",
+    ) -> ExecutionResult:
+        """Create a skipped result."""
+        return cls(
+            package_name=package_name,
+            status=ExecutionStatus.SKIPPED,
+            exit_code=0,
+            stdout=reason,
+        )
+
+
+@dataclass
+class BatchResult:
+    """Result of executing a command across multiple packages.
+
+    Attributes:
+        results: Individual execution results.
+        total_duration_ms: Total execution duration.
+    """
+
+    results: list[ExecutionResult] = field(default_factory=list)
+    total_duration_ms: int = 0
+
+    @property
+    def all_success(self) -> bool:
+        """Check if all executions were successful."""
+        return all(r.success or r.skipped for r in self.results)
+
+    @property
+    def any_failure(self) -> bool:
+        """Check if any execution failed."""
+        return any(r.failed for r in self.results)
+
+    @property
+    def success_count(self) -> int:
+        """Count of successful executions."""
+        return sum(1 for r in self.results if r.success)
+
+    @property
+    def failure_count(self) -> int:
+        """Count of failed executions."""
+        return sum(1 for r in self.results if r.failed)
+
+    @property
+    def skipped_count(self) -> int:
+        """Count of skipped executions."""
+        return sum(1 for r in self.results if r.skipped)
+
+    @property
+    def failed_packages(self) -> list[str]:
+        """Get names of packages that failed."""
+        return [r.package_name for r in self.results if r.failed]
+
+    @property
+    def successful_packages(self) -> list[str]:
+        """Get names of packages that succeeded."""
+        return [r.package_name for r in self.results if r.success]
+
+    def add(self, result: ExecutionResult) -> None:
+        """Add a result to the batch."""
+        self.results.append(result)
+
+    def __len__(self) -> int:
+        """Number of results."""
+        return len(self.results)
+
+    def __iter__(self):
+        """Iterate over results."""
+        return iter(self.results)

pymelos/execution/runner.py

@@ -0,0 +1,171 @@
+"""Command execution engine with standard asynchronous capture."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from pymelos.execution.results import ExecutionResult
+
+if TYPE_CHECKING:
+    from pymelos.workspace.package import Package
+
+
+async def run_command(
+    command: str,
+    cwd: Path,
+    *,
+    env: dict[str, str] | None = None,
+    timeout: float | None = None,
+) -> tuple[int, str, str, int]:
+    """Run a shell command asynchronously.
+
+    Args:
+        command: Shell command to execute.
+        cwd: Working directory.
+        env: Environment variables (merged with current env).
+        timeout: Timeout in seconds.
+
+    Returns:
+        Tuple of (exit_code, stdout, stderr, duration_ms).
+    """
+    # Merge environment
+    run_env = os.environ.copy()
+    if env:
+        run_env.update(env)
+
+    start_time = time.monotonic()
+
+    try:
+        process = await asyncio.create_subprocess_shell(
+            command,
+            cwd=str(cwd),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=run_env,
+        )
+
+        try:
+            # Use communicate to wait for the process and capture all output at once
+            stdout_bytes, stderr_bytes = await asyncio.wait_for(
+                process.communicate(),
+                timeout=timeout,
+            )
+        except (asyncio.TimeoutError, TimeoutError):
+            process.kill()
+            await process.wait()
+            duration_ms = int((time.monotonic() - start_time) * 1000)
+            return -1, "", f"Command timed out after {timeout}s", duration_ms
+
+        duration_ms = int((time.monotonic() - start_time) * 1000)
+
+        stdout = stdout_bytes.decode("utf-8", errors="replace")
+        stderr = stderr_bytes.decode("utf-8", errors="replace")
+
+        return process.returncode or 0, stdout, stderr, duration_ms
+
+    except Exception as e:
+        duration_ms = int((time.monotonic() - start_time) * 1000)
+        return -1, "", str(e), duration_ms
+
+
+async def run_in_package(
+    package: Package,
+    command: str,
+    *,
+    env: dict[str, str] | None = None,
+    timeout: float | None = None,
+) -> ExecutionResult:
+    """Run a command in a package directory.
+
+    Args:
+        package: Package to run command in.
+        command: Shell command to execute.
+        env: Additional environment variables.
+        timeout: Timeout in seconds.
+
+    Returns:
+        Execution result.
+    """
+    print(package.name, command)
+    # Build environment with package-specific variables
+    run_env = env.copy() if env else {}
+    run_env["PYMELOS_PACKAGE_NAME"] = package.name
+    run_env["PYMELOS_PACKAGE_PATH"] = str(package.path)
+    run_env["PYMELOS_PACKAGE_VERSION"] = package.version
+
+    exit_code, stdout, stderr, duration_ms = await run_command(
+        command,
+        cwd=package.path,
+        env=run_env,
+        timeout=timeout,
+    )
+
+    if exit_code == 0:
+        return ExecutionResult.success_result(
+            package_name=package.name,
+            stdout=stdout,
+            stderr=stderr,
+            duration_ms=duration_ms,
+            command=command,
+        )
+    else:
+        return ExecutionResult.failure_result(
+            package_name=package.name,
+            exit_code=exit_code,
+            stdout=stdout,
+            stderr=stderr,
+            duration_ms=duration_ms,
+            command=command,
+        )
+
+
+def run_command_sync(
+    command: str,
+    cwd: Path,
+    *,
+    env: dict[str, str] | None = None,
+    timeout: float | None = None,
+) -> tuple[int, str, str, int]:
+    """Run a shell command synchronously.
+
+    Args:
+        command: Shell command to execute.
+        cwd: Working directory.
+        env: Environment variables.
+        timeout: Timeout in seconds.
+
+    Returns:
+        Tuple of (exit_code, stdout, stderr, duration_ms).
+    """
+    import subprocess
+
+    run_env = os.environ.copy()
+    if env:
+        run_env.update(env)
+
+    start_time = time.monotonic()
+
+    try:
+        result = subprocess.run(
+            command,
+            shell=True,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            env=run_env,
+            timeout=timeout,
+        )
+        duration_ms = int((time.monotonic() - start_time) * 1000)
+        return result.returncode, result.stdout, result.stderr, duration_ms
+
+    except subprocess.TimeoutExpired:
+        duration_ms = int((time.monotonic() - start_time) * 1000)
+        return -1, "", f"Command timed out after {timeout}s", duration_ms
+
+    except Exception as e:
+        duration_ms = int((time.monotonic() - start_time) * 1000)
+        return -1, "", str(e), duration_ms

pymelos/filters/__init__.py

@@ -0,0 +1,27 @@
+"""Package filtering utilities."""
+
+from pymelos.filters.chain import apply_filters, apply_filters_with_since
+from pymelos.filters.ignore import filter_by_ignore, should_ignore
+from pymelos.filters.scope import filter_by_scope, match_scope, parse_scope
+from pymelos.filters.since import (
+    filter_by_since,
+    get_changed_files,
+    get_changed_packages,
+)
+
+__all__ = [
+    # Chain
+    "apply_filters",
+    "apply_filters_with_since",
+    # Scope
+    "filter_by_scope",
+    "match_scope",
+    "parse_scope",
+    # Ignore
+    "filter_by_ignore",
+    "should_ignore",
+    # Since
+    "filter_by_since",
+    "get_changed_files",
+    "get_changed_packages",
+]

pymelos/filters/chain.py

@@ -0,0 +1,101 @@
+"""Filter chain composition."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pymelos.filters.ignore import filter_by_ignore
+from pymelos.filters.scope import filter_by_scope
+
+if TYPE_CHECKING:
+    from pymelos.workspace.package import Package
+    from pymelos.workspace.workspace import Workspace
+
+
+def apply_filters(
+    packages: list[Package],
+    *,
+    scope: str | None = None,
+    ignore: list[str] | None = None,
+    names: list[str] | None = None,
+) -> list[Package]:
+    """Apply multiple filters to a package list.
+
+    Filters are applied in order:
+    1. Explicit names (if provided, only these packages)
+    2. Scope pattern matching
+    3. Ignore pattern exclusion
+
+    Args:
+        packages: List of packages to filter.
+        scope: Comma-separated names or glob patterns.
+        ignore: Patterns to exclude.
+        names: Explicit list of package names (overrides scope).
+
+    Returns:
+        Filtered list of packages.
+    """
+    result = packages
+
+    # If explicit names provided, filter to just those first
+    if names:
+        name_set = set(names)
+        result = [p for p in result if p.name in name_set]
+    else:
+        # Apply scope filter
+        result = filter_by_scope(result, scope)
+
+    # Apply ignore filter
+    result = filter_by_ignore(result, ignore)
+
+    return result
+
+
+def apply_filters_with_since(
+    packages: list[Package],
+    workspace: Workspace,
+    *,
+    scope: str | None = None,
+    since: str | None = None,
+    ignore: list[str] | None = None,
+    include_dependents: bool = False,
+) -> list[Package]:
+    """Apply filters including git-based since filter.
+
+    Args:
+        packages: List of packages to filter.
+        workspace: Workspace instance (needed for since filter).
+        scope: Comma-separated names or glob patterns.
+        since: Git reference for change detection.
+        ignore: Patterns to exclude.
+        include_dependents: Include packages that depend on changed packages.
+
+    Returns:
+        Filtered list of packages.
+    """
+    from pymelos.filters.since import filter_by_since
+
+    result = packages
+
+    # Apply scope filter first
+    result = filter_by_scope(result, scope)
+
+    # Apply since filter (git-based)
+    result = filter_by_since(
+        result,
+        workspace,
+        since,
+        include_dependents=include_dependents,
+    )
+
+    # Apply ignore filter last
+    result = filter_by_ignore(result, ignore)
+
+    return result
+
+
+# Type alias for filter function signature
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    FilterFunc = Callable[[list["Package"]], list["Package"]]

pymelos/filters/ignore.py

@@ -0,0 +1,60 @@
+"""Ignore-based package filtering."""
+
+from __future__ import annotations
+
+import fnmatch
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pymelos.workspace.package import Package
+
+
+def should_ignore(package: Package, patterns: list[str]) -> bool:
+    """Check if a package matches any ignore pattern.
+
+    Args:
+        package: Package to check.
+        patterns: List of ignore patterns.
+
+    Returns:
+        True if package should be ignored.
+    """
+    if not patterns:
+        return False
+
+    name = package.name
+    path_str = str(package.path)
+
+    for pattern in patterns:
+        # Match by name
+        if fnmatch.fnmatch(name, pattern):
+            return True
+
+        # Match by normalized name
+        if fnmatch.fnmatch(name.replace("-", "_"), pattern.replace("-", "_")):
+            return True
+
+        # Match by path
+        if fnmatch.fnmatch(path_str, pattern):
+            return True
+
+    return False
+
+
+def filter_by_ignore(
+    packages: list[Package],
+    ignore: list[str] | None,
+) -> list[Package]:
+    """Filter out packages matching ignore patterns.
+
+    Args:
+        packages: List of packages to filter.
+        ignore: List of ignore patterns.
+
+    Returns:
+        Filtered list of packages (not matching any ignore pattern).
+    """
+    if not ignore:
+        return packages
+
+    return [p for p in packages if not should_ignore(p, ignore)]

pymelos/filters/scope.py

@@ -0,0 +1,90 @@
+"""Scope-based package filtering."""
+
+from __future__ import annotations
+
+import fnmatch
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pymelos.workspace.package import Package
+
+
+def parse_scope(scope: str) -> list[str]:
+    """Parse a scope string into individual patterns.
+
+    Scope can be comma-separated names or glob patterns:
+    - "core,api" -> ["core", "api"]
+    - "*-lib" -> ["*-lib"]
+    - "core,*-lib" -> ["core", "*-lib"]
+
+    Args:
+        scope: Comma-separated scope string.
+
+    Returns:
+        List of individual patterns.
+    """
+    if not scope:
+        return []
+
+    patterns = [p.strip() for p in scope.split(",")]
+    return [p for p in patterns if p]
+
+
+def match_scope(package: Package, patterns: list[str]) -> bool:
+    """Check if a package matches any of the scope patterns.
+
+    Args:
+        package: Package to check.
+        patterns: List of name or glob patterns.
+
+    Returns:
+        True if package matches any pattern.
+    """
+    if not patterns:
+        return True  # No filter means match all
+
+    name = package.name
+
+    for pattern in patterns:
+        # Exact match
+        if name == pattern:
+            return True
+
+        # Case-insensitive exact match
+        if name.lower() == pattern.lower():
+            return True
+
+        # Glob pattern match
+        if fnmatch.fnmatch(name, pattern):
+            return True
+
+        # Try with normalized names (replace - with _)
+        normalized_name = name.replace("-", "_")
+        normalized_pattern = pattern.replace("-", "_")
+        if fnmatch.fnmatch(normalized_name, normalized_pattern):
+            return True
+
+    return False
+
+
+def filter_by_scope(
+    packages: list[Package],
+    scope: str | None,
+) -> list[Package]:
+    """Filter packages by scope pattern.
+
+    Args:
+        packages: List of packages to filter.
+        scope: Comma-separated names or glob patterns.
+
+    Returns:
+        Filtered list of packages.
+    """
+    if not scope:
+        return packages
+
+    patterns = parse_scope(scope)
+    if not patterns:
+        return packages
+
+    return [p for p in packages if match_scope(p, patterns)]