chatterer 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

chatterer/__init__.py

@@ -2,6 +2,7 @@ from .language_model import Chatterer
 from .messages import (
     AIMessage,
     BaseMessage,
+    FunctionMessage,
     HumanMessage,
     SystemMessage,
 )
@@ -16,9 +17,17 @@ from .tools import (
     citation_chunker,
     get_default_html_to_markdown_options,
     html_to_markdown,
+    init_webpage_to_markdown,
     pdf_to_text,
     pyscripts_to_snippets,
 )
+from .utils import (
+    Base64Image,
+    CodeExecutionResult,
+    FunctionSignature,
+    get_default_repl_tool,
+    insert_callables_into_global,
+)
 
 __all__ = [
     "BaseStrategy",
@@ -36,4 +45,11 @@ __all__ = [
     "HumanMessage",
     "SystemMessage",
     "AIMessage",
+    "FunctionMessage",
+    "Base64Image",
+    "init_webpage_to_markdown",
+    "FunctionSignature",
+    "CodeExecutionResult",
+    "get_default_repl_tool",
+    "insert_callables_into_global",
 ]

chatterer/language_model.py

@@ -2,9 +2,12 @@ from typing import (
     TYPE_CHECKING,
     Any,
     AsyncIterator,
+    Callable,
+    Iterable,
     Iterator,
     Optional,
     Self,
+    Sequence,
     Type,
     TypeAlias,
     TypeVar,
@@ -18,15 +21,39 @@ from langchain_core.runnables.base import Runnable
 from langchain_core.runnables.config import RunnableConfig
 from pydantic import BaseModel, Field
 
-from .messages import AIMessage, BaseMessage, HumanMessage
+from .messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
+from .utils.code_agent import CodeExecutionResult, FunctionSignature
 
 if TYPE_CHECKING:
     from instructor import Partial
+    from langchain_experimental.tools.python.tool import PythonAstREPLTool
 
 PydanticModelT = TypeVar("PydanticModelT", bound=BaseModel)
 StructuredOutputType: TypeAlias = dict[object, object] | BaseModel
 
-DEFAULT_IMAGE_DESCRIPTION_INSTRUCTION = "Just describe all the details you see in the image in few sentences."
+DEFAULT_IMAGE_DESCRIPTION_INSTRUCTION = "Provide a detailed description of all visible elements in the image, summarizing key details in a few clear sentences."
+DEFAULT_CODE_GENERATION_PROMPT = (
+    "You are utilizing a Python code execution tool now.\n"
+    "Your goal is to generate Python code that solves the task efficiently and appends both the code and its output to your context memory.\n"
+    "Since your context window is highly limited, type `pass` if no code execution is needed.\n"
+    "\n"
+    "To optimize tool efficiency, follow these guidelines:\n"
+    "- Write concise, efficient code that directly serves the intended purpose.\n"
+    "- Avoid unnecessary operations (e.g., excessive loops, recursion, or heavy computations).\n"
+    "- Handle potential errors gracefully (e.g., using try-except blocks).\n"
+    "- Prevent excessive output by limiting print statements to essential information only (e.g., avoid printing large datasets).\n"
+    "\n"
+    "Return your response strictly in the following JSON format:\n"
+    '{\n  "code": "<your_python_code_here>"\n}\n\n'
+)
+
+
+DEFAULT_FUNCTION_REFERENCE_PREFIX_PROMPT = (
+    "Below functions are included in global scope and can be used in your code.\n"
+    "Do not try to redefine the function(s).\n"
+    "You don't have to force yourself to use these tools - use them only when you need to.\n"
+)
+DEFAULT_FUNCTION_REFERENCE_SEPARATOR = "\n---\n"  # Separator to distinguish different function references
 
 
 class Chatterer(BaseModel):
@@ -288,6 +315,82 @@ class Chatterer(BaseModel):
         except Exception:
             return None
 
+    def invoke_code_execution(
+        self,
+        messages: LanguageModelInput,
+        repl_tool: Optional["PythonAstREPLTool"] = None,
+        prompt_for_code_invoke: Optional[str] = DEFAULT_CODE_GENERATION_PROMPT,
+        additional_callables: Optional[Callable[..., object] | Sequence[Callable[..., object]]] = None,
+        function_reference_prefix: Optional[str] = DEFAULT_FUNCTION_REFERENCE_PREFIX_PROMPT,
+        function_reference_seperator: str = DEFAULT_FUNCTION_REFERENCE_SEPARATOR,
+        config: Optional[RunnableConfig] = None,
+        stop: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> CodeExecutionResult:
+        function_signatures: Optional[list[FunctionSignature]] = None
+        if additional_callables:
+            if not isinstance(additional_callables, Iterable):
+                additional_callables = (additional_callables,)
+            function_signatures = FunctionSignature.from_callables(additional_callables)
+            messages = _add_message_last(
+                messages=messages,
+                prompt_to_add=FunctionSignature.as_prompt(
+                    function_signatures, function_reference_prefix, function_reference_seperator
+                ),
+            )
+        if prompt_for_code_invoke:
+            messages = _add_message_last(messages=messages, prompt_to_add=prompt_for_code_invoke)
+        code_obj: PythonCodeToExecute = self.generate_pydantic(
+            response_model=PythonCodeToExecute, messages=messages, config=config, stop=stop, **kwargs
+        )
+        return CodeExecutionResult.from_code(
+            code=code_obj.code,
+            config=config,
+            repl_tool=repl_tool,
+            function_signatures=function_signatures,
+            **kwargs,
+        )
+
+    async def ainvoke_code_execution(
+        self,
+        messages: LanguageModelInput,
+        repl_tool: Optional["PythonAstREPLTool"] = None,
+        prompt_for_code_invoke: Optional[str] = DEFAULT_CODE_GENERATION_PROMPT,
+        additional_callables: Optional[Callable[..., object] | Sequence[Callable[..., object]]] = None,
+        function_reference_prefix: Optional[str] = DEFAULT_FUNCTION_REFERENCE_PREFIX_PROMPT,
+        function_reference_seperator: str = DEFAULT_FUNCTION_REFERENCE_SEPARATOR,
+        config: Optional[RunnableConfig] = None,
+        stop: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> CodeExecutionResult:
+        function_signatures: Optional[list[FunctionSignature]] = None
+        if additional_callables:
+            if not isinstance(additional_callables, Iterable):
+                additional_callables = (additional_callables,)
+            function_signatures = FunctionSignature.from_callables(additional_callables)
+            messages = _add_message_last(
+                messages=messages,
+                prompt_to_add=FunctionSignature.as_prompt(
+                    function_signatures, function_reference_prefix, function_reference_seperator
+                ),
+            )
+        if prompt_for_code_invoke:
+            messages = _add_message_last(messages=messages, prompt_to_add=prompt_for_code_invoke)
+        code_obj: PythonCodeToExecute = await self.agenerate_pydantic(
+            response_model=PythonCodeToExecute, messages=messages, config=config, stop=stop, **kwargs
+        )
+        return await CodeExecutionResult.afrom_code(
+            code=code_obj.code,
+            config=config,
+            repl_tool=repl_tool,
+            function_signatures=function_signatures,
+            **kwargs,
+        )
+
+
+class PythonCodeToExecute(BaseModel):
+    code: str = Field(description="Python code to execute")
+
 
 def with_structured_output(
     client: BaseChatModel,
@@ -297,75 +400,93 @@ def with_structured_output(
     return client.with_structured_output(schema=response_model, **structured_output_kwargs)  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
 
 
-if __name__ == "__main__":
-    import asyncio
-
-    # 테스트용 Pydantic 모델 정의
-    class Propositions(BaseModel):
-        proposition_topic: str
-        proposition_content: str
-
-    chatterer = Chatterer.openai()
-    prompt = "What is the meaning of life?"
-
-    # === Synchronous Tests ===
-
-    # generate
-    print("=== Synchronous generate ===")
-    result_sync = chatterer(prompt)
-    print("Result (generate):", result_sync)
-
-    # generate_stream
-    print("\n=== Synchronous generate_stream ===")
-    for i, chunk in enumerate(chatterer.generate_stream(prompt)):
-        print(f"Chunk {i}:", chunk)
-
-    # generate_pydantic
-    print("\n=== Synchronous generate_pydantic ===")
-    result_pydantic = chatterer(prompt, Propositions)
-    print("Result (generate_pydantic):", result_pydantic)
-
-    # generate_pydantic_stream
-    print("\n=== Synchronous generate_pydantic_stream ===")
-    for i, chunk in enumerate(chatterer.generate_pydantic_stream(Propositions, prompt)):
-        print(f"Pydantic Chunk {i}:", chunk)
-
-    # === Asynchronous Tests ===
-
-    # Async helper function to enumerate async iterator
-    async def async_enumerate(aiter: AsyncIterator[Any], start: int = 0) -> AsyncIterator[tuple[int, Any]]:
-        i = start
-        async for item in aiter:
-            yield i, item
-            i += 1
-
-    async def run_async_tests():
-        # 6. agenerate
-        print("\n=== Asynchronous agenerate ===")
-        result_async = await chatterer.agenerate(prompt)
-        print("Result (agenerate):", result_async)
-
-        # 7. agenerate_stream
-        print("\n=== Asynchronous agenerate_stream ===")
-        async for i, chunk in async_enumerate(chatterer.agenerate_stream(prompt)):
-            print(f"Async Chunk {i}:", chunk)
-
-        # 8. agenerate_pydantic
-        print("\n=== Asynchronous agenerate_pydantic ===")
-        try:
-            result_async_pydantic = await chatterer.agenerate_pydantic(Propositions, prompt)
-            print("Result (agenerate_pydantic):", result_async_pydantic)
-        except Exception as e:
-            print("Error in agenerate_pydantic:", e)
+def _add_message_last(messages: LanguageModelInput, prompt_to_add: str) -> LanguageModelInput:
+    if isinstance(messages, str):
+        messages += f"\n{prompt_to_add}"
+    elif isinstance(messages, Sequence):
+        messages = list(messages)
+        messages.append(SystemMessage(content=prompt_to_add))
+    else:
+        messages = messages.to_messages()
+        messages.append(SystemMessage(content=prompt_to_add))
+    return messages
 
-        # 9. agenerate_pydantic_stream
-        print("\n=== Asynchronous agenerate_pydantic_stream ===")
-        try:
-            i = 0
-            async for chunk in chatterer.agenerate_pydantic_stream(Propositions, prompt):
-                print(f"Async Pydantic Chunk {i}:", chunk)
-                i += 1
-        except Exception as e:
-            print("Error in agenerate_pydantic_stream:", e)
-
-    asyncio.run(run_async_tests())
+
+# def _add_message_first(messages: LanguageModelInput, prompt_to_add: str) -> LanguageModelInput:
+#     if isinstance(messages, str):
+#         messages = f"{prompt_to_add}\n{messages}"
+#     elif isinstance(messages, Sequence):
+#         messages = list(messages)
+#         messages.insert(0, SystemMessage(content=prompt_to_add))
+#     else:
+#         messages = messages.to_messages()
+#         messages.insert(0, SystemMessage(content=prompt_to_add))
+#     return messages
+
+
+def chatbot_example(chatterer: Chatterer = Chatterer.openai()) -> None:
+    # Define the CodeExecutionDecision class using Pydantic
+
+    from rich.console import Console
+    from rich.prompt import Prompt
+
+    class CodeExecutionDecision(BaseModel):
+        is_code_execution_needed: bool = Field(
+            description="Whether Python tool calling is needed to answer user query."
+        )
+
+    # Initialize Rich console
+    console = Console()
+
+    # Initialize conversation context
+    context: list[BaseMessage] = [SystemMessage("You are an AI that can answer questions and execute Python code.")]
+
+    # Display welcome message
+    console.print("[bold blue]Welcome to the Rich-based chatbot![/bold blue]")
+    console.print("Type 'quit' or 'exit' to end the conversation.")
+
+    while True:
+        # Get user input
+        user_input = Prompt.ask("[bold green]You[/bold green]")
+        if user_input.lower() in ["quit", "exit"]:
+            console.print("[bold blue]Goodbye![/bold blue]")
+            break
+
+        # Add user message to context
+        context.append(HumanMessage(content=user_input))
+
+        # Determine if code execution is needed
+        decision = chatterer.generate_pydantic(
+            response_model=CodeExecutionDecision,  # Use response_model instead of pydantic_model
+            messages=context,
+        )
+
+        if decision.is_code_execution_needed:
+            # Execute code if needed
+            code_result = chatterer.invoke_code_execution(messages=context)
+            if code_result.code.strip() == "pass":
+                new_message = None
+            else:
+                new_message = SystemMessage(
+                    content=f"Executed code:\n```python\n{code_result.code}\n```\nOutput:\n{code_result.output}"
+                )
+                console.print("[bold yellow]Executed code:[/bold yellow]")
+                console.print(f"[code]{code_result.code}[/code]")
+                console.print("[bold yellow]Output:[/bold yellow]")
+                console.print(code_result.output)
+        else:
+            # No code execution required
+            new_message = None
+
+        # Add system message to context
+        if new_message:
+            context.append(new_message)
+
+        # Generate and display chatbot response
+        response = chatterer.generate(messages=context)  # Use generate instead of generate_response
+        context.append(AIMessage(content=response))
+        console.print(f"[bold blue]Chatbot:[/bold blue] {response}")
+
+
+if __name__ == "__main__":
+    chatbot_example()

chatterer/messages.py

@@ -1,8 +1,9 @@
-from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
+from langchain_core.messages import AIMessage, BaseMessage, FunctionMessage, HumanMessage, SystemMessage
 
 __all__ = [
     "AIMessage",
     "BaseMessage",
     "HumanMessage",
     "SystemMessage",
+    "FunctionMessage",
 ]

chatterer/tools/__init__.py

@@ -7,6 +7,13 @@ from .convert_to_text import (
     pyscripts_to_snippets,
 )
 
+
+def init_webpage_to_markdown():
+    from . import webpage_to_markdown
+
+    return webpage_to_markdown
+
+
 __all__ = [
     "html_to_markdown",
     "anything_to_markdown",
@@ -14,4 +21,5 @@ __all__ = [
     "get_default_html_to_markdown_options",
     "pyscripts_to_snippets",
     "citation_chunker",
+    "init_webpage_to_markdown",
 ]

chatterer/utils/__init__.py

@@ -0,0 +1,15 @@
+from .code_agent import (
+    CodeExecutionResult,
+    FunctionSignature,
+    get_default_repl_tool,
+    insert_callables_into_global,
+)
+from .image import Base64Image
+
+__all__ = [
+    "Base64Image",
+    "FunctionSignature",
+    "CodeExecutionResult",
+    "get_default_repl_tool",
+    "insert_callables_into_global",
+]

chatterer/utils/code_agent.py

@@ -0,0 +1,134 @@
+import inspect
+import textwrap
+from typing import (
+    TYPE_CHECKING,
+    Callable,
+    Iterable,
+    NamedTuple,
+    Optional,
+    Self,
+)
+
+from langchain_core.runnables.config import RunnableConfig
+
+if TYPE_CHECKING:
+    from langchain_experimental.tools import PythonAstREPLTool
+
+
+class FunctionSignature(NamedTuple):
+    name: str
+    callable: Callable[..., object]
+    signature: str
+
+    @classmethod
+    def from_callable(cls, callable: Callable[..., object]) -> Self:
+        """
+        Get the name and signature of a function as a string.
+        """
+        # Determine if the function is async
+        is_async_func = inspect.iscoroutinefunction(callable)
+        function_def = "async def" if is_async_func else "def"
+
+        # Determine the function name based on the type of callable
+        if inspect.isfunction(callable):
+            # For regular Python functions, use __code__.co_name
+            function_name = callable.__code__.co_name
+        elif hasattr(callable, "name"):
+            # For StructuredTool or similar objects with a 'name' attribute
+            function_name = callable.name  # type: ignore
+        elif hasattr(callable, "__name__"):
+            # For other callables with a __name__ attribute
+            function_name = callable.__name__
+        else:
+            # Fallback to the class name if no name is found
+            function_name = type(callable).__name__
+
+        # Build the signature string
+        signature = f"{function_def} {function_name}{inspect.signature(callable)}:"
+        docstring = inspect.getdoc(callable)
+        if docstring:
+            docstring = f'"""{docstring.strip()}"""'
+            return cls(
+                name=function_name, callable=callable, signature=f"{signature}\n{textwrap.indent(docstring, '    ')}"
+            )
+        else:
+            return cls(name=function_name, callable=callable, signature=signature)
+
+    @classmethod
+    def from_callables(cls, callables: Iterable[Callable[..., object]]) -> list[Self]:
+        return [cls.from_callable(callable) for callable in callables]
+
+    @classmethod
+    def as_prompt(
+        cls,
+        callables: Iterable[Self],
+        prefix: Optional[str] = "You can use the pre-made functions below without defining them:\n",
+        sep: str = "\n---\n",
+    ) -> str:
+        """
+        Generate a prompt string from a list of callables.
+        """
+        body: str = sep.join(fsig.signature for fsig in callables)
+        if prefix:
+            return f"{prefix}{body}"
+        return body
+
+
+class CodeExecutionResult(NamedTuple):
+    code: str
+    output: str
+
+    @classmethod
+    def from_code(
+        cls,
+        code: str,
+        repl_tool: Optional["PythonAstREPLTool"] = None,
+        config: Optional[RunnableConfig] = None,
+        function_signatures: Optional[Iterable[FunctionSignature]] = None,
+        **kwargs: object,
+    ) -> Self:
+        """
+        Execute code using the Python Code Execution Language Model.
+        """
+        if repl_tool is None:
+            repl_tool = get_default_repl_tool()
+        if function_signatures is not None:
+            insert_callables_into_global(function_signatures=function_signatures, repl_tool=repl_tool)
+        output = str(repl_tool.invoke(code, config=config, **kwargs))  # pyright: ignore[reportUnknownMemberType]
+        return cls(code=code, output=output)
+
+    @classmethod
+    async def afrom_code(
+        cls,
+        code: str,
+        repl_tool: Optional["PythonAstREPLTool"] = None,
+        config: Optional[RunnableConfig] = None,
+        function_signatures: Optional[Iterable[FunctionSignature]] = None,
+        **kwargs: object,
+    ) -> Self:
+        """
+        Execute code using the Python Code Execution Language Model asynchronously.
+        """
+        if repl_tool is None:
+            repl_tool = get_default_repl_tool()
+        if function_signatures is not None:
+            insert_callables_into_global(function_signatures=function_signatures, repl_tool=repl_tool)
+        output = str(await repl_tool.ainvoke(code, config=config, **kwargs))  # pyright: ignore[reportUnknownMemberType]
+        return cls(code=code, output=output)
+
+
+def get_default_repl_tool() -> "PythonAstREPLTool":
+    from langchain_experimental.tools import PythonAstREPLTool
+
+    return PythonAstREPLTool()
+
+
+def insert_callables_into_global(
+    function_signatures: Iterable[FunctionSignature], repl_tool: "PythonAstREPLTool"
+) -> None:
+    """Insert callables into the REPL tool's globals."""
+    repl_globals: Optional[dict[str, object]] = repl_tool.globals  # pyright: ignore[reportUnknownMemberType]
+    if repl_globals is None:
+        repl_tool.globals = {fsig.name: fsig.callable for fsig in function_signatures}
+    else:
+        repl_globals.update({fsig.name: fsig.callable for fsig in function_signatures})

{chatterer-0.1.8.dist-info → chatterer-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatterer
-Version: 0.1.8
+Version: 0.1.9
 Summary: The highest-level interface for various LLM APIs.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -18,13 +18,16 @@ Requires-Dist: pillow>=11.1.0; extra == "conversion"
 Requires-Dist: mistune>=3.1.2; extra == "conversion"
 Requires-Dist: markitdown>=0.0.2; extra == "conversion"
 Requires-Dist: pymupdf>=1.25.4; extra == "conversion"
+Provides-Extra: langchain
+Requires-Dist: chatterer[langchain-providers]; extra == "langchain"
+Requires-Dist: langchain-experimental>=0.3.4; extra == "langchain"
 Provides-Extra: langchain-providers
 Requires-Dist: langchain-openai>=0.3.7; extra == "langchain-providers"
 Requires-Dist: langchain-anthropic>=0.3.8; extra == "langchain-providers"
 Requires-Dist: langchain-google-genai>=2.0.10; extra == "langchain-providers"
 Requires-Dist: langchain-ollama>=0.2.3; extra == "langchain-providers"
 Provides-Extra: all
-Requires-Dist: chatterer[langchain-providers]; extra == "all"
+Requires-Dist: chatterer[langchain]; extra == "all"
 Requires-Dist: chatterer[conversion]; extra == "all"
 Requires-Dist: chatterer[dev]; extra == "all"
 

{chatterer-0.1.8.dist-info → chatterer-0.1.9.dist-info}/RECORD

@@ -1,11 +1,11 @@
-chatterer/__init__.py,sha256=kl8VWiDJIt5IQjaBpQu13n0GrzP3qzaNXyA68B1xHTE,802
-chatterer/language_model.py,sha256=S8x2IbzZBi1mAKSKrGuoB4-gfKBz73RCNXt_H-fiDzc,13826
-chatterer/messages.py,sha256=-NyOIK7wJI1uVD8qaJPeLA0LqirFEsZ1mOYoO1F2wLc,188
+chatterer/__init__.py,sha256=QqW6ITeJ7Qpt42BvVzTgI8M6vKRYIlwSDa0nMO4NsV0,1209
+chatterer/language_model.py,sha256=J7_iLtfjr-0tNTejrY4_vLiEWGTnRGGUb_x9G2CZ-Vg,20083
+chatterer/messages.py,sha256=OtbZ3two0LUQ4PXES97FDIBUSO3IcMHdFV1VFkDL2mI,229
 chatterer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chatterer/strategies/__init__.py,sha256=SdOggbmHpw4f7Njwy-T8q64e91OLOUp1k0a0ozZd4qI,221
 chatterer/strategies/atom_of_thoughts.py,sha256=CygOCLu5vLk-fzY9O-iE3qLShfjD7iY40ks9jH4ULBM,40872
 chatterer/strategies/base.py,sha256=b2gMPqodp97OP1dkHfj0UqixjdjVhmTw_V5qJ7i2S6g,427
-chatterer/tools/__init__.py,sha256=yA4RcHIAO33xsmWXQTmtSm9bk1p80yJKSadtMa3X-aY,415
+chatterer/tools/__init__.py,sha256=XomZMXHKhMyLprQkCfAKetI_uueHH184xWESjTKJeeA,560
 chatterer/tools/convert_to_text.py,sha256=kBqxCJ0IoiAw2eiPYqep_SPZm-TtYKF7mdACLsWQUuI,15915
 chatterer/tools/citation_chunking/__init__.py,sha256=gG7Fnkkp28UpcWMbfMY_4gqzZSZ8QzlhalHBoeoq7K0,82
 chatterer/tools/citation_chunking/chunks.py,sha256=50Dpa43RaYftlNox8tM1qI8htZ3_AJ9Uyyn02WsmxYk,2173
@@ -17,8 +17,10 @@ chatterer/tools/citation_chunking/utils.py,sha256=M4pH2-UIE1VLzQLXDqjEe4L3Xcy0e0
 chatterer/tools/webpage_to_markdown/__init__.py,sha256=bHH4qfnXyw8Zz-yBPLaTezF1sh9njvNBJmhBVtcpjsA,123
 chatterer/tools/webpage_to_markdown/playwright_bot.py,sha256=yP0KixYZNQ4Kn_ZCFDI3mVyBD_DpUGfqgklpaGJUTCU,27496
 chatterer/tools/webpage_to_markdown/utils.py,sha256=ZLUU94imYciEdynD2K7Dmcsbt8BVQTaOP56Ba6DAFvk,12593
+chatterer/utils/__init__.py,sha256=8nzpFJKU_wSRPH6LBP6HRBotPMrSl_VO9UlmFprTrK0,334
+chatterer/utils/code_agent.py,sha256=phMMXHeZNkzHrySX72y50IW3-o2MOSriPV9IUPQd4nU,4973
 chatterer/utils/image.py,sha256=F3_D1677UDFlgp-UQBS_ChkNODzf_VOfjYNSUi02MaI,10852
-chatterer-0.1.8.dist-info/METADATA,sha256=01CGNp0oae5VdHM5gzqPKYFtlSqufE0h5XFMdn2E_6c,4234
-chatterer-0.1.8.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-chatterer-0.1.8.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
-chatterer-0.1.8.dist-info/RECORD,,
+chatterer-0.1.9.dist-info/METADATA,sha256=GbjuJgbQJ09TEYt7lvI96Od5saTZ_y0KDzmybsW-0H0,4388
+chatterer-0.1.9.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+chatterer-0.1.9.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
+chatterer-0.1.9.dist-info/RECORD,,