aient 1.2.0__tar.gz → 1.2.2__tar.gz

{aient-1.2.0 → aient-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aient
-Version: 1.2.0
+Version: 1.2.2
 Summary: Aient: The Awakening of Agent.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{aient-1.2.0 → aient-1.2.2}/aient/architext/architext/core.py

@@ -10,6 +10,30 @@ from dataclasses import dataclass
 from abc import ABC, abstractmethod
 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()
@@ -273,6 +297,16 @@ 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:
         final_parts = []
         for item in self._items:
@@ -420,15 +454,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
@@ -436,22 +472,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[ContextProvider]:
-        indexed = self._providers_index.get(name)
-        return indexed[0] if indexed else None
+    def provider(self, name: str) -> Optional[Union[ContextProvider, ProviderGroup]]:
+        indexed_list = self._providers_index.get(name)
+        if not indexed_list:
+            return 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.
@@ -459,10 +513,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:
@@ -481,7 +538,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]]:

{aient-1.2.0 → aient-1.2.2}/aient/architext/test/test.py

@@ -1053,6 +1053,88 @@ Current time: {Texts(lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S"))}
         self.assertEqual(len(rendered_visible_again), 1)
         self.assertEqual(rendered_visible_again[0]['content'], "Hello, World!")
 
+    async def test_z8_bulk_provider_visibility_control(self):
+        """测试通过名称批量控制和豁免provider的可见性"""
+        # 1. 创建多个同名 provider
+        messages = Messages(
+            UserMessage(
+                Texts("First explanation.", name="explanation"),
+                Texts("Second explanation.", name="explanation"),
+                Texts("Some other text."),
+                Texts("Third explanation.", name="explanation")
+            )
+        )
+
+        # 2. 初始渲染，所有 "explanation" 都应该可见
+        rendered_initial = await messages.render_latest()
+        self.assertIn("First explanation.", rendered_initial[0]['content'])
+        self.assertIn("Second explanation.", rendered_initial[0]['content'])
+        self.assertIn("Third explanation.", rendered_initial[0]['content'])
+
+        # 3. 获取所有名为 "explanation" 的 provider
+        explanation_providers = messages.provider("explanation")
+        self.assertIsInstance(explanation_providers, ProviderGroup)
+        self.assertEqual(len(explanation_providers), 3)
+
+        # 4. 将所有 "explanation" provider 设置为不可见
+        # 这是需要实现的新语法
+        explanation_providers.visible = False
+        for p in explanation_providers:
+             self.assertFalse(p.visible)
+
+        # 5. 渲染，所有 "explanation" 的内容都应该消失
+        rendered_hidden = await messages.render_latest()
+        self.assertNotIn("First explanation.", rendered_hidden[0]['content'])
+        self.assertNotIn("Second explanation.", rendered_hidden[0]['content'])
+        self.assertNotIn("Third explanation.", rendered_hidden[0]['content'])
+        self.assertIn("Some other text.", rendered_hidden[0]['content'])
+
+        # 6. 将最后一个 "explanation" provider 设置回可见
+        # 这是需要实现的另一个新语法
+        explanation_providers[-1].visible = True
+        self.assertTrue(explanation_providers[-1].visible)
+        self.assertFalse(explanation_providers[0].visible)
+
+        # 7. 最终渲染，只应看到最后一个 "explanation"
+        rendered_final = await messages.render_latest()
+        self.assertNotIn("First explanation.", rendered_final[0]['content'])
+        self.assertNotIn("Second explanation.", rendered_final[0]['content'])
+        self.assertIn("Third explanation.", rendered_final[0]['content'])
+        self.assertIn("Some other text.", rendered_final[0]['content'])
+
+    async def test_z9_rolemessage_content_access(self):
+        """测试是否支持 RoleMessage.content 来访问渲染好的内容"""
+        # 1. 创建一个简单的 UserMessage
+        user_message = UserMessage("你好, Architext!")
+        # 对于简单的 Texts, refresh 不是必须的, 但这是个好习惯
+        # Message 类本身没有 refresh, 调用其 providers 的 refresh
+        for p in user_message.providers():
+            await p.refresh()
+
+        # 2. 直接访问 .content 属性
+        # 在实现该功能前，这行代码会因 AttributeError 而失败
+        self.assertEqual(user_message.content, "你好, Architext!")
+
+        # 3. 创建一个多模态消息
+        multimodal_message = AssistantMessage(
+            "这是一张图片:",
+            Images(url="data:image/png;base64,FAKE_IMG_DATA")
+        )
+        for p in multimodal_message.providers():
+            await p.refresh()
+
+        # 4. 访问多模态消息的 .content 属性，期望返回一个列表
+        content_list = multimodal_message.content
+        self.assertIsInstance(content_list, list)
+        self.assertEqual(len(content_list), 2)
+        self.assertEqual(content_list[0]['type'], 'text')
+        self.assertEqual(content_list[1]['type'], 'image_url')
+
+        # 5. 测试通过 RoleMessage 工厂创建的消息
+        role_message = RoleMessage('user', "通过工厂创建的内容")
+        for p in role_message.providers():
+            await p.refresh()
+        self.assertEqual(role_message.content, "通过工厂创建的内容")
 
 # ==============================================================================
 # 6. 演示

{aient-1.2.0 → aient-1.2.2}/aient.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aient
-Version: 1.2.0
+Version: 1.2.2
 Summary: Aient: The Awakening of Agent.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{aient-1.2.0 → aient-1.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aient"
-version = "1.2.0"
+version = "1.2.2"
 description = "Aient: The Awakening of Agent."
 readme = "README.md"
 requires-python = ">=3.11"