beswarm 0.2.82__py3-none-any.whl → 0.2.83__py3-none-any.whl

beswarm/aient/aient/architext/architext/core.py

@@ -4,9 +4,51 @@ import asyncio
 import logging
 import hashlib
 import mimetypes
+import uuid
+import threading
 from dataclasses import dataclass
 from abc import ABC, abstractmethod
-from typing import List, Dict, Any, Optional, Union
+from typing import List, Dict, Any, Optional, Union, Callable
+
+# A wrapper to manage multiple providers with the same name
+class ProviderGroup:
+    """A container for multiple providers that share the same name, allowing for bulk operations."""
+    def __init__(self, providers: List['ContextProvider']):
+        self._providers = providers
+    def __getitem__(self, key: int) -> 'ContextProvider':
+        """Allows accessing providers by index, e.g., group[-1]."""
+        return self._providers[key]
+    def __iter__(self):
+        """Allows iterating over the providers."""
+        return iter(self._providers)
+    def __len__(self) -> int:
+        """Returns the number of providers in the group."""
+        return len(self._providers)
+    @property
+    def visible(self) -> List[bool]:
+        """Gets the visibility of all providers in the group."""
+        return [p.visible for p in self._providers]
+    @visible.setter
+    def visible(self, value: bool):
+        """Sets the visibility for all providers in the group."""
+        for p in self._providers:
+            p.visible = value
+
+# Global, thread-safe registry for providers created within f-strings
+_fstring_provider_registry = {}
+_registry_lock = threading.Lock()
+
+def _register_provider(provider: 'ContextProvider') -> str:
+    """Registers a provider and returns a unique placeholder."""
+    with _registry_lock:
+        provider_id = f"__provider_placeholder_{uuid.uuid4().hex}__"
+        _fstring_provider_registry[provider_id] = provider
+        return provider_id
+
+def _retrieve_provider(placeholder: str) -> Optional['ContextProvider']:
+    """Retrieves a provider from the registry."""
+    with _registry_lock:
+        return _fstring_provider_registry.pop(placeholder, None)
 
 # 1. 核心数据结构: ContentBlock
 @dataclass
@@ -17,8 +59,30 @@ class ContentBlock:
 # 2. 上下文提供者 (带缓存)
 class ContextProvider(ABC):
     def __init__(self, name: str):
-        self.name = name; self._cached_content: Optional[str] = None; self._is_stale: bool = True
+        self.name = name
+        self._cached_content: Optional[str] = None
+        self._is_stale: bool = True
+        self._visible: bool = True
+
+    def __str__(self):
+        # This allows the object to be captured when used inside an f-string.
+        return _register_provider(self)
+
     def mark_stale(self): self._is_stale = True
+
+    @property
+    def visible(self) -> bool:
+        """Gets the visibility of the provider."""
+        return self._visible
+
+    @visible.setter
+    def visible(self, value: bool):
+        """Sets the visibility of the provider."""
+        if self._visible != value:
+            self._visible = value
+            # Content needs to be re-evaluated, but the source data hasn't changed,
+            # so just marking it stale is enough for the renderer to reconsider it.
+            self.mark_stale()
     async def refresh(self):
         if self._is_stale:
             self._cached_content = await self.render()
@@ -28,35 +92,113 @@ class ContextProvider(ABC):
     @abstractmethod
     def update(self, *args, **kwargs): raise NotImplementedError
     def get_content_block(self) -> Optional[ContentBlock]:
-        if self._cached_content is not None: return ContentBlock(self.name, self._cached_content)
+        if self.visible and self._cached_content is not None:
+            return ContentBlock(self.name, self._cached_content)
         return None
 
 class Texts(ContextProvider):
-    def __init__(self, text: str, name: Optional[str] = None):
-        self._text = text
+    def __init__(self, text: Optional[Union[str, Callable[[], str]]] = None, name: Optional[str] = None):
+        if text is None and name is None:
+            raise ValueError("Either 'text' or 'name' must be provided.")
+
+        # Ensure that non-callable inputs are treated as strings
+        if not callable(text):
+            self._text = str(text) if text is not None else None
+        else:
+            self._text = text
+
+        self._is_dynamic = callable(self._text)
+
         if name is None:
-            h = hashlib.sha1(self._text.encode()).hexdigest()
-            _name = f"text_{h[:8]}"
+            if self._is_dynamic:
+                import uuid
+                _name = f"dynamic_text_{uuid.uuid4().hex[:8]}"
+            else:
+                # Handle the case where text is None during initialization
+                h = hashlib.sha1(self._text.encode() if self._text else b'').hexdigest()
+                _name = f"text_{h[:8]}"
         else:
             _name = name
         super().__init__(_name)
 
-    def update(self, text: str):
+    async def refresh(self):
+        if self._is_dynamic:
+            self._is_stale = True
+        await super().refresh()
+
+    def update(self, text: Union[str, Callable[[], str]]):
         self._text = text
+        self._is_dynamic = callable(self._text)
         self.mark_stale()
 
-    async def render(self) -> str: return self._text
+    @property
+    def content(self) -> Optional[str]:
+        """
+        Synchronously retrieves the raw text content as a property.
+        If the content is dynamic (a callable), it executes the callable.
+        """
+        if self._is_dynamic:
+            # Ensure dynamic content returns a string, even if empty
+            result = self._text()
+            return result if result is not None else ""
+        # Ensure static content returns a string, even if empty
+        return self._text if self._text is not None else ""
+
+    async def render(self) -> Optional[str]:
+        return self.content
+
+    def __getstate__(self):
+        """Custom state for pickling."""
+        state = self.__dict__.copy()
+        if self._is_dynamic:
+            # For dynamic content, we snapshot its current value for serialization.
+            # The lambda function itself cannot be pickled.
+            try:
+                # Evaluate the lambda and store it as a static string
+                state['_text'] = self.content
+                # Mark it as no longer dynamic in the pickled state
+                state['_is_dynamic'] = False
+            except Exception as e:
+                # If the lambda fails for some reason, store an error message.
+                logging.error(f"Error evaluating dynamic text '{self.name}' during pickling: {e}")
+                state['_text'] = f"[Error: Could not evaluate dynamic content during save: {e}]"
+                state['_is_dynamic'] = False
+        return state
+
+    def __setstate__(self, state):
+        """Custom state for unpickling."""
+        # Just restore the dictionary. The transformation is one-way.
+        self.__dict__.update(state)
+
+    def __eq__(self, other):
+        if not isinstance(other, Texts):
+            return NotImplemented
+        # If either object is dynamic, they are only equal if they are the exact same object.
+        if self._is_dynamic or (hasattr(other, '_is_dynamic') and other._is_dynamic):
+            return self is other
+        # For static content, compare the actual content.
+        return self.content == other.content
 
 class Tools(ContextProvider):
-    def __init__(self, tools_json: List[Dict]): super().__init__("tools"); self._tools_json = tools_json
+    def __init__(self, tools_json: Optional[List[Dict]] = None, name: str = "tools"):
+        super().__init__(name)
+        self._tools_json = tools_json or []
     def update(self, tools_json: List[Dict]):
         self._tools_json = tools_json
         self.mark_stale()
-    async def render(self) -> str: return f"<tools>{str(self._tools_json)}</tools>"
+    async def render(self) -> Optional[str]:
+        if not self._tools_json:
+            return None
+        return f"<tools>{str(self._tools_json)}</tools>"
+
+    def __eq__(self, other):
+        if not isinstance(other, Tools):
+            return NotImplemented
+        return self._tools_json == other._tools_json
 
 class Files(ContextProvider):
-    def __init__(self, *paths: Union[str, List[str]]):
-        super().__init__("files")
+    def __init__(self, *paths: Union[str, List[str]], name: str = "files"):
+        super().__init__(name)
         self._files: Dict[str, str] = {}
 
         file_paths: List[str] = []
@@ -130,6 +272,11 @@ class Files(ContextProvider):
         if not self._files: return None
         return "<latest_file_content>" + "\n".join([f"<file><file_path>{p}</file_path><file_content>{c}</file_content></file>" for p, c in self._files.items()]) + "\n</latest_file_content>"
 
+    def __eq__(self, other):
+        if not isinstance(other, Files):
+            return NotImplemented
+        return self._files == other._files
+
 class Images(ContextProvider):
     def __init__(self, url: str, name: Optional[str] = None):
         super().__init__(name or url)
@@ -150,6 +297,11 @@ class Images(ContextProvider):
             logging.warning(f"Image file not found: {self.url}. Skipping.")
             return None # Or handle error appropriately
 
+    def __eq__(self, other):
+        if not isinstance(other, Images):
+            return NotImplemented
+        return self.url == other.url
+
 # 3. 消息类 (已合并 MessageContent)
 class Message(ABC):
     def __init__(self, role: str, *initial_items: Union[ContextProvider, str, list]):
@@ -157,9 +309,25 @@ class Message(ABC):
         processed_items = []
         for item in initial_items:
             if isinstance(item, str):
-                processed_items.append(Texts(text=item))
+                # Check if the string contains placeholders from f-string rendering
+                import re
+                placeholder_pattern = re.compile(r'(__provider_placeholder_[a-f0-9]{32}__)')
+                parts = placeholder_pattern.split(item)
+
+                if len(parts) > 1: # Placeholders were found
+                    for part in parts:
+                        if not part: continue
+                        if placeholder_pattern.match(part):
+                            provider = _retrieve_provider(part)
+                            if provider:
+                                processed_items.append(provider)
+                        else:
+                            processed_items.append(Texts(text=part))
+                else: # No placeholders, just a regular string
+                    processed_items.append(Texts(text=item))
+
             elif isinstance(item, Message):
-                processed_items.extend(item.providers())
+                processed_items.extend(item.provider())
             elif isinstance(item, ContextProvider):
                 processed_items.append(item)
             elif isinstance(item, list):
@@ -181,9 +349,24 @@ class Message(ABC):
         self._items: List[ContextProvider] = processed_items
         self._parent_messages: Optional['Messages'] = None
 
+    @property
+    def content(self) -> Optional[Union[str, List[Dict[str, Any]]]]:
+        """
+        Renders the message content.
+        For simple text messages, returns a string.
+        For multimodal messages, returns a list of content blocks.
+        """
+        rendered_dict = self.to_dict()
+        return rendered_dict.get('content') if rendered_dict else None
+
     def _render_content(self) -> str:
-        blocks = [item.get_content_block() for item in self._items]
-        return "\n\n".join(b.content for b in blocks if b and b.content)
+        final_parts = []
+        for item in self._items:
+            block = item.get_content_block()
+            if block and block.content is not None:
+                final_parts.append(block.content)
+
+        return "".join(final_parts)
 
     def pop(self, name: str) -> Optional[ContextProvider]:
         popped_item = None
@@ -205,14 +388,24 @@ class Message(ABC):
         if self._parent_messages:
             self._parent_messages._notify_provider_added(item, self)
 
-    def providers(self) -> List[ContextProvider]: return self._items
+    def provider(self, name: Optional[str] = None) -> Optional[Union[ContextProvider, ProviderGroup, List[ContextProvider]]]:
+        if name is None:
+            return self._items
+
+        named_providers = [p for p in self._items if hasattr(p, 'name') and p.name == name]
+
+        if not named_providers:
+            return None
+        if len(named_providers) == 1:
+            return named_providers[0]
+        return ProviderGroup(named_providers)
 
     def __add__(self, other):
         if isinstance(other, str):
             new_items = self._items + [Texts(text=other)]
             return type(self)(*new_items)
         if isinstance(other, Message):
-            new_items = self._items + other.providers()
+            new_items = self._items + other.provider()
             return type(self)(*new_items)
         return NotImplemented
 
@@ -221,30 +414,40 @@ class Message(ABC):
             new_items = [Texts(text=other)] + self._items
             return type(self)(*new_items)
         if isinstance(other, Message):
-            new_items = other.providers() + self._items
+            new_items = other.provider() + self._items
             return type(self)(*new_items)
         return NotImplemented
 
-    def __getitem__(self, key: str) -> Any:
+    def __getitem__(self, key: Union[str, int]) -> Any:
         """
-        使得 Message 对象支持字典风格的访问 (e.g., message['content'])。
+        使得 Message 对象支持字典风格的访问 (e.g., message['content'])
+        和列表风格的索引访问 (e.g., message[-1])。
         """
-        if key == 'role':
-            return self.role
-        elif key == 'content':
-            # 直接调用 to_dict 并提取 'content'，确保逻辑一致
-            rendered_dict = self.to_dict()
-            return rendered_dict.get('content') if rendered_dict else None
-        # 对于 tool_calls 等特殊属性，也通过 to_dict 获取
-        elif hasattr(self, key):
-            rendered_dict = self.to_dict()
-            if rendered_dict and key in rendered_dict:
-                return rendered_dict[key]
-
-        # 如果在对象本身或其 to_dict() 中都找不到，则引发 KeyError
-        if hasattr(self, key):
-             return getattr(self, key)
-        raise KeyError(f"'{key}'")
+        if isinstance(key, str):
+            if key == 'role':
+                return self.role
+            elif key == 'content':
+                # 直接调用 to_dict 并提取 'content'，确保逻辑一致
+                rendered_dict = self.to_dict()
+                return rendered_dict.get('content') if rendered_dict else None
+            # 对于 tool_calls 等特殊属性，也通过 to_dict 获取
+            elif hasattr(self, key):
+                rendered_dict = self.to_dict()
+                if rendered_dict and key in rendered_dict:
+                    return rendered_dict[key]
+
+            # 如果在对象本身或其 to_dict() 中都找不到，则引发 KeyError
+            if hasattr(self, key):
+                 return getattr(self, key)
+            raise KeyError(f"'{key}'")
+        elif isinstance(key, int):
+            return self._items[key]
+        else:
+            raise TypeError(f"Message indices must be integers or strings, not {type(key).__name__}")
+
+    def __len__(self) -> int:
+        """返回消息中 provider 的数量。"""
+        return len(self._items)
 
     def __repr__(self): return f"Message(role='{self.role}', items={[i.name for i in self._items]})"
     def __bool__(self) -> bool:
@@ -323,15 +526,17 @@ class ToolCalls(Message):
 class ToolResults(Message):
     """Represents a tool message with the result of a single tool call."""
     def __init__(self, tool_call_id: str, content: str):
-        super().__init__("tool")
+        # We pass a Texts provider to the parent so it can be rendered,
+        # but the primary way to access content for ToolResults is via its dict representation.
+        super().__init__("tool", Texts(text=content))
         self.tool_call_id = tool_call_id
-        self.content = content
+        self._content = content
 
     def to_dict(self) -> Dict[str, Any]:
         return {
             "role": self.role,
             "tool_call_id": self.tool_call_id,
-            "content": self.content
+            "content": self._content
         }
 
 # 4. 顶层容器: Messages
@@ -339,22 +544,40 @@ class Messages:
     def __init__(self, *initial_messages: Message):
         from typing import Tuple
         self._messages: List[Message] = []
-        self._providers_index: Dict[str, Tuple[ContextProvider, Message]] = {}
+        self._providers_index: Dict[str, List[Tuple[ContextProvider, Message]]] = {}
         if initial_messages:
             for msg in initial_messages:
                 self.append(msg)
 
     def _notify_provider_added(self, provider: ContextProvider, message: Message):
         if provider.name not in self._providers_index:
-            self._providers_index[provider.name] = (provider, message)
+            self._providers_index[provider.name] = []
+        self._providers_index[provider.name].append((provider, message))
 
     def _notify_provider_removed(self, provider: ContextProvider):
         if provider.name in self._providers_index:
-            del self._providers_index[provider.name]
+            # Create a new list excluding the provider to be removed.
+            # Comparing by object identity (`is`) is crucial here.
+            providers_list = self._providers_index[provider.name]
+            new_list = [(p, m) for p, m in providers_list if p is not provider]
+
+            if not new_list:
+                # If the list becomes empty, remove the key from the dictionary.
+                del self._providers_index[provider.name]
+            else:
+                # Otherwise, update the dictionary with the new list.
+                self._providers_index[provider.name] = new_list
+
+    def provider(self, name: str) -> Optional[Union[ContextProvider, ProviderGroup]]:
+        indexed_list = self._providers_index.get(name)
+        if not indexed_list:
+            return None
 
-    def provider(self, name: str) -> Optional[ContextProvider]:
-        indexed = self._providers_index.get(name)
-        return indexed[0] if indexed else None
+        providers = [p for p, m in indexed_list]
+        if len(providers) == 1:
+            return providers[0]
+        else:
+            return ProviderGroup(providers)
 
     def pop(self, key: Optional[Union[str, int]] = None) -> Union[Optional[ContextProvider], Optional[Message]]:
         # If no key is provided, pop the last message.
@@ -362,10 +585,13 @@ class Messages:
             key = len(self._messages) - 1
 
         if isinstance(key, str):
-            indexed = self._providers_index.get(key)
-            if not indexed:
+            indexed_list = self._providers_index.get(key)
+            if not indexed_list:
                 return None
-            _provider, parent_message = indexed
+            # Pop the first one found, which is consistent with how pop usually works
+            _provider, parent_message = indexed_list[0]
+            # The actual removal from _providers_index happens in _notify_provider_removed
+            # which is called by message.pop()
             return parent_message.pop(key)
         elif isinstance(key, int):
             try:
@@ -375,7 +601,7 @@ class Messages:
                     return None
                 popped_message = self._messages.pop(key)
                 popped_message._parent_messages = None
-                for provider in popped_message.providers():
+                for provider in popped_message.provider():
                     self._notify_provider_removed(provider)
                 return popped_message
             except IndexError:
@@ -384,7 +610,10 @@ class Messages:
         return None
 
     async def refresh(self):
-        tasks = [provider.refresh() for provider, _ in self._providers_index.values()]
+        tasks = []
+        for provider_list in self._providers_index.values():
+            for provider, _ in provider_list:
+                tasks.append(provider.refresh())
         await asyncio.gather(*tasks)
 
     def render(self) -> List[Dict[str, Any]]:
@@ -398,12 +627,12 @@ class Messages:
     def append(self, message: Message):
         if self._messages and self._messages[-1].role == message.role:
             last_message = self._messages[-1]
-            for provider in message.providers():
+            for provider in message.provider():
                 last_message.append(provider)
         else:
             message._parent_messages = self
             self._messages.append(message)
-            for p in message.providers():
+            for p in message.provider():
                 self._notify_provider_added(p, message)
 
     def save(self, file_path: str):
@@ -425,12 +654,41 @@ class Messages:
             with open(file_path, 'rb') as f:
                 return pickle.load(f)
         except FileNotFoundError:
-            logging.warning(f"File not found at {file_path}, returning empty Messages.")
+            # logging.warning(f"File not found at {file_path}, returning empty Messages.")
             return cls()
         except (pickle.UnpicklingError, EOFError) as e:
             logging.error(f"Could not deserialize file {file_path}: {e}")
             return cls()
 
-    def __getitem__(self, index: int) -> Message: return self._messages[index]
+    def __getitem__(self, index: Union[int, slice]) -> Union[Message, 'Messages']:
+        if isinstance(index, slice):
+            return Messages(*self._messages[index])
+        return self._messages[index]
+
+    def __setitem__(self, index: slice, value: 'Messages'):
+        if not isinstance(index, slice) or not isinstance(value, Messages):
+            raise TypeError("Unsupported operand type(s) for slice assignment")
+
+        # Basic slice assignment logic.
+        # A more robust implementation would handle step and negative indices.
+        start, stop, step = index.indices(len(self._messages))
+
+        if step != 1:
+            raise ValueError("Slice assignment with step is not supported.")
+
+        # Remove old providers from the index
+        for i in range(start, stop):
+            for provider in self._messages[i].provider():
+                self._notify_provider_removed(provider)
+
+        # Replace the slice in the list
+        self._messages[start:stop] = value._messages
+
+        # Add new providers to the index and set parent
+        for msg in value:
+            msg._parent_messages = self
+            for provider in msg.provider():
+                self._notify_provider_added(provider, msg)
+
     def __len__(self) -> int: return len(self._messages)
     def __iter__(self): return iter(self._messages)