adversarial-workflow 0.6.6__py3-none-any.whl → 0.9.0__py3-none-any.whl

adversarial_workflow/library/config.py

@@ -0,0 +1,81 @@
+"""Library configuration with env > file > defaults precedence."""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+@dataclass
+class LibraryConfig:
+    """Configuration for the evaluator library.
+
+    Precedence: environment variables > config file > defaults.
+    """
+
+    url: str = "https://raw.githubusercontent.com/movito/adversarial-evaluator-library/main"
+    ref: str = "main"
+    cache_ttl: int = 3600  # 1 hour
+    cache_dir: Path = field(default_factory=lambda: Path.home() / ".cache" / "adversarial-workflow")
+    enabled: bool = True
+
+
+def get_library_config(config_path: Optional[Path] = None) -> LibraryConfig:
+    """
+    Load library configuration with precedence: env > file > defaults.
+
+    Args:
+        config_path: Optional path to config file. Defaults to .adversarial/config.yml
+
+    Returns:
+        LibraryConfig with merged settings.
+    """
+    config = LibraryConfig()
+
+    # Load from config file if exists
+    config_file = config_path or Path(".adversarial/config.yml")
+    if config_file.exists():
+        try:
+            with open(config_file, "r", encoding="utf-8") as f:
+                data = yaml.safe_load(f) or {}
+            # Handle non-dict YAML (list, scalar, etc.) gracefully
+            if not isinstance(data, dict):
+                data = {}
+            lib_config = data.get("library", {})
+
+            if "url" in lib_config:
+                config.url = lib_config["url"]
+            if "ref" in lib_config:
+                config.ref = lib_config["ref"]
+            if "cache_ttl" in lib_config:
+                config.cache_ttl = int(lib_config["cache_ttl"])
+            if "cache_dir" in lib_config:
+                # Expand ~ in path
+                config.cache_dir = Path(lib_config["cache_dir"]).expanduser()
+            if "enabled" in lib_config:
+                config.enabled = bool(lib_config["enabled"])
+        except (yaml.YAMLError, OSError, ValueError):
+            # Config file is invalid, use defaults
+            pass
+
+    # Apply environment variable overrides (highest precedence)
+    if url := os.environ.get("ADVERSARIAL_LIBRARY_URL"):
+        config.url = url
+
+    # Process TTL first, then NO_CACHE (so NO_CACHE always wins)
+    if ttl := os.environ.get("ADVERSARIAL_LIBRARY_CACHE_TTL"):
+        try:
+            config.cache_ttl = int(ttl)
+        except ValueError:
+            pass  # Invalid TTL, keep current value
+
+    # NO_CACHE takes precedence over CACHE_TTL - check it last
+    if os.environ.get("ADVERSARIAL_LIBRARY_NO_CACHE"):
+        config.cache_ttl = 0
+
+    if ref := os.environ.get("ADVERSARIAL_LIBRARY_REF"):
+        config.ref = ref
+
+    return config

adversarial_workflow/library/models.py

@@ -0,0 +1,129 @@
+"""Data models for the evaluator library client."""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Dict, List, Optional
+
+
+@dataclass
+class EvaluatorEntry:
+    """An evaluator entry from the library index."""
+
+    name: str
+    provider: str
+    path: str
+    model: str
+    category: str
+    description: str
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "EvaluatorEntry":
+        """Create an EvaluatorEntry from a dictionary."""
+        return cls(
+            name=data["name"],
+            provider=data["provider"],
+            path=data["path"],
+            model=data["model"],
+            category=data["category"],
+            description=data["description"],
+        )
+
+    @property
+    def full_name(self) -> str:
+        """Return provider/name format."""
+        return f"{self.provider}/{self.name}"
+
+
+@dataclass
+class IndexData:
+    """Parsed library index data."""
+
+    version: str
+    evaluators: List[EvaluatorEntry]
+    categories: Dict[str, str]
+    fetched_at: Optional[datetime] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "IndexData":
+        """Create an IndexData from a dictionary."""
+        evaluators = [EvaluatorEntry.from_dict(e) for e in data.get("evaluators", [])]
+        return cls(
+            version=data.get("version", "unknown"),
+            evaluators=evaluators,
+            categories=data.get("categories", {}),
+            fetched_at=datetime.now(timezone.utc),
+        )
+
+    def get_evaluator(self, provider: str, name: str) -> Optional[EvaluatorEntry]:
+        """Find an evaluator by provider and name."""
+        for e in self.evaluators:
+            if e.provider == provider and e.name == name:
+                return e
+        return None
+
+    def filter_by_provider(self, provider: str) -> List[EvaluatorEntry]:
+        """Filter evaluators by provider."""
+        return [e for e in self.evaluators if e.provider == provider]
+
+    def filter_by_category(self, category: str) -> List[EvaluatorEntry]:
+        """Filter evaluators by category."""
+        return [e for e in self.evaluators if e.category == category]
+
+
+@dataclass
+class InstalledEvaluatorMeta:
+    """Metadata for an installed evaluator (from _meta block)."""
+
+    source: str
+    source_path: str
+    version: str
+    installed: str
+    file_path: Optional[str] = None  # Path to the installed file
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> Optional["InstalledEvaluatorMeta"]:
+        """Create from _meta dictionary, returns None if invalid."""
+        if not data:
+            return None
+        try:
+            return cls(
+                source=data.get("source", ""),
+                source_path=data.get("source_path", ""),
+                version=data.get("version", ""),
+                installed=data.get("installed", ""),
+            )
+        except (KeyError, TypeError):
+            return None
+
+    @property
+    def provider(self) -> str:
+        """Extract provider from source_path."""
+        parts = self.source_path.split("/")
+        return parts[0] if parts else ""
+
+    @property
+    def name(self) -> str:
+        """Extract name from source_path."""
+        parts = self.source_path.split("/")
+        return parts[1] if len(parts) > 1 else ""
+
+
+@dataclass
+class UpdateInfo:
+    """Information about an available update."""
+
+    name: str
+    installed_version: str
+    available_version: str
+    is_outdated: bool
+    is_local_only: bool = False
+
+    @property
+    def status(self) -> str:
+        """Human-readable status."""
+        if self.is_local_only:
+            return "Local only"
+        elif self.is_outdated:
+            return "Update available"
+        else:
+            return "Up to date"