aient 1.1.90__py3-none-any.whl → 1.1.91__py3-none-any.whl

aient/architext/architext/core.py

@@ -1,31 +1,30 @@
+import base64
 import asyncio
+import logging
+import mimetypes
+from dataclasses import dataclass
 from abc import ABC, abstractmethod
-from typing import List, Dict, Any, Optional, Union
+from typing import List, Dict, Any, Optional
 
 # 1. 核心数据结构: ContentBlock
+@dataclass
 class ContentBlock:
-    def __init__(self, name: str, content: str, provider: Optional['ContextProvider'] = None):
-        self.name = name; self.content = content; self.provider = provider
-    def __repr__(self): return f"Block(name='{self.name}')"
+    name: str
+    content: str
 
 # 2. 上下文提供者 (带缓存)
 class ContextProvider(ABC):
     def __init__(self, name: str):
         self.name = name; self._cached_content: Optional[str] = None; self._is_stale: bool = True
     def mark_stale(self): self._is_stale = True
-    async def _refresh(self):
+    async def refresh(self):
         if self._is_stale:
-            # 注意：我们将在这个方法上使用 mock，所以实际的 print 不再重要
-            # print(f"信息: 正在为上下文提供者 '{self.name}' 刷新内容...")
             self._cached_content = await self._fetch_content()
             self._is_stale = False
-        # else:
-            # print(f"调试: 上下文提供者 '{self.name}' 正在使用缓存内容。")
     @abstractmethod
     async def _fetch_content(self) -> Optional[str]: raise NotImplementedError
-    async def render(self) -> Optional[ContentBlock]:
-        await self._refresh()
-        if self._cached_content is not None: return ContentBlock(self.name, self._cached_content, self)
+    def get_content_block(self) -> Optional[ContentBlock]:
+        if self._cached_content is not None: return ContentBlock(self.name, self._cached_content)
         return None
 
 class Texts(ContextProvider):
@@ -41,78 +40,136 @@ class Files(ContextProvider):
     def update(self, path: str, content: str): self._files[path] = content; self.mark_stale()
     async def _fetch_content(self) -> str:
         if not self._files: return None
-        return "<files>\n" + "\n".join([f"<file path='{p}'>{c[:50]}...</file>" for p, c in self._files.items()]) + "\n</files>"
-
-Item = Union[ContentBlock, ContextProvider]
-
-# 3. 消息内容类与消息类
-class MessageContent:
-    def __init__(self, items: List[Item]): self._items: List[Item] = items
-    async def render(self) -> str:
-        tasks = []
-        for item in self._items:
-            if isinstance(item, ContextProvider):
-                tasks.append(item.render())
-            elif isinstance(item, ContentBlock):
-                # 为了统一处理，将 ContentBlock 也包装成一个已完成的 Future
-                future = asyncio.Future()
-                future.set_result(item)
-                tasks.append(future)
-
-        blocks = await asyncio.gather(*tasks)
+        return "<files>\n" + "\n".join([f"<file path='{p}'>{c}...</file>" for p, c in self._files.items()]) + "\n</files>"
+
+class Images(ContextProvider):
+    def __init__(self, image_path: str, name: Optional[str] = None):
+        super().__init__(name or image_path)
+        self.image_path = image_path
+    async def _fetch_content(self) -> Optional[str]:
+        try:
+            with open(self.image_path, "rb") as image_file:
+                encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
+                mime_type, _ = mimetypes.guess_type(self.image_path)
+                if not mime_type: mime_type = "application/octet-stream" # Fallback
+                return f"data:{mime_type};base64,{encoded_string}"
+        except FileNotFoundError:
+            logging.warning(f"Image file not found: {self.image_path}. Skipping.")
+            return None # Or handle error appropriately
+
+# 3. 消息类 (已合并 MessageContent)
+class Message(ABC):
+    def __init__(self, role: str, *initial_items: ContextProvider):
+        self.role = role
+        self._items: List[ContextProvider] = list(initial_items)
+        self._parent_messages: Optional['Messages'] = 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)
-    def pop(self, name: str) -> Optional[Item]:
-        for i, item in enumerate(self._items):
-            if hasattr(item, 'name') and item.name == name: return self._items.pop(i)
-        return None
-    def insert(self, index: int, item: Item): self._items.insert(index, item)
-    def append(self, item: Item): self._items.append(item)
-    def providers(self) -> List[ContextProvider]: return [item for item in self._items if isinstance(item, ContextProvider)]
-    def __repr__(self): return f"Content(items={[item.name for item in self._items if hasattr(item, 'name')]})"
 
-class Message(ABC):
-    def __init__(self, role: str, *initial_items: Item): self.role = role; self.content = MessageContent(list(initial_items))
-    async def to_dict(self) -> Optional[Dict[str, Any]]:
-        rendered_content = await self.content.render()
-        if not rendered_content: return None
-        return {"role": self.role, "content": rendered_content}
+    def pop(self, name: str) -> Optional[ContextProvider]:
+        popped_item = None
+        for i, item in enumerate(self._items):
+            if hasattr(item, 'name') and item.name == name:
+                popped_item = self._items.pop(i)
+                break
+        if popped_item and self._parent_messages:
+            self._parent_messages._notify_provider_removed(popped_item)
+        return popped_item
+
+    def insert(self, index: int, item: ContextProvider):
+        self._items.insert(index, item)
+        if self._parent_messages:
+            self._parent_messages._notify_provider_added(item, self)
+
+    def append(self, item: ContextProvider):
+        self._items.append(item)
+        if self._parent_messages:
+            self._parent_messages._notify_provider_added(item, self)
+
+    def providers(self) -> List[ContextProvider]: return self._items
+    def __repr__(self): return f"Message(role='{self.role}', items={[i.name for i in self._items]})"
+    def to_dict(self) -> Optional[Dict[str, Any]]:
+        is_multimodal = any(isinstance(p, Images) for p in self._items)
+
+        if not is_multimodal:
+            rendered_content = self._render_content()
+            if not rendered_content: return None
+            return {"role": self.role, "content": rendered_content}
+        else:
+            content_list = []
+            for item in self._items:
+                block = item.get_content_block()
+                if not block or not block.content: continue
+                if isinstance(item, Images):
+                    content_list.append({"type": "image_url", "image_url": {"url": block.content}})
+                else:
+                    content_list.append({"type": "text", "text": block.content})
+            if not content_list: return None
+            return {"role": self.role, "content": content_list}
 
 class SystemMessage(Message):
     def __init__(self, *items): super().__init__("system", *items)
 class UserMessage(Message):
     def __init__(self, *items): super().__init__("user", *items)
 
-# 4. 上下文构建器 (内部使用)
-class ContextBuilder:
-    def __init__(self, providers: List[ContextProvider]): self.providers = {p.name: p for p in providers}
-    def get_provider(self, name: str) -> Optional[ContextProvider]: return self.providers.get(name)
-
-# 5. 顶层容器: Messages
+# 4. 顶层容器: Messages
 class Messages:
     def __init__(self, *initial_messages: Message):
-        self._messages: List[Message] = list(initial_messages)
-        all_providers = []
-        for msg in self._messages: all_providers.extend(msg.content.providers())
-        self._context_builder = ContextBuilder(all_providers)
-    def provider(self, name: str) -> Optional[ContextProvider]: return self._context_builder.get_provider(name)
-    def pop(self, name: str) -> Optional[Item]:
-        for message in self._messages:
-            popped_item = message.content.pop(name)
-            if popped_item: return popped_item
-        return None
-    async def render(self) -> List[Dict[str, Any]]:
-        tasks = [msg.to_dict() for msg in self._messages]
-        results = await asyncio.gather(*tasks)
+        from typing import Tuple
+        self._messages: List[Message] = []
+        self._providers_index: Dict[str, 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)
+
+    def _notify_provider_removed(self, provider: ContextProvider):
+        if provider.name in self._providers_index:
+            del self._providers_index[provider.name]
+
+    def provider(self, name: str) -> Optional[ContextProvider]:
+        indexed = self._providers_index.get(name)
+        return indexed[0] if indexed else None
+
+    def pop(self, name: str) -> Optional[ContextProvider]:
+        indexed = self._providers_index.get(name)
+        if not indexed:
+            return None
+        _provider, parent_message = indexed
+        return parent_message.pop(name)
+
+    async def refresh(self):
+        tasks = [provider.refresh() for provider, _ in self._providers_index.values()]
+        await asyncio.gather(*tasks)
+
+    def render(self) -> List[Dict[str, Any]]:
+        results = [msg.to_dict() for msg in self._messages]
         return [res for res in results if res]
+
+    async def render_latest(self) -> List[Dict[str, Any]]:
+        await self.refresh()
+        return self.render()
+
     def append(self, message: Message):
-        self._messages.append(message)
-        for p in message.content.providers():
-            if p.name not in self._context_builder.providers: self._context_builder.providers[p.name] = p
+        if self._messages and self._messages[-1].role == message.role:
+            last_message = self._messages[-1]
+            for provider in message.providers():
+                last_message.append(provider)
+        else:
+            message._parent_messages = self
+            self._messages.append(message)
+            for p in message.providers():
+                self._notify_provider_added(p, message)
+
     def __getitem__(self, index: int) -> Message: return self._messages[index]
     def __len__(self) -> int: return len(self._messages)
     def __iter__(self): return iter(self._messages)
 
-
 # ==============================================================================
 # 6. 演示
 # ==============================================================================
@@ -126,40 +183,55 @@ async def run_demo():
     print("\n>>> 场景 A: 使用新的、优雅的构造函数直接初始化 Messages")
     messages = Messages(
         SystemMessage(system_prompt_provider, tools_provider),
-        UserMessage(files_provider, Texts("user_input", "这是我的初始问题。"))
+        UserMessage(files_provider, Texts("user_input", "这是我的初始问题。")),
+        UserMessage(Texts("user_input2", "这是我的初始问题2。"))
     )
 
     print("\n--- 渲染后的初始 Messages (首次渲染，全部刷新) ---")
-    for msg_dict in await messages.render(): print(msg_dict)
+    for msg_dict in await messages.render_latest(): print(msg_dict)
     print("-" * 40)
 
     # --- 3. 演示穿透更新 ---
     print("\n>>> 场景 B: 穿透更新 File Provider，渲染时自动刷新")
-
-    # 直接通过 messages 对象穿透访问并更新 files provider
     files_provider_instance = messages.provider("files")
     if isinstance(files_provider_instance, Files):
         files_provider_instance.update("file1.py", "这是新的文件内容！")
 
     print("\n--- 再次渲染 Messages (只有文件提供者会刷新) ---")
-    for msg_dict in await messages.render(): print(msg_dict)
+    for msg_dict in await messages.render_latest(): print(msg_dict)
     print("-" * 40)
 
     # --- 4. 演示全局 Pop 和通过索引 Insert ---
     print("\n>>> 场景 C: 全局 Pop 工具提供者，并 Insert 到 UserMessage 中")
-
-    # a. 全局弹出 'tools' Provider
     popped_tools_provider = messages.pop("tools")
-
-    # b. 将弹出的 Provider 插入到第一个 UserMessage (索引为1) 的开头
     if popped_tools_provider:
-        # 通过索引精确定位
-        messages[1].content.insert(0, popped_tools_provider)
+        messages[1].insert(0, popped_tools_provider)
         print(f"\n已成功将 '{popped_tools_provider.name}' 提供者移动到用户消息。")
 
     print("\n--- Pop 和 Insert 后渲染的 Messages (验证移动效果) ---")
-    for msg_dict in await messages.render(): print(msg_dict)
+    for msg_dict in messages.render(): print(msg_dict)
     print("-" * 40)
 
+    # --- 5. 演示多模态渲染 ---
+    print("\n>>> 场景 D: 演示多模态 (文本+图片) 渲染")
+    with open("dummy_image.png", "w") as f:
+        f.write("This is a dummy image file.")
+
+    multimodal_message = Messages(
+        UserMessage(
+            Texts("prompt", "What do you see in this image?"),
+            Images("dummy_image.png")
+        )
+    )
+    print("\n--- 渲染后的多模态 Message ---")
+    for msg_dict in await multimodal_message.render_latest():
+        if isinstance(msg_dict['content'], list):
+            for item in msg_dict['content']:
+                if item['type'] == 'image_url':
+                    item['image_url']['url'] = item['image_url']['url'][:80] + "..."
+        print(msg_dict)
+    print("-" * 40)
+
+
 if __name__ == "__main__":
-    asyncio.run(run_demo())
+    asyncio.run(run_demo())

aient/architext/test.py

@@ -21,7 +21,7 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         )
 
         self.assertEqual(len(messages), 2)
-        rendered = await messages.render()
+        rendered = await messages.render_latest()
 
         self.assertEqual(len(rendered), 2)
         self.assertIn("<tools>", rendered[0]['content'])
@@ -29,29 +29,30 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
 
     async def test_b_provider_passthrough_and_refresh(self):
         """测试通过 mock 验证缓存和刷新逻辑"""
-        # 为 files_provider 的 _fetch_content 方法创建一个 mock
-        # 我们希望它在被调用时仍然返回真实的结果，所以使用 side_effect
-        original_fetch = self.files_provider._fetch_content
-        self.files_provider._fetch_content = AsyncMock(side_effect=original_fetch)
+        # 我们真正关心的是 _fetch_content 是否被不必要地调用
+        # 所以我们 mock 底层的它，而不是 refresh 方法
+        original_fetch_content = self.files_provider._fetch_content
+        self.files_provider._fetch_content = AsyncMock(side_effect=original_fetch_content)
 
         messages = Messages(UserMessage(self.files_provider))
 
-        # 1. 初始文件内容为空，渲染一次
+        # 1. 首次刷新
         self.files_provider.update("path1", "content1")
-        await messages.render()
+        await messages.refresh()
         # _fetch_content 应该被调用了 1 次
         self.assertEqual(self.files_provider._fetch_content.call_count, 1)
 
-        # 2. 再次渲染，内容未变，不应再次调用 _fetch_content
-        await messages.render()
+        # 2. 再次刷新，内容未变，不应再次调用 _fetch_content
+        await messages.refresh()
         # 调用次数应该仍然是 1，证明缓存生效
         self.assertEqual(self.files_provider._fetch_content.call_count, 1)
 
         # 3. 更新文件内容，这会标记 provider 为 stale
         self.files_provider.update("path2", "content2")
 
-        # 4. 再次渲染，现在应该会重新调用 _fetch_content
-        rendered = await messages.render()
+        # 4. 再次刷新，现在应该会重新调用 _fetch_content
+        await messages.refresh()
+        rendered = messages.render()
         # 调用次数应该变为 2
         self.assertEqual(self.files_provider._fetch_content.call_count, 2)
         # 并且渲染结果包含了新内容
@@ -65,7 +66,7 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         )
 
         # 验证初始状态
-        initial_rendered = await messages.render()
+        initial_rendered = await messages.render_latest()
         self.assertTrue(any("<tools>" in msg['content'] for msg in initial_rendered if msg['role'] == 'system'))
 
         # 全局弹出 'tools' Provider
@@ -73,20 +74,153 @@ class TestContextManagement(unittest.IsolatedAsyncioTestCase):
         self.assertIs(popped_tools_provider, self.tools_provider)
 
         # 验证 pop 后的状态
-        rendered_after_pop = await messages.render()
+        rendered_after_pop = messages.render()
         self.assertFalse(any("<tools>" in msg['content'] for msg in rendered_after_pop if msg['role'] == 'system'))
 
         # 通过索引将弹出的provider插入到UserMessage的开头
-        messages[1].content.insert(0, popped_tools_provider)
+        messages[1].insert(0, popped_tools_provider)
 
         # 验证 insert 后的状态
-        rendered_after_insert = await messages.render()
+        rendered_after_insert = messages.render()
         user_message_content = next(msg['content'] for msg in rendered_after_insert if msg['role'] == 'user')
         self.assertTrue(user_message_content.startswith("<tools>"))
 
+    async def test_d_multimodal_rendering(self):
+        """测试多模态（文本+图片）渲染"""
+        # Create a dummy image file for the test
+        dummy_image_path = "test_dummy_image.png"
+        with open(dummy_image_path, "w") as f:
+            f.write("dummy content")
+
+        messages = Messages(
+            UserMessage(
+                Texts("prompt", "Describe the image."),
+                Images(dummy_image_path) # Test with optional name
+            )
+        )
+
+        rendered = await messages.render_latest()
+        self.assertEqual(len(rendered), 1)
+
+        content = rendered[0]['content']
+        self.assertIsInstance(content, list)
+        self.assertEqual(len(content), 2)
+
+        # Check text part
+        self.assertEqual(content[0]['type'], 'text')
+        self.assertEqual(content[0]['text'], 'Describe the image.')
+
+        # Check image part
+        self.assertEqual(content[1]['type'], 'image_url')
+        self.assertIn('data:image/png;base64,', content[1]['image_url']['url'])
+
+        # Clean up the dummy file
+        import os
+        os.remove(dummy_image_path)
+
+    async def test_e_multimodal_type_switching(self):
+        """测试多模态消息在pop图片后是否能正确回退到字符串渲染"""
+        dummy_image_path = "test_dummy_image_2.png"
+        with open(dummy_image_path, "w") as f:
+            f.write("dummy content")
+
+        messages = Messages(
+            UserMessage(
+                Texts("prefix", "Look at this:"),
+                Images(dummy_image_path, name="image"), # Explicit name for popping
+                Texts("suffix", "Any thoughts?")
+            )
+        )
+
+        # 1. Initial multimodal render
+        rendered_multi = await messages.render_latest()
+        content_multi = rendered_multi[0]['content']
+        self.assertIsInstance(content_multi, list)
+        self.assertEqual(len(content_multi), 3) # prefix, image, suffix
+
+        # 2. Pop the image
+        popped_image = messages.pop("image")
+        self.assertIsNotNone(popped_image)
+
+        # 3. Render again, should fall back to string content
+        rendered_str = messages.render() # No refresh needed
+        content_str = rendered_str[0]['content']
+        self.assertIsInstance(content_str, str)
+        self.assertEqual(content_str, "Look at this:\n\nAny thoughts?")
+
+        # Clean up
+        import os
+        os.remove(dummy_image_path)
+
+    def test_f_message_merging(self):
+        """测试初始化和追加时自动合并消息的功能"""
+        # 1. Test merging during initialization
+        messages = Messages(
+            UserMessage(Texts("part1", "Hello,")),
+            UserMessage(Texts("part2", "world!")),
+            SystemMessage(Texts("system", "System prompt.")),
+            UserMessage(Texts("part3", "How are you?"))
+        )
+        # Should be merged into: User, System, User
+        self.assertEqual(len(messages), 3)
+        self.assertEqual(len(messages[0]._items), 2) # First UserMessage has 2 items
+        self.assertEqual(messages[0]._items[1].name, "part2")
+        self.assertEqual(messages[1].role, "system")
+        self.assertEqual(messages[2].role, "user")
+
+        # 2. Test merging during append
+        messages.append(UserMessage(Texts("part4", "I am fine.")))
+        self.assertEqual(len(messages), 3) # Still 3 messages
+        self.assertEqual(len(messages[2]._items), 2) # Last UserMessage now has 2 items
+        self.assertEqual(messages[2]._items[1].name, "part4")
+
+        # 3. Test appending a different role
+        messages.append(SystemMessage(Texts("system2", "Another prompt.")))
+        self.assertEqual(len(messages), 4) # Should not merge
+        self.assertEqual(messages[3].role, "system")
+
+    async def test_g_state_inconsistency_on_direct_message_modification(self):
+        """
+        测试当直接在 Message 对象上执行 pop 操作时，
+        顶层 Messages 对象的 _providers_index 是否会产生不一致。
+        """
+        messages = Messages(
+            SystemMessage(self.system_prompt_provider, self.tools_provider),
+            UserMessage(self.files_provider)
+        )
+
+        # 0. 先刷新一次，确保所有 provider 的 cache 都已填充
+        await messages.refresh()
+
+        # 1. 初始状态：'tools' 提供者应该在索引中
+        self.assertIsNotNone(messages.provider("tools"), "初始状态下 'tools' 提供者应该能被找到")
+        self.assertIs(messages.provider("tools"), self.tools_provider)
+
+        # 2. 直接在子消息对象上执行 pop 操作
+        system_message = messages[0]
+        popped_provider = system_message.pop("tools")
+
+        # 验证是否真的从 Message 对象中弹出了
+        self.assertIs(popped_provider, self.tools_provider, "应该从 SystemMessage 中成功弹出 provider")
+        self.assertNotIn(self.tools_provider, system_message.providers(), "provider 不应再存在于 SystemMessage 的 providers 列表中")
+
+        # 3. 核心问题：检查顶层 Messages 的索引
+        # 在理想情况下，直接修改子消息应该同步更新顶层索引。
+        # 因此，我们断言 provider 现在应该是找不到的。这个测试现在应该会失败。
+        provider_after_pop = messages.provider("tools")
+        self.assertIsNone(provider_after_pop, "BUG: 直接从子消息中 pop 后，顶层索引未同步，仍然可以找到 provider")
+
+        # 4. 进一步验证：渲染结果和索引内容不一致
+        # 渲染结果应该不再包含 tools 内容，因为 Message 对象本身是正确的
+        rendered_messages = messages.render()
+        self.assertGreater(len(rendered_messages), 0, "渲染后的消息列表不应为空")
+        rendered_content = rendered_messages[0]['content']
+        self.assertNotIn("<tools>", rendered_content, "渲染结果中不应再包含 'tools' 的内容，证明数据源已更新")
+
+
 if __name__ == '__main__':
     # 为了在普通脚本环境中运行，添加这两行
     suite = unittest.TestSuite()
     suite.addTest(unittest.makeSuite(TestContextManagement))
     runner = unittest.TextTestRunner()
-    runner.run(suite)
+    runner.run(suite)

{aient-1.1.90.dist-info → aient-1.1.91.dist-info}/METADATA

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

{aient-1.1.90.dist-info → aient-1.1.91.dist-info}/RECORD

@@ -1,7 +1,7 @@
 aient/__init__.py,sha256=SRfF7oDVlOOAi6nGKiJIUK6B_arqYLO9iSMp-2IZZps,21
-aient/architext/test.py,sha256=nLrF8AkVO1minNf8Us1FS4YkGuXhwMTp8E-VRUvUXh8,4115
+aient/architext/test.py,sha256=n2hUwHOPhOdpHRLCPuqeR-r4hGK43SF1WKaLdivdmC8,10021
 aient/architext/architext/__init__.py,sha256=79Ih1151rfcqZdr7F8HSZSTs_iT2SKd1xCkehMsXeXs,19
-aient/architext/architext/core.py,sha256=l-bjazODG5tkYQ_fVS8df-xg0TFkBK5oVOF8Uz5Wdqg,7843
+aient/architext/architext/core.py,sha256=vww5nxNyoGXmWwmNEfLMGfv7k4GhCDZSiRqKzyqYv_8,10070
 aient/core/__init__.py,sha256=NxjebTlku35S4Dzr16rdSqSTWUvvwEeACe8KvHJnjPg,34
 aient/core/log_config.py,sha256=kz2_yJv1p-o3lUQOwA3qh-LSc3wMHv13iCQclw44W9c,274
 aient/core/models.py,sha256=KMlCRLjtq1wQHZTJGqnbWhPS2cHq6eLdnk7peKDrzR8,7490
@@ -33,8 +33,8 @@ aient/plugins/write_file.py,sha256=Jt8fOEwqhYiSWpCbwfAr1xoi_BmFnx3076GMhuL06uI,3
 aient/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aient/utils/prompt.py,sha256=UcSzKkFE4-h_1b6NofI6xgk3GoleqALRKY8VBaXLjmI,11311
 aient/utils/scripts.py,sha256=VqtK4RFEx7KxkmcqG3lFDS1DxoNlFFGErEjopVcc8IE,40974
-aient-1.1.90.dist-info/licenses/LICENSE,sha256=XNdbcWldt0yaNXXWB_Bakoqnxb3OVhUft4MgMA_71ds,1051
-aient-1.1.90.dist-info/METADATA,sha256=IHi6EZF4kBr85Ape07JXmYtzBlwha3yNkst8uf9oSEQ,4842
-aient-1.1.90.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aient-1.1.90.dist-info/top_level.txt,sha256=3oXzrP5sAVvyyqabpeq8A2_vfMtY554r4bVE-OHBrZk,6
-aient-1.1.90.dist-info/RECORD,,
+aient-1.1.91.dist-info/licenses/LICENSE,sha256=XNdbcWldt0yaNXXWB_Bakoqnxb3OVhUft4MgMA_71ds,1051
+aient-1.1.91.dist-info/METADATA,sha256=SByLoF4YtLoR1QxQ1qmVim3FbMHQIgD-b1OcxliO4bw,4842
+aient-1.1.91.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aient-1.1.91.dist-info/top_level.txt,sha256=3oXzrP5sAVvyyqabpeq8A2_vfMtY554r4bVE-OHBrZk,6
+aient-1.1.91.dist-info/RECORD,,