pymelos 0.1.3__py3-none-any.whl

pymelos/commands/changed.py

@@ -0,0 +1,161 @@
+"""Changed command implementation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from pymelos.commands.base import CommandContext, SyncCommand
+from pymelos.workspace.workspace import Workspace
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class ChangedPackage:
+    """Information about a changed package."""
+
+    name: str
+    path: str
+    files_changed: int
+    is_dependent: bool  # True if changed due to dependency
+
+
+@dataclass
+class ChangedResult:
+    """Result of changed command."""
+
+    since: str
+    changed: list[ChangedPackage]
+    total_files_changed: int
+
+
+@dataclass
+class ChangedOptions:
+    """Options for changed command."""
+
+    since: str
+    include_dependents: bool = True
+    scope: str | None = None
+    ignore: list[str] | None = None
+
+
+class ChangedCommand(SyncCommand[ChangedResult]):
+    """List packages that have changed since a git reference."""
+
+    def __init__(self, context: CommandContext, options: ChangedOptions) -> None:
+        super().__init__(context)
+        self.options = options
+
+    def execute(self) -> ChangedResult:
+        """Execute the changed command."""
+        from pymelos.filters import apply_filters
+        from pymelos.git import get_changed_files_since
+
+        # Get all changed files
+        changed_files = get_changed_files_since(self.workspace.root, self.options.since)
+
+        # Map files to packages
+        directly_changed: dict[str, list[str]] = {}  # package -> files
+
+        for pkg in self.workspace.packages.values():
+            pkg_files: list[str] = []
+            for file_path in changed_files:
+                abs_path = self.workspace.root / file_path
+                try:
+                    abs_path.relative_to(pkg.path)
+                    pkg_files.append(str(file_path))
+                except ValueError:
+                    continue
+
+            if pkg_files:
+                directly_changed[pkg.name] = pkg_files
+
+        # Get dependents if requested
+        dependent_packages: set[str] = set()
+        if self.options.include_dependents:
+            for pkg_name in list(directly_changed.keys()):
+                dependents = self.workspace.graph.get_transitive_dependents(pkg_name)
+                for dep in dependents:
+                    if dep.name not in directly_changed:
+                        dependent_packages.add(dep.name)
+
+        # Build result
+        changed_pkgs: list[ChangedPackage] = []
+
+        # Add directly changed packages
+        for pkg_name, files in directly_changed.items():
+            pkg = self.workspace.get_package(pkg_name)
+            changed_pkgs.append(
+                ChangedPackage(
+                    name=pkg_name,
+                    path=str(pkg.path.relative_to(self.workspace.root)),
+                    files_changed=len(files),
+                    is_dependent=False,
+                )
+            )
+
+        # Add dependent packages
+        for pkg_name in dependent_packages:
+            pkg = self.workspace.get_package(pkg_name)
+            changed_pkgs.append(
+                ChangedPackage(
+                    name=pkg_name,
+                    path=str(pkg.path.relative_to(self.workspace.root)),
+                    files_changed=0,
+                    is_dependent=True,
+                )
+            )
+
+        # Apply filters
+        if self.options.scope or self.options.ignore:
+            pkg_list = [self.workspace.get_package(p.name) for p in changed_pkgs]
+            filtered = apply_filters(
+                pkg_list,
+                scope=self.options.scope,
+                ignore=self.options.ignore,
+            )
+            filtered_names = {p.name for p in filtered}
+            changed_pkgs = [p for p in changed_pkgs if p.name in filtered_names]
+
+        # Sort by name
+        changed_pkgs.sort(key=lambda p: p.name)
+
+        return ChangedResult(
+            since=self.options.since,
+            changed=changed_pkgs,
+            total_files_changed=len(changed_files),
+        )
+
+
+def get_changed_packages(
+    workspace: Workspace,
+    since: str,
+    *,
+    include_dependents: bool = True,
+    scope: str | None = None,
+    ignore: list[str] | None = None,
+) -> ChangedResult:
+    """Convenience function to get changed packages.
+
+    Args:
+        workspace: Workspace to check.
+        since: Git reference.
+        include_dependents: Include transitive dependents.
+        scope: Package scope filter.
+        ignore: Patterns to exclude.
+
+    Returns:
+        Changed result.
+    """
+
+    context = CommandContext(workspace=workspace)
+    options = ChangedOptions(
+        since=since,
+        include_dependents=include_dependents,
+        scope=scope,
+        ignore=ignore,
+    )
+    cmd = ChangedCommand(context, options)
+    return cmd.execute()

pymelos/commands/clean.py

@@ -0,0 +1,142 @@
+"""Clean command implementation."""
+
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from pymelos.commands.base import Command, CommandContext
+
+if TYPE_CHECKING:
+    from pymelos.workspace import Package
+    from pymelos.workspace.workspace import Workspace
+
+
+@dataclass
+class CleanResult:
+    """Result of clean command."""
+
+    files_removed: int
+    dirs_removed: int
+    bytes_freed: int
+    packages_cleaned: list[str]
+
+
+@dataclass
+class CleanOptions:
+    """Options for clean command."""
+
+    scope: str | None = None
+    patterns: list[str] | None = None
+    protected: list[str] | None = None
+    dry_run: bool = False
+
+
+class CleanCommand(Command[CleanResult]):
+    """Clean build artifacts from packages."""
+
+    def __init__(self, context: CommandContext, options: CleanOptions | None = None) -> None:
+        super().__init__(context)
+        self.options = options or CleanOptions()
+
+    def get_packages(self) -> list[Package]:
+        """Get packages to clean."""
+        from pymelos.filters import apply_filters
+
+        packages = list(self.workspace.packages.values())
+        return apply_filters(packages, scope=self.options.scope)
+
+    def get_patterns(self) -> list[str]:
+        """Get patterns to clean."""
+        if self.options.patterns:
+            return self.options.patterns
+        return self.workspace.config.clean.patterns
+
+    def get_protected(self) -> set[str]:
+        """Get protected patterns."""
+        if self.options.protected:
+            return set(self.options.protected)
+        return set(self.workspace.config.clean.protected)
+
+    def is_protected(self, path: Path, protected: set[str]) -> bool:
+        """Check if a path is protected."""
+        import fnmatch
+
+        return any(fnmatch.fnmatch(path.name, pattern) for pattern in protected)
+
+    def _calculate_size(self, path: Path) -> int:
+        """Calculate total size of a path (file or directory)."""
+        if path.is_file():
+            return path.stat().st_size
+        return sum(f.stat().st_size for f in path.rglob("*") if f.is_file())
+
+    def _get_paths_to_clean(
+        self, packages: list[Package], patterns: list[str], protected: set[str]
+    ) -> list[tuple[str, Path]]:
+        """Get all paths to clean with their package names."""
+        return [
+            (pkg.name, path)
+            for pkg in packages
+            for pattern in patterns
+            for path in pkg.path.glob(pattern)
+            if not self.is_protected(path, protected)
+        ]
+
+    async def execute(self) -> CleanResult:
+        """Execute the clean command."""
+        paths_to_clean = self._get_paths_to_clean(
+            self.get_packages(), self.get_patterns(), self.get_protected()
+        )
+
+        files_removed = 0
+        dirs_removed = 0
+        bytes_freed = 0
+        packages_cleaned: set[str] = set()
+        is_dry_run = self.options.dry_run or self.context.dry_run
+
+        for pkg_name, path in paths_to_clean:
+            bytes_freed += self._calculate_size(path)
+            packages_cleaned.add(pkg_name)
+
+            if path.is_file():
+                files_removed += 1
+                if not is_dry_run:
+                    path.unlink()
+            elif path.is_dir():
+                dirs_removed += 1
+                if not is_dry_run:
+                    shutil.rmtree(path)
+
+        return CleanResult(
+            files_removed=files_removed,
+            dirs_removed=dirs_removed,
+            bytes_freed=bytes_freed,
+            packages_cleaned=list(packages_cleaned),
+        )
+
+
+async def clean(
+    workspace: Workspace,
+    *,
+    scope: str | None = None,
+    patterns: list[str] | None = None,
+    dry_run: bool = False,
+) -> CleanResult:
+    """Convenience function to clean packages.
+
+    Args:
+        workspace: Workspace to clean.
+        scope: Package scope filter.
+        patterns: Override clean patterns.
+        dry_run: Show what would be cleaned.
+
+    Returns:
+        Clean result.
+    """
+
+    context = CommandContext(workspace=workspace, dry_run=dry_run)
+    options = CleanOptions(scope=scope, patterns=patterns, dry_run=dry_run)
+    cmd = CleanCommand(context, options)
+    return await cmd.execute()

pymelos/commands/exec.py

@@ -0,0 +1,116 @@
+"""Exec command implementation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from pymelos.commands.base import Command, CommandContext
+from pymelos.execution import BatchResult, ParallelExecutor
+
+if TYPE_CHECKING:
+    from pymelos.workspace import Package
+    from pymelos.workspace.workspace import Workspace
+
+
+@dataclass
+class ExecOptions:
+    """Options for exec command."""
+
+    command: str
+    scope: str | None = None
+    since: str | None = None
+    ignore: list[str] | None = None
+    concurrency: int = 4
+    fail_fast: bool = False
+    topological: bool = False  # exec doesn't default to topological
+    include_dependents: bool = False
+
+
+class ExecCommand(Command[BatchResult]):
+    """Execute an arbitrary command across packages.
+
+    Unlike 'run', exec takes a direct command string rather
+    than a script name from configuration.
+    """
+
+    def __init__(self, context: CommandContext, options: ExecOptions) -> None:
+        super().__init__(context)
+        self.options = options
+
+    def get_packages(self) -> list[Package]:
+        """Get packages to execute command in."""
+        from pymelos.filters import apply_filters_with_since
+
+        packages = list(self.workspace.packages.values())
+
+        return apply_filters_with_since(
+            packages,
+            self.workspace,
+            scope=self.options.scope,
+            since=self.options.since,
+            ignore=self.options.ignore,
+            include_dependents=self.options.include_dependents,
+        )
+
+    async def execute(self) -> BatchResult:
+        """Execute the command."""
+        packages = self.get_packages()
+        if not packages:
+            return BatchResult(results=[])
+
+        # Build environment
+        env = dict(self.context.env)
+        env.update(self.workspace.config.env)
+
+        executor = ParallelExecutor(
+            concurrency=self.options.concurrency,
+            fail_fast=self.options.fail_fast,
+        )
+
+        if self.options.topological:
+            batches = self.workspace.parallel_batches(packages)
+            return await executor.execute_batches(batches, self.options.command, env=env)
+        else:
+            return await executor.execute(packages, self.options.command, env=env)
+
+
+async def exec_command(
+    workspace: Workspace,
+    command: str,
+    *,
+    scope: str | None = None,
+    since: str | None = None,
+    ignore: list[str] | None = None,
+    concurrency: int = 4,
+    fail_fast: bool = False,
+    topological: bool = False,
+) -> BatchResult:
+    """Convenience function to execute a command.
+
+    Args:
+        workspace: Workspace to run in.
+        command: Command to execute.
+        scope: Package scope filter.
+        since: Git reference.
+        ignore: Patterns to exclude.
+        concurrency: Parallel jobs.
+        fail_fast: Stop on first failure.
+        topological: Respect dependency order.
+
+    Returns:
+        Batch result.
+    """
+
+    context = CommandContext(workspace=workspace)
+    options = ExecOptions(
+        command=command,
+        scope=scope,
+        since=since,
+        ignore=ignore,
+        concurrency=concurrency,
+        fail_fast=fail_fast,
+        topological=topological,
+    )
+    cmd = ExecCommand(context, options)
+    return await cmd.execute()

pymelos/commands/list.py

@@ -0,0 +1,128 @@
+"""List command implementation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from pymelos.commands.base import CommandContext, SyncCommand
+
+if TYPE_CHECKING:
+    from pymelos.workspace import Package
+    from pymelos.workspace.workspace import Workspace
+
+
+class ListFormat(Enum):
+    """Output format for list command."""
+
+    TABLE = "table"
+    JSON = "json"
+    GRAPH = "graph"
+    NAMES = "names"
+
+
+@dataclass
+class PackageInfo:
+    """Information about a package for display."""
+
+    name: str
+    version: str
+    path: str
+    description: str | None
+    dependencies: list[str]
+    dependents: list[str]
+
+
+@dataclass
+class ListResult:
+    """Result of list command."""
+
+    packages: list[PackageInfo]
+
+
+@dataclass
+class ListOptions:
+    """Options for list command."""
+
+    scope: str | None = None
+    since: str | None = None
+    ignore: list[str] | None = None
+    format: ListFormat = ListFormat.TABLE
+    include_dependents: bool = False
+
+
+class ListCommand(SyncCommand[ListResult]):
+    """List packages in the workspace."""
+
+    def __init__(self, context: CommandContext, options: ListOptions | None = None) -> None:
+        super().__init__(context)
+        self.options = options or ListOptions()
+
+    def get_packages(self) -> list[Package]:
+        """Get packages to list."""
+        from pymelos.filters import apply_filters_with_since
+
+        packages = list(self.workspace.packages.values())
+
+        return apply_filters_with_since(
+            packages,
+            self.workspace,
+            scope=self.options.scope,
+            since=self.options.since,
+            ignore=self.options.ignore,
+            include_dependents=self.options.include_dependents,
+        )
+
+    def execute(self) -> ListResult:
+        """Execute the list command."""
+        packages = self.get_packages()
+        graph = self.workspace.graph
+
+        infos: list[PackageInfo] = []
+        for pkg in packages:
+            deps = graph.get_dependencies(pkg.name)
+            dependents = graph.get_dependents(pkg.name)
+
+            infos.append(
+                PackageInfo(
+                    name=pkg.name,
+                    version=pkg.version,
+                    path=str(pkg.path.relative_to(self.workspace.root)),
+                    description=pkg.description,
+                    dependencies=[d.name for d in deps],
+                    dependents=[d.name for d in dependents],
+                )
+            )
+
+        # Sort by name
+        infos.sort(key=lambda p: p.name)
+
+        return ListResult(packages=infos)
+
+
+def list_packages(
+    workspace: Workspace,
+    *,
+    scope: str | None = None,
+    since: str | None = None,
+    ignore: list[str] | None = None,
+    format: ListFormat = ListFormat.TABLE,
+) -> ListResult:
+    """Convenience function to list packages.
+
+    Args:
+        workspace: Workspace to list.
+        scope: Package scope filter.
+        since: Git reference.
+        ignore: Patterns to exclude.
+        format: Output format.
+
+    Returns:
+        List result with package info.
+    """
+
+    context = CommandContext(workspace=workspace)
+    options = ListOptions(scope=scope, since=since, ignore=ignore, format=format)
+    cmd = ListCommand(context, options)
+    return cmd.execute()