pactown 0.1.4__py3-none-any.whl → 0.1.47__py3-none-any.whl

pactown/parallel.py

@@ -5,13 +5,13 @@ from __future__ import annotations
 import asyncio
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Callable, Optional, Any
 from threading import Lock
+from typing import Any, Callable, Optional
 
 from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn
 
 console = Console()
 
@@ -34,29 +34,29 @@ def run_parallel(
 ) -> 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(),
@@ -66,11 +66,11 @@ def run_parallel(
                 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(
@@ -86,13 +86,13 @@ def run_parallel(
                             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(
@@ -108,7 +108,7 @@ def run_parallel(
                         duration=duration,
                         error=str(e),
                     )
-    
+
     return results
 
 
@@ -120,23 +120,23 @@ def run_in_dependency_waves(
 ) -> 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 = []
@@ -144,29 +144,29 @@ def run_in_dependency_waves(
             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
 
 
@@ -176,12 +176,12 @@ async def run_parallel_async(
 ) -> 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()
@@ -201,23 +201,23 @@ async def run_parallel_async(
                     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]],
@@ -225,22 +225,22 @@ class ParallelSandboxBuilder:
     ) -> 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,
@@ -253,16 +253,16 @@ 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/platform.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import re
+from typing import Literal, Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+SubdomainSeparator = Literal["-", "."]
+
+
+def coerce_subdomain_separator(value: Optional[str]) -> SubdomainSeparator:
+    return "." if value == "." else "-"
+
+
+def normalize_host(value: str) -> str:
+    v = (value or "").strip().lower()
+    if v.startswith("http://"):
+        v = v[len("http://") :]
+    elif v.startswith("https://"):
+        v = v[len("https://") :]
+    v = v.split("/", 1)[0]
+    v = v.split(":", 1)[0]
+    v = v.strip(".")
+    return v
+
+
+def normalize_domain(value: str) -> str:
+    v = normalize_host(value)
+    if v.startswith("www."):
+        v = v[len("www.") :]
+    return v
+
+
+def is_local_domain(domain: str) -> bool:
+    d = normalize_domain(domain)
+    return d in {"localhost", "127.0.0.1", "0.0.0.0"}
+
+
+def build_origin(*, scheme: Literal["http", "https"], host: str, port: Optional[int] = None) -> str:
+    h = normalize_host(host)
+    if port is None:
+        return f"{scheme}://{h}"
+    return f"{scheme}://{h}:{int(port)}"
+
+
+def web_base_url(domain: str, web_host_port: int) -> str:
+    if is_local_domain(domain):
+        return build_origin(scheme="http", host="localhost", port=int(web_host_port))
+    return build_origin(scheme="https", host=normalize_domain(domain))
+
+
+def api_base_url(domain: str, api_host_port: int) -> str:
+    if is_local_domain(domain):
+        return build_origin(scheme="http", host="localhost", port=int(api_host_port))
+    return build_origin(scheme="https", host=f"api.{normalize_domain(domain)}")
+
+
+def to_dns_label(value: str, *, max_len: int = 63, fallback: str = "x") -> str:
+    v = (value or "").lower().strip()
+    v = re.sub(r"[^a-z0-9]+", "-", v)
+    v = re.sub(r"-+", "-", v).strip("-")
+    if not v:
+        v = fallback
+    return v[:max_len]
+
+
+class DomainConfig(BaseModel):
+    domain: str = Field(default="localhost")
+    subdomain_separator: SubdomainSeparator = Field(default="-")
+
+    @field_validator("domain")
+    @classmethod
+    def _normalize_domain(cls, v: str) -> str:
+        out = normalize_domain(v)
+        if not out:
+            return "localhost"
+        return out
+
+    @field_validator("subdomain_separator")
+    @classmethod
+    def _normalize_separator(cls, v: str) -> SubdomainSeparator:
+        return coerce_subdomain_separator(v)
+
+
+class ProjectHostParts(BaseModel):
+    project_id: int
+    username: str
+
+
+_PROJECT_SUBDOMAIN_RE = re.compile(r"^(?P<project_id>\d+)(?:-|\.)(?P<username>[a-z0-9-]+)$")
+
+
+def parse_project_subdomain(subdomain: str) -> Optional[ProjectHostParts]:
+    s = (subdomain or "").strip().lower()
+    m = _PROJECT_SUBDOMAIN_RE.match(s)
+    if not m:
+        return None
+    try:
+        project_id = int(m.group("project_id"))
+    except Exception:
+        return None
+    username = m.group("username")
+    if not username:
+        return None
+    return ProjectHostParts(project_id=project_id, username=username)
+
+
+def build_project_subdomain(project_id: int, username: str, *, separator: SubdomainSeparator) -> str:
+    pid = int(project_id)
+    sep = coerce_subdomain_separator(separator)
+
+    prefix = f"{pid}{sep}"
+    max_username_len = max(1, 63 - len(prefix))
+    uname = to_dns_label(username, max_len=max_username_len, fallback="user")
+
+    return f"{pid}{sep}{uname}"
+
+
+def build_project_host(project_id: int, username: str, *, domain: str, separator: SubdomainSeparator) -> str:
+    base_domain = normalize_domain(domain)
+    sub = build_project_subdomain(project_id, username, separator=separator)
+    return f"{sub}.{base_domain}"
+
+
+def parse_project_host(host: str, *, domain: str) -> Optional[ProjectHostParts]:
+    h = normalize_host(host)
+    base_domain = normalize_domain(domain)
+    suffix = f".{base_domain}" if base_domain else ""
+
+    if not suffix or not h.endswith(suffix):
+        return None
+
+    subdomain = h[: -len(suffix)]
+    return parse_project_subdomain(subdomain)
+
+
+def build_service_subdomain(service_name: str, username: str, *, separator: SubdomainSeparator) -> str:
+    sep = coerce_subdomain_separator(separator)
+    service_label = to_dns_label(service_name, max_len=20, fallback="app")
+    tenant_label = to_dns_label(username, max_len=30, fallback="user")
+
+    if sep == ".":
+        return f"{service_label}.{tenant_label}".strip(".")
+
+    label = f"{service_label}-{tenant_label}".strip("-")
+    return label[:63].strip("-")

pactown/registry/__init__.py

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

pactown/registry/client.py

@@ -1,29 +1,28 @@
 """Client for pactown registry."""
 
 from pathlib import Path
-from typing import Optional, Any
-import hashlib
+from typing import Optional
 
 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:
@@ -31,10 +30,10 @@ class RegistryClient:
             return response.status_code == 200
         except Exception:
             return False
-    
+
     def list_artifacts(
-        self, 
-        namespace: Optional[str] = None, 
+        self,
+        namespace: Optional[str] = None,
         search: Optional[str] = None
     ) -> list[dict]:
         """List artifacts in the registry."""
@@ -43,11 +42,11 @@ class RegistryClient:
             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:
@@ -60,11 +59,11 @@ class RegistryClient:
             return response.json()
         except httpx.HTTPStatusError:
             return None
-    
+
     def get_version(
-        self, 
-        name: str, 
-        version: str = "latest", 
+        self,
+        name: str,
+        version: str = "latest",
         namespace: str = "default"
     ) -> Optional[dict]:
         """Get specific version information."""
@@ -78,11 +77,11 @@ class RegistryClient:
             return response.json()
         except httpx.HTTPStatusError:
             return None
-    
+
     def get_readme(
-        self, 
-        name: str, 
-        version: str = "latest", 
+        self,
+        name: str,
+        version: str = "latest",
         namespace: str = "default"
     ) -> Optional[str]:
         """Get README content for a specific version."""
@@ -96,7 +95,7 @@ class RegistryClient:
             return response.json().get("content")
         except httpx.HTTPStatusError:
             return None
-    
+
     def publish(
         self,
         name: str,
@@ -111,10 +110,10 @@ class RegistryClient:
         """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,
@@ -124,31 +123,31 @@ class RegistryClient:
             "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", 
+        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:
@@ -158,7 +157,7 @@ class RegistryClient:
             return response.status_code == 200
         except httpx.HTTPStatusError:
             return False
-    
+
     def list_namespaces(self) -> list[str]:
         """List all namespaces."""
         try:
@@ -171,30 +170,30 @@ class RegistryClient:
 
 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, 
+        self,
         namespace: Optional[str] = None,
         search: Optional[str] = None,
     ) -> list[dict]:
@@ -203,15 +202,15 @@ class AsyncRegistryClient:
             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", 
+        self,
+        name: str,
+        version: str = "latest",
         namespace: str = "default"
     ) -> Optional[str]:
         try:
@@ -224,7 +223,7 @@ class AsyncRegistryClient:
             return response.json().get("content")
         except httpx.HTTPStatusError:
             return None
-    
+
     async def publish(
         self,
         name: str,
@@ -244,7 +243,7 @@ class AsyncRegistryClient:
             "tags": tags or [],
             "metadata": metadata or {},
         }
-        
+
         try:
             response = await self._client.post(f"{self.base_url}/v1/publish", json=payload)
             response.raise_for_status()