jaf-py 2.5.10__py3-none-any.whl → 2.5.11__py3-none-any.whl

jaf/core/performance.py

@@ -18,6 +18,7 @@ from .types import TraceEvent, RunId, TraceId
 @dataclass(frozen=True)
 class PerformanceMetrics:
     """Comprehensive performance metrics for agent execution."""
+
     execution_time_ms: float
     memory_usage_mb: float
     peak_memory_mb: float
@@ -27,27 +28,30 @@ class PerformanceMetrics:
     tool_call_count: int
     error_count: int
     retry_count: int
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert metrics to dictionary for serialization."""
         return {
-            'execution_time_ms': self.execution_time_ms,
-            'memory_usage_mb': self.memory_usage_mb,
-            'peak_memory_mb': self.peak_memory_mb,
-            'token_count': self.token_count,
-            'cache_hit_rate': self.cache_hit_rate,
-            'llm_call_count': self.llm_call_count,
-            'tool_call_count': self.tool_call_count,
-            'error_count': self.error_count,
-            'retry_count': self.retry_count
+            "execution_time_ms": self.execution_time_ms,
+            "memory_usage_mb": self.memory_usage_mb,
+            "peak_memory_mb": self.peak_memory_mb,
+            "token_count": self.token_count,
+            "cache_hit_rate": self.cache_hit_rate,
+            "llm_call_count": self.llm_call_count,
+            "tool_call_count": self.tool_call_count,
+            "error_count": self.error_count,
+            "retry_count": self.retry_count,
         }
 
 
 @dataclass(frozen=True)
 class PerformanceEvent:
     """Performance-related trace event."""
-    type: str = 'performance_metrics'
-    data: PerformanceMetrics = field(default_factory=lambda: PerformanceMetrics(0, 0, 0, 0, 0, 0, 0, 0, 0))
+
+    type: str = "performance_metrics"
+    data: PerformanceMetrics = field(
+        default_factory=lambda: PerformanceMetrics(0, 0, 0, 0, 0, 0, 0, 0, 0)
+    )
     timestamp: float = field(default_factory=time.time)
     run_id: Optional[RunId] = None
     trace_id: Optional[TraceId] = None
@@ -56,10 +60,10 @@ class PerformanceEvent:
 class PerformanceMonitor:
     """
     Performance monitoring system for JAF agents.
-    
+
     Tracks execution metrics, memory usage, and provides performance insights.
     """
-    
+
     def __init__(self):
         self.start_time: Optional[float] = None
         self.start_memory: Optional[float] = None
@@ -72,22 +76,22 @@ class PerformanceMonitor:
         self.errors: int = 0
         self.retries: int = 0
         self.process = psutil.Process()
-    
+
     def start_monitoring(self) -> None:
         """Start performance monitoring."""
         self.start_time = time.time()
         self.start_memory = self._get_memory_usage()
         self.peak_memory = self.start_memory
-    
+
     def stop_monitoring(self) -> PerformanceMetrics:
         """Stop monitoring and return collected metrics."""
         if self.start_time is None:
             raise ValueError("Monitoring not started")
-        
+
         execution_time = (time.time() - self.start_time) * 1000  # Convert to ms
         current_memory = self._get_memory_usage()
         cache_hit_rate = self._calculate_cache_hit_rate()
-        
+
         return PerformanceMetrics(
             execution_time_ms=execution_time,
             memory_usage_mb=current_memory,
@@ -97,36 +101,36 @@ class PerformanceMonitor:
             llm_call_count=self.llm_calls,
             tool_call_count=self.tool_calls,
             error_count=self.errors,
-            retry_count=self.retries
+            retry_count=self.retries,
         )
-    
+
     def record_llm_call(self, token_count: int = 0) -> None:
         """Record an LLM call with optional token count."""
         self.llm_calls += 1
         self.token_count += token_count
         self._update_peak_memory()
-    
+
     def record_tool_call(self) -> None:
         """Record a tool call."""
         self.tool_calls += 1
         self._update_peak_memory()
-    
+
     def record_cache_hit(self) -> None:
         """Record a cache hit."""
         self.cache_hits += 1
-    
+
     def record_cache_miss(self) -> None:
         """Record a cache miss."""
         self.cache_misses += 1
-    
+
     def record_error(self) -> None:
         """Record an error occurrence."""
         self.errors += 1
-    
+
     def record_retry(self) -> None:
         """Record a retry attempt."""
         self.retries += 1
-    
+
     def _get_memory_usage(self) -> float:
         """Get current memory usage in MB."""
         try:
@@ -134,13 +138,13 @@ class PerformanceMonitor:
             return memory_info.rss / 1024 / 1024  # Convert bytes to MB
         except (psutil.NoSuchProcess, psutil.AccessDenied):
             return 0.0
-    
+
     def _update_peak_memory(self) -> None:
         """Update peak memory usage."""
         current_memory = self._get_memory_usage()
         if current_memory > self.peak_memory:
             self.peak_memory = current_memory
-    
+
     def _calculate_cache_hit_rate(self) -> float:
         """Calculate cache hit rate as a percentage."""
         total_cache_operations = self.cache_hits + self.cache_misses
@@ -153,11 +157,11 @@ class PerformanceMonitor:
 async def monitor_performance(
     run_id: Optional[RunId] = None,
     trace_id: Optional[TraceId] = None,
-    on_complete: Optional[Callable[[PerformanceMetrics], None]] = None
+    on_complete: Optional[Callable[[PerformanceMetrics], None]] = None,
 ) -> AsyncIterator[PerformanceMonitor]:
     """
     Context manager for performance monitoring.
-    
+
     Usage:
         async with monitor_performance() as monitor:
             monitor.record_llm_call(150)  # 150 tokens
@@ -165,50 +169,46 @@ async def monitor_performance(
     """
     monitor = PerformanceMonitor()
     monitor.start_monitoring()
-    
+
     try:
         yield monitor
     finally:
         metrics = monitor.stop_monitoring()
-        
+
         if on_complete:
             on_complete(metrics)
-        
+
         # Emit performance event
-        event = PerformanceEvent(
-            data=metrics,
-            run_id=run_id,
-            trace_id=trace_id
-        )
+        event = PerformanceEvent(data=metrics, run_id=run_id, trace_id=trace_id)
 
 
 class PerformanceCollector:
     """
     Collects and aggregates performance metrics across multiple runs.
     """
-    
+
     def __init__(self):
         self.metrics_history: List[PerformanceMetrics] = []
         self.run_metrics: Dict[str, PerformanceMetrics] = {}
-    
+
     def collect_metrics(self, metrics: PerformanceMetrics, run_id: Optional[str] = None) -> None:
         """Collect performance metrics from a run."""
         self.metrics_history.append(metrics)
         if run_id:
             self.run_metrics[run_id] = metrics
-    
+
     def get_average_metrics(self, last_n: Optional[int] = None) -> Optional[PerformanceMetrics]:
         """Get average metrics across runs."""
         if not self.metrics_history:
             return None
-        
+
         metrics_to_analyze = self.metrics_history[-last_n:] if last_n else self.metrics_history
-        
+
         if not metrics_to_analyze:
             return None
-        
+
         count = len(metrics_to_analyze)
-        
+
         return PerformanceMetrics(
             execution_time_ms=sum(m.execution_time_ms for m in metrics_to_analyze) / count,
             memory_usage_mb=sum(m.memory_usage_mb for m in metrics_to_analyze) / count,
@@ -218,52 +218,54 @@ class PerformanceCollector:
             llm_call_count=sum(m.llm_call_count for m in metrics_to_analyze) / count,
             tool_call_count=sum(m.tool_call_count for m in metrics_to_analyze) / count,
             error_count=sum(m.error_count for m in metrics_to_analyze) / count,
-            retry_count=sum(m.retry_count for m in metrics_to_analyze) / count
+            retry_count=sum(m.retry_count for m in metrics_to_analyze) / count,
         )
-    
+
     def get_performance_summary(self) -> Dict[str, Any]:
         """Get comprehensive performance summary."""
         if not self.metrics_history:
-            return {'status': 'no_data'}
-        
+            return {"status": "no_data"}
+
         recent_metrics = self.get_average_metrics(last_n=10)
         all_time_metrics = self.get_average_metrics()
-        
+
         return {
-            'total_runs': len(self.metrics_history),
-            'recent_average': recent_metrics.to_dict() if recent_metrics else None,
-            'all_time_average': all_time_metrics.to_dict() if all_time_metrics else None,
-            'performance_trends': self._analyze_trends()
+            "total_runs": len(self.metrics_history),
+            "recent_average": recent_metrics.to_dict() if recent_metrics else None,
+            "all_time_average": all_time_metrics.to_dict() if all_time_metrics else None,
+            "performance_trends": self._analyze_trends(),
         }
-    
+
     def _analyze_trends(self) -> Dict[str, str]:
         """Analyze performance trends."""
         if len(self.metrics_history) < 2:
-            return {'status': 'insufficient_data'}
-        
-        recent = self.metrics_history[-5:] if len(self.metrics_history) >= 5 else self.metrics_history
+            return {"status": "insufficient_data"}
+
+        recent = (
+            self.metrics_history[-5:] if len(self.metrics_history) >= 5 else self.metrics_history
+        )
         older = self.metrics_history[:-5] if len(self.metrics_history) >= 10 else []
-        
+
         if not older:
-            return {'status': 'insufficient_historical_data'}
-        
+            return {"status": "insufficient_historical_data"}
+
         recent_avg_time = sum(m.execution_time_ms for m in recent) / len(recent)
         older_avg_time = sum(m.execution_time_ms for m in older) / len(older)
-        
-        time_trend = 'improving' if recent_avg_time < older_avg_time else 'degrading'
-        
+
+        time_trend = "improving" if recent_avg_time < older_avg_time else "degrading"
+
         recent_avg_memory = sum(m.memory_usage_mb for m in recent) / len(recent)
         older_avg_memory = sum(m.memory_usage_mb for m in older) / len(older)
-        
-        memory_trend = 'improving' if recent_avg_memory < older_avg_memory else 'degrading'
-        
+
+        memory_trend = "improving" if recent_avg_memory < older_avg_memory else "degrading"
+
         return {
-            'execution_time_trend': time_trend,
-            'memory_usage_trend': memory_trend,
-            'recent_avg_time_ms': recent_avg_time,
-            'older_avg_time_ms': older_avg_time,
-            'recent_avg_memory_mb': recent_avg_memory,
-            'older_avg_memory_mb': older_avg_memory
+            "execution_time_trend": time_trend,
+            "memory_usage_trend": memory_trend,
+            "recent_avg_time_ms": recent_avg_time,
+            "older_avg_time_ms": older_avg_time,
+            "recent_avg_memory_mb": recent_avg_memory,
+            "older_avg_memory_mb": older_avg_memory,
         }
 
 

jaf/core/proxy.py

@@ -14,6 +14,7 @@ from urllib.parse import urlparse
 @dataclass
 class ProxyAuth:
     """Proxy authentication configuration."""
+
     username: str
     password: str
 
@@ -21,100 +22,98 @@ class ProxyAuth:
 @dataclass
 class ProxyConfig:
     """Proxy configuration for HTTP clients."""
+
     http_proxy: Optional[str] = None
     https_proxy: Optional[str] = None
     no_proxy: Optional[str] = None
     auth: Optional[ProxyAuth] = None
-    
+
     @classmethod
-    def from_environment(cls) -> 'ProxyConfig':
+    def from_environment(cls) -> "ProxyConfig":
         """Create proxy configuration from environment variables."""
         return cls(
-            http_proxy=os.getenv('HTTP_PROXY') or os.getenv('http_proxy'),
-            https_proxy=os.getenv('HTTPS_PROXY') or os.getenv('https_proxy'),
-            no_proxy=os.getenv('NO_PROXY') or os.getenv('no_proxy'),
+            http_proxy=os.getenv("HTTP_PROXY") or os.getenv("http_proxy"),
+            https_proxy=os.getenv("HTTPS_PROXY") or os.getenv("https_proxy"),
+            no_proxy=os.getenv("NO_PROXY") or os.getenv("no_proxy"),
             auth=ProxyAuth(
-                username=os.getenv('PROXY_USERNAME', ''),
-                password=os.getenv('PROXY_PASSWORD', '')
-            ) if os.getenv('PROXY_USERNAME') else None
+                username=os.getenv("PROXY_USERNAME", ""), password=os.getenv("PROXY_PASSWORD", "")
+            )
+            if os.getenv("PROXY_USERNAME")
+            else None,
         )
-    
+
     @classmethod
-    def from_url(cls, proxy_url: str, auth: Optional[ProxyAuth] = None) -> 'ProxyConfig':
+    def from_url(cls, proxy_url: str, auth: Optional[ProxyAuth] = None) -> "ProxyConfig":
         """Create proxy configuration from a single URL."""
-        return cls(
-            http_proxy=proxy_url,
-            https_proxy=proxy_url,
-            auth=auth
-        )
-    
+        return cls(http_proxy=proxy_url, https_proxy=proxy_url, auth=auth)
+
     def to_httpx_proxies(self) -> Optional[Dict[str, str]]:
         """Convert to httpx proxies format."""
         if not self.http_proxy and not self.https_proxy:
             return None
-        
+
         proxies = {}
-        
+
         if self.http_proxy:
-            proxies['http://'] = self._add_auth_to_url(self.http_proxy)
-        
+            proxies["http://"] = self._add_auth_to_url(self.http_proxy)
+
         if self.https_proxy:
-            proxies['https://'] = self._add_auth_to_url(self.https_proxy)
-        
+            proxies["https://"] = self._add_auth_to_url(self.https_proxy)
+
         return proxies if proxies else None
-    
+
     def to_openai_proxies(self) -> Optional[Dict[str, str]]:
         """Convert to OpenAI client proxies format."""
         # OpenAI client supports httpx-style proxy configuration
         return self.to_httpx_proxies()
-    
+
     def _add_auth_to_url(self, url: str) -> str:
         """Add authentication to proxy URL if configured."""
         if not self.auth or not self.auth.username:
             return url
-        
+
         parsed = urlparse(url)
-        
+
         # If URL already has auth, don't override
-        if '@' in parsed.netloc:
+        if "@" in parsed.netloc:
             return url
-        
+
         auth_string = f"{self.auth.username}:{self.auth.password}"
-        
+
         # Reconstruct URL with auth
         if parsed.port:
             netloc = f"{auth_string}@{parsed.hostname}:{parsed.port}"
         else:
             netloc = f"{auth_string}@{parsed.hostname}"
-        
+
         return f"{parsed.scheme}://{netloc}{parsed.path}"
-    
+
     def should_bypass_proxy(self, host: str) -> bool:
         """Check if a host should bypass the proxy based on no_proxy settings."""
         if not self.no_proxy:
             return False
-        
-        no_proxy_hosts = [h.strip() for h in self.no_proxy.split(',')]
-        
+
+        no_proxy_hosts = [h.strip() for h in self.no_proxy.split(",")]
+
         for no_proxy_host in no_proxy_hosts:
             if not no_proxy_host:
                 continue
-            
+
             # Exact match
             if host == no_proxy_host:
                 return True
-            
+
             # Wildcard match (e.g., *.example.com)
-            if no_proxy_host.startswith('*'):
+            if no_proxy_host.startswith("*"):
                 suffix = no_proxy_host[1:]
                 if host.endswith(suffix):
                     return True
-            
+
             # Domain suffix match
-            if no_proxy_host.startswith('.'):
+            if no_proxy_host.startswith("."):
                 if host.endswith(no_proxy_host) or host == no_proxy_host[1:]:
                     return True
-        
+
         return False
 
 
@@ -122,20 +121,20 @@ def create_proxy_config(
     proxy_url: Optional[str] = None,
     username: Optional[str] = None,
     password: Optional[str] = None,
-    no_proxy: Optional[str] = None
+    no_proxy: Optional[str] = None,
 ) -> ProxyConfig:
     """Create a proxy configuration with optional parameters."""
     auth = ProxyAuth(username, password) if username else None
-    
+
     if proxy_url:
         config = ProxyConfig.from_url(proxy_url, auth)
         if no_proxy:
             config.no_proxy = no_proxy
         return config
-    
+
     return ProxyConfig.from_environment()
 
 
 def get_default_proxy_config() -> ProxyConfig:
     """Get the default proxy configuration from environment variables."""
-    return ProxyConfig.from_environment()
+    return ProxyConfig.from_environment()

jaf/core/proxy_helpers.py

@@ -17,11 +17,11 @@ def make_proxy_enabled_litellm_provider(
     proxy_url: Optional[str] = None,
     proxy_username: Optional[str] = None,
     proxy_password: Optional[str] = None,
-    use_env_proxy: bool = True
+    use_env_proxy: bool = True,
 ):
     """
     Create a LiteLLM provider with proxy support.
-    
+
     Args:
         base_url: Base URL for the LiteLLM server
         api_key: API key (defaults to "anything" for local servers)
@@ -30,19 +30,18 @@ def make_proxy_enabled_litellm_provider(
         proxy_username: Proxy username for authentication
         proxy_password: Proxy password for authentication
         use_env_proxy: Whether to use proxy settings from environment variables
-        
+
     Returns:
         ModelProvider with proxy configuration
     """
     proxy_config = None
-    
+
     if proxy_url:
         # Use explicitly provided proxy settings
         from .proxy import ProxyAuth, create_proxy_config
+
         proxy_config = create_proxy_config(
-            proxy_url=proxy_url,
-            username=proxy_username,
-            password=proxy_password
+            proxy_url=proxy_url, username=proxy_username, password=proxy_password
         )
     elif use_env_proxy:
         # Use environment-based proxy settings
@@ -50,61 +49,59 @@ def make_proxy_enabled_litellm_provider(
         # Only use proxy if actually configured in environment
         if not proxy_config.http_proxy and not proxy_config.https_proxy:
             proxy_config = None
-    
+
     return make_litellm_provider(
         base_url=base_url,
         api_key=api_key,
         default_timeout=default_timeout,
-        proxy_config=proxy_config
+        proxy_config=proxy_config,
     )
 
 
-
-
 def get_proxy_info() -> Dict[str, Any]:
     """
     Get information about current proxy configuration from environment.
-    
+
     Returns:
         Dictionary with proxy configuration details
     """
     proxy_config = get_default_proxy_config()
-    
+
     return {
         "http_proxy": proxy_config.http_proxy,
         "https_proxy": proxy_config.https_proxy,
         "no_proxy": proxy_config.no_proxy,
         "has_auth": proxy_config.auth is not None,
         "auth_username": proxy_config.auth.username if proxy_config.auth else None,
-        "is_configured": bool(proxy_config.http_proxy or proxy_config.https_proxy)
+        "is_configured": bool(proxy_config.http_proxy or proxy_config.https_proxy),
     }
 
 
 def validate_proxy_config(proxy_config: ProxyConfig) -> Dict[str, Any]:
     """
     Validate proxy configuration and return validation results.
-    
+
     Args:
         proxy_config: Proxy configuration to validate
-        
+
     Returns:
         Dictionary with validation results
     """
-    results = {
-        "valid": True,
-        "warnings": [],
-        "errors": []
-    }
-    
+    results = {"valid": True, "warnings": [], "errors": []}
+
     # Check if at least one proxy is configured
     if not proxy_config.http_proxy and not proxy_config.https_proxy:
         results["warnings"].append("No proxy URLs configured")
-    
+
     # Validate proxy URLs if configured
-    for proxy_type, proxy_url in [("HTTP", proxy_config.http_proxy), ("HTTPS", proxy_config.https_proxy)]:
+    for proxy_type, proxy_url in [
+        ("HTTP", proxy_config.http_proxy),
+        ("HTTPS", proxy_config.https_proxy),
+    ]:
         if proxy_url:
             try:
                 from urllib.parse import urlparse
+
                 parsed = urlparse(proxy_url)
                 if not parsed.scheme:
                     results["errors"].append(f"{proxy_type} proxy URL missing scheme: {proxy_url}")
@@ -115,12 +112,12 @@ def validate_proxy_config(proxy_config: ProxyConfig) -> Dict[str, Any]:
             except Exception as e:
                 results["errors"].append(f"Invalid {proxy_type} proxy URL: {e}")
                 results["valid"] = False
-    
+
     # Check authentication consistency
     if proxy_config.auth:
         if not proxy_config.auth.username:
             results["warnings"].append("Proxy authentication configured but username is empty")
         if not proxy_config.auth.password:
             results["warnings"].append("Proxy authentication configured but password is empty")
-    
-    return results
+
+    return results