pactown 0.1.4__py3-none-any.whl

pactown/parallel.py

@@ -0,0 +1,268 @@
+"""Parallel execution utilities for pactown."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Callable, Optional, Any
+from threading import Lock
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+
+console = Console()
+
+
+@dataclass
+class TaskResult:
+    """Result of a parallel task."""
+    name: str
+    success: bool
+    duration: float
+    result: Any = None
+    error: Optional[str] = None
+
+
+def run_parallel(
+    tasks: dict[str, Callable[[], Any]],
+    max_workers: int = 4,
+    show_progress: bool = True,
+    description: str = "Running tasks",
+) -> dict[str, TaskResult]:
+    """
+    Run multiple tasks in parallel using ThreadPoolExecutor.
+    
+    Args:
+        tasks: Dict of {name: callable} to run
+        max_workers: Maximum parallel workers
+        show_progress: Show progress bar
+        description: Progress description
+    
+    Returns:
+        Dict of {name: TaskResult}
+    """
+    results: dict[str, TaskResult] = {}
+    
+    if not tasks:
+        return results
+    
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = {}
+        start_times = {}
+        
+        for name, func in tasks.items():
+            start_times[name] = time.time()
+            futures[executor.submit(func)] = name
+        
+        if show_progress:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TaskProgressColumn(),
+                console=console,
+            ) as progress:
+                task = progress.add_task(description, total=len(tasks))
+                
+                for future in as_completed(futures):
+                    name = futures[future]
+                    duration = time.time() - start_times[name]
+                    
+                    try:
+                        result = future.result()
+                        results[name] = TaskResult(
+                            name=name,
+                            success=True,
+                            duration=duration,
+                            result=result,
+                        )
+                    except Exception as e:
+                        results[name] = TaskResult(
+                            name=name,
+                            success=False,
+                            duration=duration,
+                            error=str(e),
+                        )
+                    
+                    progress.advance(task)
+        else:
+            for future in as_completed(futures):
+                name = futures[future]
+                duration = time.time() - start_times[name]
+                
+                try:
+                    result = future.result()
+                    results[name] = TaskResult(
+                        name=name,
+                        success=True,
+                        duration=duration,
+                        result=result,
+                    )
+                except Exception as e:
+                    results[name] = TaskResult(
+                        name=name,
+                        success=False,
+                        duration=duration,
+                        error=str(e),
+                    )
+    
+    return results
+
+
+def run_in_dependency_waves(
+    tasks: dict[str, Callable[[], Any]],
+    dependencies: dict[str, list[str]],
+    max_workers: int = 4,
+    on_complete: Optional[Callable[[str, TaskResult], None]] = None,
+) -> dict[str, TaskResult]:
+    """
+    Run tasks in waves based on dependencies.
+    
+    Services with no unmet dependencies run in parallel.
+    When a wave completes, next wave starts.
+    
+    Args:
+        tasks: Dict of {name: callable}
+        dependencies: Dict of {name: [dependency_names]}
+        max_workers: Max parallel workers per wave
+        on_complete: Callback when task completes
+    
+    Returns:
+        Dict of {name: TaskResult}
+    """
+    results: dict[str, TaskResult] = {}
+    completed = set()
+    remaining = set(tasks.keys())
+    
+    while remaining:
+        # Find tasks with all dependencies satisfied
+        ready = []
+        for name in remaining:
+            deps = dependencies.get(name, [])
+            if all(d in completed for d in deps):
+                ready.append(name)
+        
+        if not ready:
+            # Circular dependency or missing dependency
+            raise ValueError(f"Cannot resolve dependencies for: {remaining}")
+        
+        # Run ready tasks in parallel
+        wave_tasks = {name: tasks[name] for name in ready}
+        wave_results = run_parallel(wave_tasks, max_workers=max_workers, show_progress=False)
+        
+        for name, result in wave_results.items():
+            results[name] = result
+            remaining.remove(name)
+            
+            if result.success:
+                completed.add(name)
+            
+            if on_complete:
+                on_complete(name, result)
+        
+        # If any task in wave failed, stop
+        if any(not r.success for r in wave_results.values()):
+            break
+    
+    return results
+
+
+async def run_parallel_async(
+    tasks: dict[str, Callable[[], Any]],
+    max_concurrent: int = 4,
+) -> dict[str, TaskResult]:
+    """
+    Run tasks using asyncio with a semaphore for concurrency control.
+    
+    Uses run_in_executor for CPU-bound tasks.
+    """
+    results: dict[str, TaskResult] = {}
+    semaphore = asyncio.Semaphore(max_concurrent)
+    
+    async def run_task(name: str, func: Callable) -> TaskResult:
+        async with semaphore:
+            start = time.time()
+            try:
+                loop = asyncio.get_event_loop()
+                result = await loop.run_in_executor(None, func)
+                return TaskResult(
+                    name=name,
+                    success=True,
+                    duration=time.time() - start,
+                    result=result,
+                )
+            except Exception as e:
+                return TaskResult(
+                    name=name,
+                    success=False,
+                    duration=time.time() - start,
+                    error=str(e),
+                )
+    
+    coros = [run_task(name, func) for name, func in tasks.items()]
+    task_results = await asyncio.gather(*coros)
+    
+    for result in task_results:
+        results[result.name] = result
+    
+    return results
+
+
+class ParallelSandboxBuilder:
+    """Build multiple sandboxes in parallel."""
+    
+    def __init__(self, max_workers: int = 4):
+        self.max_workers = max_workers
+        self._lock = Lock()
+    
+    def build_sandboxes(
+        self,
+        services: list[tuple[str, Path, Callable]],
+        on_complete: Optional[Callable[[str, bool, float], None]] = None,
+    ) -> dict[str, TaskResult]:
+        """
+        Build sandboxes for multiple services in parallel.
+        
+        Args:
+            services: List of (name, readme_path, build_func)
+            on_complete: Callback(name, success, duration)
+        
+        Returns:
+            Dict of results
+        """
+        tasks = {}
+        for name, readme_path, build_func in services:
+            tasks[name] = build_func
+        
+        def callback(name: str, result: TaskResult):
+            if on_complete:
+                on_complete(name, result.success, result.duration)
+        
+        return run_parallel(
+            tasks,
+            max_workers=self.max_workers,
+            show_progress=True,
+            description="Building sandboxes",
+        )
+
+
+def format_parallel_results(results: dict[str, TaskResult]) -> str:
+    """Format parallel execution results for display."""
+    lines = []
+    total_time = sum(r.duration for r in results.values())
+    
+    successful = [r for r in results.values() if r.success]
+    failed = [r for r in results.values() if not r.success]
+    
+    lines.append(f"Completed: {len(successful)}/{len(results)} tasks")
+    lines.append(f"Total time: {total_time:.2f}s")
+    
+    if failed:
+        lines.append("\nFailed:")
+        for r in failed:
+            lines.append(f"  ✗ {r.name}: {r.error}")
+    
+    return "\n".join(lines)

pactown/registry/__init__.py

@@ -0,0 +1,12 @@
+"""Pactown registry - local artifact registry for markpact modules."""
+
+from .server import create_app
+from .client import RegistryClient
+from .models import Artifact, ArtifactVersion
+
+__all__ = [
+    "create_app",
+    "RegistryClient",
+    "Artifact",
+    "ArtifactVersion",
+]

pactown/registry/client.py

@@ -0,0 +1,253 @@
+"""Client for pactown registry."""
+
+from pathlib import Path
+from typing import Optional, Any
+import hashlib
+
+import httpx
+
+
+class RegistryClient:
+    """Client for interacting with pactown registry."""
+    
+    def __init__(self, base_url: str = "http://localhost:8800", timeout: float = 30.0):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._client = httpx.Client(timeout=timeout)
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, *args):
+        self._client.close()
+    
+    def close(self):
+        self._client.close()
+    
+    def health(self) -> bool:
+        """Check if registry is healthy."""
+        try:
+            response = self._client.get(f"{self.base_url}/health")
+            return response.status_code == 200
+        except Exception:
+            return False
+    
+    def list_artifacts(
+        self, 
+        namespace: Optional[str] = None, 
+        search: Optional[str] = None
+    ) -> list[dict]:
+        """List artifacts in the registry."""
+        params = {}
+        if namespace:
+            params["namespace"] = namespace
+        if search:
+            params["search"] = search
+        
+        response = self._client.get(f"{self.base_url}/v1/artifacts", params=params)
+        response.raise_for_status()
+        return response.json()
+    
+    def get_artifact(self, name: str, namespace: str = "default") -> Optional[dict]:
+        """Get artifact information."""
+        try:
+            response = self._client.get(
+                f"{self.base_url}/v1/artifacts/{namespace}/{name}"
+            )
+            if response.status_code == 404:
+                return None
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError:
+            return None
+    
+    def get_version(
+        self, 
+        name: str, 
+        version: str = "latest", 
+        namespace: str = "default"
+    ) -> Optional[dict]:
+        """Get specific version information."""
+        try:
+            response = self._client.get(
+                f"{self.base_url}/v1/artifacts/{namespace}/{name}/{version}"
+            )
+            if response.status_code == 404:
+                return None
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError:
+            return None
+    
+    def get_readme(
+        self, 
+        name: str, 
+        version: str = "latest", 
+        namespace: str = "default"
+    ) -> Optional[str]:
+        """Get README content for a specific version."""
+        try:
+            response = self._client.get(
+                f"{self.base_url}/v1/artifacts/{namespace}/{name}/{version}/readme"
+            )
+            if response.status_code == 404:
+                return None
+            response.raise_for_status()
+            return response.json().get("content")
+        except httpx.HTTPStatusError:
+            return None
+    
+    def publish(
+        self,
+        name: str,
+        version: str,
+        readme_path: Optional[Path] = None,
+        readme_content: Optional[str] = None,
+        namespace: str = "default",
+        description: str = "",
+        tags: Optional[list[str]] = None,
+        metadata: Optional[dict] = None,
+    ) -> dict:
+        """Publish an artifact to the registry."""
+        if readme_path:
+            readme_content = Path(readme_path).read_text()
+        
+        if not readme_content:
+            raise ValueError("Either readme_path or readme_content must be provided")
+        
+        payload = {
+            "name": name,
+            "version": version,
+            "readme_content": readme_content,
+            "namespace": namespace,
+            "description": description,
+            "tags": tags or [],
+            "metadata": metadata or {},
+        }
+        
+        try:
+            response = self._client.post(f"{self.base_url}/v1/publish", json=payload)
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            return {"success": False, "error": str(e)}
+    
+    def pull(
+        self, 
+        name: str, 
+        version: str = "latest", 
+        namespace: str = "default",
+        output_path: Optional[Path] = None,
+    ) -> Optional[str]:
+        """Pull an artifact from the registry."""
+        readme = self.get_readme(name, version, namespace)
+        
+        if readme and output_path:
+            output_path = Path(output_path)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(readme)
+        
+        return readme
+    
+    def delete(self, name: str, namespace: str = "default") -> bool:
+        """Delete an artifact from the registry."""
+        try:
+            response = self._client.delete(
+                f"{self.base_url}/v1/artifacts/{namespace}/{name}"
+            )
+            return response.status_code == 200
+        except httpx.HTTPStatusError:
+            return False
+    
+    def list_namespaces(self) -> list[str]:
+        """List all namespaces."""
+        try:
+            response = self._client.get(f"{self.base_url}/v1/namespaces")
+            response.raise_for_status()
+            return response.json().get("namespaces", [])
+        except httpx.HTTPStatusError:
+            return []
+
+
+class AsyncRegistryClient:
+    """Async client for pactown registry."""
+    
+    def __init__(self, base_url: str = "http://localhost:8800", timeout: float = 30.0):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._client = httpx.AsyncClient(timeout=timeout)
+    
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, *args):
+        await self._client.aclose()
+    
+    async def close(self):
+        await self._client.aclose()
+    
+    async def health(self) -> bool:
+        try:
+            response = await self._client.get(f"{self.base_url}/health")
+            return response.status_code == 200
+        except Exception:
+            return False
+    
+    async def list_artifacts(
+        self, 
+        namespace: Optional[str] = None,
+        search: Optional[str] = None,
+    ) -> list[dict]:
+        params = {}
+        if namespace:
+            params["namespace"] = namespace
+        if search:
+            params["search"] = search
+        
+        response = await self._client.get(f"{self.base_url}/v1/artifacts", params=params)
+        response.raise_for_status()
+        return response.json()
+    
+    async def get_readme(
+        self, 
+        name: str, 
+        version: str = "latest", 
+        namespace: str = "default"
+    ) -> Optional[str]:
+        try:
+            response = await self._client.get(
+                f"{self.base_url}/v1/artifacts/{namespace}/{name}/{version}/readme"
+            )
+            if response.status_code == 404:
+                return None
+            response.raise_for_status()
+            return response.json().get("content")
+        except httpx.HTTPStatusError:
+            return None
+    
+    async def publish(
+        self,
+        name: str,
+        version: str,
+        readme_content: str,
+        namespace: str = "default",
+        description: str = "",
+        tags: Optional[list[str]] = None,
+        metadata: Optional[dict] = None,
+    ) -> dict:
+        payload = {
+            "name": name,
+            "version": version,
+            "readme_content": readme_content,
+            "namespace": namespace,
+            "description": description,
+            "tags": tags or [],
+            "metadata": metadata or {},
+        }
+        
+        try:
+            response = await self._client.post(f"{self.base_url}/v1/publish", json=payload)
+            response.raise_for_status()
+            return response.json()
+        except httpx.HTTPStatusError as e:
+            return {"success": False, "error": str(e)}

pactown/registry/models.py

@@ -0,0 +1,150 @@
+"""Data models for pactown registry."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional, Any
+from pathlib import Path
+import json
+
+
+@dataclass
+class ArtifactVersion:
+    """A specific version of an artifact."""
+    version: str
+    readme_content: str
+    checksum: str
+    published_at: datetime = field(default_factory=datetime.utcnow)
+    metadata: dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> dict:
+        return {
+            "version": self.version,
+            "readme_content": self.readme_content,
+            "checksum": self.checksum,
+            "published_at": self.published_at.isoformat(),
+            "metadata": self.metadata,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> "ArtifactVersion":
+        return cls(
+            version=data["version"],
+            readme_content=data["readme_content"],
+            checksum=data["checksum"],
+            published_at=datetime.fromisoformat(data["published_at"]),
+            metadata=data.get("metadata", {}),
+        )
+
+
+@dataclass
+class Artifact:
+    """An artifact in the registry (a markpact module)."""
+    name: str
+    namespace: str = "default"
+    description: str = ""
+    versions: dict[str, ArtifactVersion] = field(default_factory=dict)
+    latest_version: Optional[str] = None
+    created_at: datetime = field(default_factory=datetime.utcnow)
+    updated_at: datetime = field(default_factory=datetime.utcnow)
+    tags: list[str] = field(default_factory=list)
+    
+    @property
+    def full_name(self) -> str:
+        return f"{self.namespace}/{self.name}"
+    
+    def add_version(self, version: ArtifactVersion) -> None:
+        self.versions[version.version] = version
+        self.latest_version = version.version
+        self.updated_at = datetime.utcnow()
+    
+    def get_version(self, version: str = "latest") -> Optional[ArtifactVersion]:
+        if version == "latest" or version == "*":
+            version = self.latest_version
+        return self.versions.get(version)
+    
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "namespace": self.namespace,
+            "description": self.description,
+            "versions": {k: v.to_dict() for k, v in self.versions.items()},
+            "latest_version": self.latest_version,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+            "tags": self.tags,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> "Artifact":
+        versions = {
+            k: ArtifactVersion.from_dict(v) 
+            for k, v in data.get("versions", {}).items()
+        }
+        return cls(
+            name=data["name"],
+            namespace=data.get("namespace", "default"),
+            description=data.get("description", ""),
+            versions=versions,
+            latest_version=data.get("latest_version"),
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+            tags=data.get("tags", []),
+        )
+
+
+class RegistryStorage:
+    """File-based storage for registry artifacts."""
+    
+    def __init__(self, storage_path: Path):
+        self.storage_path = Path(storage_path)
+        self.storage_path.mkdir(parents=True, exist_ok=True)
+        self._index_path = self.storage_path / "index.json"
+        self._artifacts: dict[str, Artifact] = {}
+        self._load()
+    
+    def _load(self) -> None:
+        if self._index_path.exists():
+            with open(self._index_path) as f:
+                data = json.load(f)
+                for full_name, artifact_data in data.get("artifacts", {}).items():
+                    self._artifacts[full_name] = Artifact.from_dict(artifact_data)
+    
+    def _save(self) -> None:
+        data = {
+            "artifacts": {k: v.to_dict() for k, v in self._artifacts.items()},
+            "updated_at": datetime.utcnow().isoformat(),
+        }
+        with open(self._index_path, "w") as f:
+            json.dump(data, f, indent=2)
+    
+    def get(self, namespace: str, name: str) -> Optional[Artifact]:
+        return self._artifacts.get(f"{namespace}/{name}")
+    
+    def list(self, namespace: Optional[str] = None) -> list[Artifact]:
+        if namespace:
+            return [a for a in self._artifacts.values() if a.namespace == namespace]
+        return list(self._artifacts.values())
+    
+    def save_artifact(self, artifact: Artifact) -> None:
+        self._artifacts[artifact.full_name] = artifact
+        self._save()
+    
+    def delete(self, namespace: str, name: str) -> bool:
+        key = f"{namespace}/{name}"
+        if key in self._artifacts:
+            del self._artifacts[key]
+            self._save()
+            return True
+        return False
+    
+    def search(self, query: str) -> list[Artifact]:
+        query = query.lower()
+        results = []
+        for artifact in self._artifacts.values():
+            if (query in artifact.name.lower() or 
+                query in artifact.description.lower() or
+                any(query in tag.lower() for tag in artifact.tags)):
+                results.append(artifact)
+        return results