tapps-agents 3.5.40__py3-none-any.whl → 3.6.0__py3-none-any.whl

tapps_agents/experts/domain_utils.py

@@ -1,84 +1,84 @@
-"""
-Utility functions for domain name handling.
-"""
-
-import re
-from urllib.parse import urlparse
-
-
-# Known domain-to-directory name mappings for built-in experts
-# Maps expert domain names to their actual knowledge base directory names
-# This handles cases where domain names don't match directory names
-DOMAIN_TO_DIRECTORY_MAP = {
-    "performance-optimization": "performance",
-    "ai-agent-framework": "ai-frameworks",
-    "testing-strategies": "testing",
-}
-
-
-def sanitize_domain_for_path(domain: str) -> str:
-    """
-    Sanitize a domain name or URL for use as a directory path.
-
-    Handles URLs by extracting the hostname and path, then sanitizing
-    invalid filename characters. This ensures cross-platform compatibility.
-    
-    Also handles known domain-to-directory name mappings for built-in experts.
-
-    Args:
-        domain: Domain name or URL (e.g., "home-automation" or "https://www.home-assistant.io/docs/")
-
-    Returns:
-        Sanitized string safe for use as a directory name
-
-    Examples:
-        >>> sanitize_domain_for_path("home-automation")
-        'home-automation'
-        >>> sanitize_domain_for_path("https://www.home-assistant.io/docs/")
-        'home-assistant.io-docs'
-        >>> sanitize_domain_for_path("https://example.com/api/v1")
-        'example.com-api-v1'
-        >>> sanitize_domain_for_path("performance-optimization")
-        'performance'
-    """
-    if not domain:
-        return "unknown"
-
-    # Check for known domain-to-directory mappings first (built-in experts)
-    if domain in DOMAIN_TO_DIRECTORY_MAP:
-        return DOMAIN_TO_DIRECTORY_MAP[domain]
-
-    # Try to parse as URL
-    try:
-        parsed = urlparse(domain)
-        if parsed.netloc:  # Has a hostname, it's a URL
-            # Extract hostname and path
-            parts = [parsed.netloc.replace("www.", "")]
-            if parsed.path and parsed.path != "/":
-                # Add path segments, removing leading/trailing slashes
-                path_parts = [p for p in parsed.path.strip("/").split("/") if p]
-                parts.extend(path_parts)
-            domain = "-".join(parts)
-    except Exception:
-        # Not a valid URL, use as-is
-        pass
-
-    # Replace invalid filename characters with hyphens
-    # Windows invalid chars: < > : " / \ | ? *
-    # Also replace spaces, ampersands, and other problematic chars
-    sanitized = re.sub(r'[<>:"/\\|?*\s&]+', '-', domain)
-
-    # Remove leading/trailing dots and hyphens (Windows doesn't allow these)
-    sanitized = sanitized.strip('.-')
-
-    # Replace multiple consecutive hyphens with single hyphen
-    sanitized = re.sub(r'-+', '-', sanitized)
-
-    # Ensure it's not empty and not too long (Windows path limit)
-    if not sanitized:
-        sanitized = "unknown"
-    elif len(sanitized) > 200:  # Reasonable limit for directory names
-        sanitized = sanitized[:200].rstrip('-')
-
-    return sanitized.lower()
-
+"""
+Utility functions for domain name handling.
+"""
+
+import re
+from urllib.parse import urlparse
+
+
+# Known domain-to-directory name mappings for built-in experts
+# Maps expert domain names to their actual knowledge base directory names
+# This handles cases where domain names don't match directory names
+DOMAIN_TO_DIRECTORY_MAP = {
+    "performance-optimization": "performance",
+    "ai-agent-framework": "ai-frameworks",
+    "testing-strategies": "testing",
+}
+
+
+def sanitize_domain_for_path(domain: str) -> str:
+    """
+    Sanitize a domain name or URL for use as a directory path.
+
+    Handles URLs by extracting the hostname and path, then sanitizing
+    invalid filename characters. This ensures cross-platform compatibility.
+    
+    Also handles known domain-to-directory name mappings for built-in experts.
+
+    Args:
+        domain: Domain name or URL (e.g., "home-automation" or "https://www.home-assistant.io/docs/")
+
+    Returns:
+        Sanitized string safe for use as a directory name
+
+    Examples:
+        >>> sanitize_domain_for_path("home-automation")
+        'home-automation'
+        >>> sanitize_domain_for_path("https://www.home-assistant.io/docs/")
+        'home-assistant.io-docs'
+        >>> sanitize_domain_for_path("https://example.com/api/v1")
+        'example.com-api-v1'
+        >>> sanitize_domain_for_path("performance-optimization")
+        'performance'
+    """
+    if not domain:
+        return "unknown"
+
+    # Check for known domain-to-directory mappings first (built-in experts)
+    if domain in DOMAIN_TO_DIRECTORY_MAP:
+        return DOMAIN_TO_DIRECTORY_MAP[domain]
+
+    # Try to parse as URL
+    try:
+        parsed = urlparse(domain)
+        if parsed.netloc:  # Has a hostname, it's a URL
+            # Extract hostname and path
+            parts = [parsed.netloc.replace("www.", "")]
+            if parsed.path and parsed.path != "/":
+                # Add path segments, removing leading/trailing slashes
+                path_parts = [p for p in parsed.path.strip("/").split("/") if p]
+                parts.extend(path_parts)
+            domain = "-".join(parts)
+    except Exception:
+        # Not a valid URL, use as-is
+        pass
+
+    # Replace invalid filename characters with hyphens
+    # Windows invalid chars: < > : " / \ | ? *
+    # Also replace spaces, ampersands, and other problematic chars
+    sanitized = re.sub(r'[<>:"/\\|?*\s&]+', '-', domain)
+
+    # Remove leading/trailing dots and hyphens (Windows doesn't allow these)
+    sanitized = sanitized.strip('.-')
+
+    # Replace multiple consecutive hyphens with single hyphen
+    sanitized = re.sub(r'-+', '-', sanitized)
+
+    # Ensure it's not empty and not too long (Windows path limit)
+    if not sanitized:
+        sanitized = "unknown"
+    elif len(sanitized) > 200:  # Reasonable limit for directory names
+        sanitized = sanitized[:200].rstrip('-')
+
+    return sanitized.lower()
+

tapps_agents/experts/expert_config.py

@@ -1,113 +1,113 @@
-"""
-Expert Configuration System
-
-Provides configuration models and loaders for defining experts via YAML files.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any
-
-import yaml
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class ExpertConfigModel(BaseModel):
-    """
-    Pydantic model for expert configuration.
-
-    Experts are defined in YAML configuration files and instantiated
-    automatically by the ExpertRegistry.
-    """
-
-    model_config = ConfigDict(extra="forbid")  # Don't allow extra fields
-
-    expert_id: str = Field(
-        ..., description="Unique expert identifier (e.g., 'expert-home-automation')"
-    )
-    expert_name: str = Field(..., description="Human-readable expert name")
-    primary_domain: str = Field(
-        ..., description="Domain where this expert has 51% authority"
-    )
-    rag_enabled: bool = Field(
-        default=False, description="Enable RAG for knowledge retrieval"
-    )
-    fine_tuned: bool = Field(
-        default=False, description="Use fine-tuned models (future)"
-    )
-    confidence_matrix: dict[str, float] | None = Field(
-        default=None,
-        description="Custom confidence weights per domain (usually auto-calculated from weight matrix)",
-    )
-
-
-@dataclass
-class ExpertsConfig:
-    """Container for multiple expert configurations."""
-
-    experts: list[ExpertConfigModel] = field(default_factory=list)
-
-    @classmethod
-    def from_yaml(cls, yaml_file: Path) -> ExpertsConfig:
-        """
-        Load expert configurations from YAML file.
-
-        Args:
-            yaml_file: Path to experts.yaml file
-
-        Returns:
-            ExpertsConfig instance
-
-        Raises:
-            FileNotFoundError: If file doesn't exist
-            ValueError: If YAML is invalid or missing required fields
-        """
-        if not yaml_file.exists():
-            raise FileNotFoundError(f"Expert configuration file not found: {yaml_file}")
-
-        try:
-            with open(yaml_file, encoding="utf-8") as f:
-                data = yaml.safe_load(f)
-        except yaml.YAMLError as e:
-            raise ValueError(f"Invalid YAML in {yaml_file}: {e}") from e
-
-        if not isinstance(data, dict):
-            raise ValueError(f"Expected dict at root level, got {type(data).__name__}")
-
-        if "experts" not in data:
-            raise ValueError(f"Missing 'experts' key in {yaml_file}")
-
-        if not isinstance(data["experts"], list):
-            raise ValueError(
-                f"Expected 'experts' to be a list, got {type(data['experts']).__name__}"
-            )
-
-        expert_configs = []
-        for idx, expert_data in enumerate(data["experts"]):
-            try:
-                expert_config = ExpertConfigModel(**expert_data)
-                expert_configs.append(expert_config)
-            except Exception as e:
-                raise ValueError(
-                    f"Invalid expert configuration at index {idx} in {yaml_file}: {e}"
-                ) from e
-
-        return cls(experts=expert_configs)
-
-
-def load_expert_configs(config_file: Path) -> list[ExpertConfigModel]:
-    """
-    Load expert configurations from YAML file.
-
-    Convenience function that returns just the list of expert configs.
-
-    Args:
-        config_file: Path to experts.yaml file
-
-    Returns:
-        List of ExpertConfigModel instances
-    """
-    experts_config = ExpertsConfig.from_yaml(config_file)
-    return experts_config.experts
+"""
+Expert Configuration System
+
+Provides configuration models and loaders for defining experts via YAML files.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ExpertConfigModel(BaseModel):
+    """
+    Pydantic model for expert configuration.
+
+    Experts are defined in YAML configuration files and instantiated
+    automatically by the ExpertRegistry.
+    """
+
+    model_config = ConfigDict(extra="forbid")  # Don't allow extra fields
+
+    expert_id: str = Field(
+        ..., description="Unique expert identifier (e.g., 'expert-home-automation')"
+    )
+    expert_name: str = Field(..., description="Human-readable expert name")
+    primary_domain: str = Field(
+        ..., description="Domain where this expert has 51% authority"
+    )
+    rag_enabled: bool = Field(
+        default=False, description="Enable RAG for knowledge retrieval"
+    )
+    fine_tuned: bool = Field(
+        default=False, description="Use fine-tuned models (future)"
+    )
+    confidence_matrix: dict[str, float] | None = Field(
+        default=None,
+        description="Custom confidence weights per domain (usually auto-calculated from weight matrix)",
+    )
+
+
+@dataclass
+class ExpertsConfig:
+    """Container for multiple expert configurations."""
+
+    experts: list[ExpertConfigModel] = field(default_factory=list)
+
+    @classmethod
+    def from_yaml(cls, yaml_file: Path) -> ExpertsConfig:
+        """
+        Load expert configurations from YAML file.
+
+        Args:
+            yaml_file: Path to experts.yaml file
+
+        Returns:
+            ExpertsConfig instance
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            ValueError: If YAML is invalid or missing required fields
+        """
+        if not yaml_file.exists():
+            raise FileNotFoundError(f"Expert configuration file not found: {yaml_file}")
+
+        try:
+            with open(yaml_file, encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML in {yaml_file}: {e}") from e
+
+        if not isinstance(data, dict):
+            raise ValueError(f"Expected dict at root level, got {type(data).__name__}")
+
+        if "experts" not in data:
+            raise ValueError(f"Missing 'experts' key in {yaml_file}")
+
+        if not isinstance(data["experts"], list):
+            raise ValueError(
+                f"Expected 'experts' to be a list, got {type(data['experts']).__name__}"
+            )
+
+        expert_configs = []
+        for idx, expert_data in enumerate(data["experts"]):
+            try:
+                expert_config = ExpertConfigModel(**expert_data)
+                expert_configs.append(expert_config)
+            except Exception as e:
+                raise ValueError(
+                    f"Invalid expert configuration at index {idx} in {yaml_file}: {e}"
+                ) from e
+
+        return cls(experts=expert_configs)
+
+
+def load_expert_configs(config_file: Path) -> list[ExpertConfigModel]:
+    """
+    Load expert configurations from YAML file.
+
+    Convenience function that returns just the list of expert configs.
+
+    Args:
+        config_file: Path to experts.yaml file
+
+    Returns:
+        List of ExpertConfigModel instances
+    """
+    experts_config = ExpertsConfig.from_yaml(config_file)
+    return experts_config.experts