loom-agent 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

loom/core/context_assembly.py

@@ -10,8 +10,9 @@ overwritten by system prompts.
 
 from __future__ import annotations
 
+import hashlib
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Callable
+from typing import Dict, List, Optional, Callable, Any
 from enum import IntEnum
 
 
@@ -56,6 +57,9 @@ class ContextAssembler:
     - Token budget management
     - Smart truncation of low-priority components
     - Guarantee high-priority component integrity
+    - Component caching for performance
+    - Dynamic priority adjustment
+    - Context reuse optimization
 
     Example:
         ```python
@@ -85,7 +89,9 @@ class ContextAssembler:
         self,
         max_tokens: int = 16000,
         token_counter: Optional[Callable[[str], int]] = None,
-        token_buffer: float = 0.9  # Use 90% of budget for safety
+        token_buffer: float = 0.9,  # Use 90% of budget for safety
+        enable_caching: bool = True,
+        cache_size: int = 100
     ):
         """
         Initialize the context assembler.
@@ -94,10 +100,19 @@ class ContextAssembler:
             max_tokens: Maximum token budget
             token_counter: Custom token counting function (defaults to simple estimation)
             token_buffer: Safety buffer ratio (0.9 = use 90% of max_tokens)
+            enable_caching: Enable component caching for performance
+            cache_size: Maximum number of cached components
         """
         self.max_tokens = int(max_tokens * token_buffer)
         self.token_counter = token_counter or self._estimate_tokens
         self.components: List[ContextComponent] = []
+        
+        # Performance optimizations
+        self.enable_caching = enable_caching
+        self._component_cache: Dict[str, ContextComponent] = {}
+        self._cache_size = cache_size
+        self._assembly_cache: Optional[str] = None
+        self._last_components_hash: Optional[str] = None
 
     def add_component(
         self,
@@ -127,16 +142,26 @@ class ContextAssembler:
             truncatable=truncatable
         )
         self.components.append(component)
+        
+        # Update cache if enabled
+        if self.enable_caching:
+            self._component_cache[name] = component
+            # Maintain cache size limit
+            if len(self._component_cache) > self._cache_size:
+                # Remove oldest entries (simple LRU)
+                oldest_key = next(iter(self._component_cache))
+                del self._component_cache[oldest_key]
 
     def assemble(self) -> str:
         """
         Assemble the final context from all components.
 
         Strategy:
-        1. Sort components by priority (descending)
-        2. Add components until budget is reached
-        3. Truncate low-priority components if needed
-        4. Merge all components into final string
+        1. Check cache for identical component configuration
+        2. Sort components by priority (descending)
+        3. Add components until budget is reached
+        4. Truncate low-priority components if needed
+        5. Merge all components into final string
 
         Returns:
             Assembled context string
@@ -144,6 +169,13 @@ class ContextAssembler:
         if not self.components:
             return ""
 
+        # Check cache if enabled
+        if self.enable_caching:
+            current_hash = self._get_components_hash()
+            if (self._assembly_cache is not None and 
+                self._last_components_hash == current_hash):
+                return self._assembly_cache
+
         # Sort by priority (highest first)
         sorted_components = sorted(
             self.components,
@@ -165,7 +197,83 @@ class ContextAssembler:
             header = f"# {component.name.replace('_', ' ').upper()}"
             sections.append(f"{header}\n{component.content}")
 
-        return "\n\n".join(sections)
+        result = "\n\n".join(sections)
+        
+        # Update cache if enabled
+        if self.enable_caching:
+            self._assembly_cache = result
+            self._last_components_hash = self._get_components_hash()
+
+        return result
+
+    def _get_components_hash(self) -> str:
+        """
+        Generate hash for current component configuration
+
+        优化版本：
+        - 使用 blake2b 替代 MD5（更快）
+        - 直接update字节而非拼接字符串
+        - 移除不必要的排序
+        """
+        # 使用 blake2b，比 MD5 更快且安全
+        hasher = hashlib.blake2b(digest_size=16)
+
+        # 直接更新hasher，避免字符串拼接
+        for comp in self.components:
+            hasher.update(comp.name.encode())
+            hasher.update(str(comp.priority).encode())
+            hasher.update(str(comp.token_count).encode())
+            hasher.update(b'1' if comp.truncatable else b'0')
+
+        return hasher.hexdigest()
+
+    def adjust_priority(self, component_name: str, new_priority: int) -> bool:
+        """
+        Dynamically adjust component priority.
+        
+        Args:
+            component_name: Name of the component to adjust
+            new_priority: New priority value
+            
+        Returns:
+            True if component was found and adjusted, False otherwise
+        """
+        for component in self.components:
+            if component.name == component_name:
+                component.priority = new_priority
+                # Clear cache since configuration changed
+                if self.enable_caching:
+                    self._assembly_cache = None
+                    self._last_components_hash = None
+                return True
+        return False
+
+    def get_component_stats(self) -> Dict[str, Any]:
+        """Get statistics about current components"""
+        if not self.components:
+            return {"total_components": 0, "total_tokens": 0}
+        
+        total_tokens = sum(c.token_count for c in self.components)
+        priority_distribution = {}
+        
+        for comp in self.components:
+            priority_distribution[comp.priority] = priority_distribution.get(comp.priority, 0) + 1
+        
+        return {
+            "total_components": len(self.components),
+            "total_tokens": total_tokens,
+            "budget_utilization": total_tokens / self.max_tokens if self.max_tokens > 0 else 0,
+            "priority_distribution": priority_distribution,
+            "cache_enabled": self.enable_caching,
+            "cache_size": len(self._component_cache) if self.enable_caching else 0
+        }
+
+    def clear_cache(self) -> None:
+        """Clear all caches"""
+        if self.enable_caching:
+            self._component_cache.clear()
+            self._assembly_cache = None
+            self._last_components_hash = None
 
     def _truncate_components(
         self,

loom/core/events.py

@@ -4,6 +4,12 @@ Agent Event System for Loom 2.0
 This module defines the unified event model for streaming agent execution.
 Inspired by Claude Code's event-driven architecture.
 
+新特性 (Loom 0.0.3):
+- 事件过滤和批量处理
+- 智能事件聚合
+- 性能优化的事件流
+- 事件优先级管理
+
 Example:
     ```python
     agent = Agent(llm=llm, tools=tools)
@@ -412,3 +418,243 @@ class EventCollector:
         if finish_events:
             return finish_events[-1].content
         return None
+
+
+class EventFilter:
+    """
+    事件过滤器 - 提供高级事件过滤和批量处理能力
+    
+    新特性 (Loom 0.0.3):
+    - 智能事件过滤
+    - 批量事件处理
+    - 事件聚合和合并
+    - 性能优化的事件流
+    """
+    
+    def __init__(self, 
+                 allowed_types: Optional[List[AgentEventType]] = None,
+                 blocked_types: Optional[List[AgentEventType]] = None,
+                 enable_batching: bool = True,
+                 batch_size: int = 10,
+                 batch_timeout: float = 0.1):
+        """
+        初始化事件过滤器
+        
+        Args:
+            allowed_types: 允许的事件类型列表（None = 全部允许）
+            blocked_types: 阻止的事件类型列表
+            enable_batching: 启用批量处理
+            batch_size: 批量大小
+            batch_timeout: 批量超时时间（秒）
+        """
+        self.allowed_types = allowed_types
+        self.blocked_types = blocked_types or []
+        self.enable_batching = enable_batching
+        self.batch_size = batch_size
+        self.batch_timeout = batch_timeout
+        
+        # 批量处理状态
+        self._batch_buffer: List[AgentEvent] = []
+        self._last_batch_time = time.time()
+    
+    def should_include(self, event: AgentEvent) -> bool:
+        """判断事件是否应该被包含"""
+        # 检查允许的类型
+        if self.allowed_types and event.type not in self.allowed_types:
+            return False
+        
+        # 检查阻止的类型
+        if event.type in self.blocked_types:
+            return False
+        
+        return True
+    
+    def process_event(self, event: AgentEvent) -> List[AgentEvent]:
+        """
+        处理单个事件，可能返回批量事件
+        
+        Returns:
+            处理后的事件列表
+        """
+        if not self.should_include(event):
+            return []
+        
+        if not self.enable_batching:
+            return [event]
+        
+        # 添加到批量缓冲区
+        self._batch_buffer.append(event)
+        
+        # 检查是否需要输出批量事件
+        should_flush = (
+            len(self._batch_buffer) >= self.batch_size or
+            (time.time() - self._last_batch_time) >= self.batch_timeout
+        )
+        
+        if should_flush:
+            return self._flush_batch()
+        
+        return []
+    
+    def _flush_batch(self) -> List[AgentEvent]:
+        """输出批量事件并清空缓冲区"""
+        if not self._batch_buffer:
+            return []
+        
+        # 智能聚合相同类型的事件
+        aggregated_events = self._aggregate_events(self._batch_buffer)
+        
+        # 清空缓冲区
+        self._batch_buffer.clear()
+        self._last_batch_time = time.time()
+        
+        return aggregated_events
+    
+    def _aggregate_events(self, events: List[AgentEvent]) -> List[AgentEvent]:
+        """智能聚合事件"""
+        if not events:
+            return []
+        
+        # 按类型分组
+        events_by_type: Dict[AgentEventType, List[AgentEvent]] = {}
+        for event in events:
+            if event.type not in events_by_type:
+                events_by_type[event.type] = []
+            events_by_type[event.type].append(event)
+        
+        aggregated = []
+        
+        for event_type, type_events in events_by_type.items():
+            if event_type == AgentEventType.LLM_DELTA:
+                # 合并 LLM delta 事件
+                merged_content = "".join(e.content or "" for e in type_events)
+                if merged_content:
+                    # 创建合并的事件
+                    merged_event = AgentEvent(
+                        type=AgentEventType.LLM_DELTA,
+                        content=merged_content,
+                        timestamp=type_events[0].timestamp,
+                        metadata={
+                            "batch_size": len(type_events),
+                            "aggregated": True
+                        }
+                    )
+                    aggregated.append(merged_event)
+            else:
+                # 其他类型的事件保持原样
+                aggregated.extend(type_events)
+        
+        return aggregated
+    
+    def flush_remaining(self) -> List[AgentEvent]:
+        """强制输出剩余的事件"""
+        return self._flush_batch()
+
+
+class EventProcessor:
+    """
+    事件处理器 - 提供高级事件处理能力
+    
+    新特性 (Loom 0.0.3):
+    - 事件优先级管理
+    - 智能事件路由
+    - 事件统计和分析
+    - 性能监控
+    """
+    
+    def __init__(self, 
+                 filters: Optional[List[EventFilter]] = None,
+                 enable_stats: bool = True):
+        """
+        初始化事件处理器
+        
+        Args:
+            filters: 事件过滤器列表
+            enable_stats: 启用统计功能
+        """
+        self.filters = filters or []
+        self.enable_stats = enable_stats
+        
+        # 统计信息
+        self._stats = {
+            "total_events": 0,
+            "filtered_events": 0,
+            "batched_events": 0,
+            "events_by_type": {},
+            "processing_times": []
+        }
+    
+    def process_events(self, events: List[AgentEvent]) -> List[AgentEvent]:
+        """
+        批量处理事件
+        
+        Args:
+            events: 输入事件列表
+            
+        Returns:
+            处理后的事件列表
+        """
+        if not events:
+            return []
+        
+        start_time = time.time()
+        processed_events = []
+        
+        for event in events:
+            # 更新统计
+            if self.enable_stats:
+                self._stats["total_events"] += 1
+                event_type = event.type.value
+                self._stats["events_by_type"][event_type] = \
+                    self._stats["events_by_type"].get(event_type, 0) + 1
+            
+            # 应用过滤器
+            for filter_obj in self.filters:
+                filtered = filter_obj.process_event(event)
+                processed_events.extend(filtered)
+            
+            # 如果没有过滤器，直接添加事件
+            if not self.filters:
+                processed_events.append(event)
+        
+        # 强制刷新所有过滤器的批量缓冲区
+        for filter_obj in self.filters:
+            remaining = filter_obj.flush_remaining()
+            processed_events.extend(remaining)
+        
+        # 更新处理时间统计
+        if self.enable_stats:
+            processing_time = time.time() - start_time
+            self._stats["processing_times"].append(processing_time)
+            self._stats["filtered_events"] = len(processed_events)
+        
+        return processed_events
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """获取处理统计信息"""
+        if not self.enable_stats:
+            return {}
+        
+        avg_processing_time = (
+            sum(self._stats["processing_times"]) / len(self._stats["processing_times"])
+            if self._stats["processing_times"] else 0
+        )
+        
+        return {
+            **self._stats,
+            "average_processing_time": avg_processing_time,
+            "filter_efficiency": (
+                self._stats["filtered_events"] / self._stats["total_events"]
+                if self._stats["total_events"] > 0 else 0
+            )
+        }
+    
+    def reset_stats(self) -> None:
+        """重置统计信息"""
+        self._stats = {
+            "total_events": 0,
+            "filtered_events": 0,
+            "batched_events": 0,
+            "events_by_type": {},
+            "processing_times": []
+        }