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

chatterer/__init__.py

@@ -1,4 +1,4 @@
-from .language_model import Chatterer
+from .language_model import Chatterer, interactive_shell
 from .messages import (
     AIMessage,
     BaseMessage,
@@ -16,10 +16,12 @@ from .tools import (
     anything_to_markdown,
     citation_chunker,
     get_default_html_to_markdown_options,
+    get_youtube_video_subtitle,
     html_to_markdown,
     init_webpage_to_markdown,
     pdf_to_text,
     pyscripts_to_snippets,
+    get_youtube_video_details,
 )
 from .utils import (
     Base64Image,
@@ -52,4 +54,7 @@ __all__ = [
     "CodeExecutionResult",
     "get_default_repl_tool",
     "insert_callables_into_global",
+    "get_youtube_video_subtitle",
+    "get_youtube_video_details",
+    "interactive_shell",
 ]

chatterer/language_model.py

@@ -22,7 +22,7 @@ from langchain_core.runnables.config import RunnableConfig
 from pydantic import BaseModel, Field
 
 from .messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
-from .utils.code_agent import CodeExecutionResult, FunctionSignature
+from .utils.code_agent import CodeExecutionResult, FunctionSignature, get_default_repl_tool
 
 if TYPE_CHECKING:
     from instructor import Partial
@@ -189,7 +189,7 @@ class Chatterer(BaseModel):
         stop: Optional[list[str]] = None,
         **kwargs: Any,
     ) -> PydanticModelT:
-        result: StructuredOutputType = with_structured_output(
+        result: StructuredOutputType = _with_structured_output(
             client=self.client,
             response_model=response_model,
             structured_output_kwargs=self.structured_output_kwargs,
@@ -207,7 +207,7 @@ class Chatterer(BaseModel):
         stop: Optional[list[str]] = None,
         **kwargs: Any,
     ) -> PydanticModelT:
-        result: StructuredOutputType = await with_structured_output(
+        result: StructuredOutputType = await _with_structured_output(
             client=self.client,
             response_model=response_model,
             structured_output_kwargs=self.structured_output_kwargs,
@@ -231,7 +231,7 @@ class Chatterer(BaseModel):
             raise ImportError("Please install `instructor` with `pip install instructor` to use this feature.")
 
         partial_response_model = instructor.Partial[response_model]
-        for chunk in with_structured_output(
+        for chunk in _with_structured_output(
             client=self.client,
             response_model=partial_response_model,
             structured_output_kwargs=self.structured_output_kwargs,
@@ -252,7 +252,7 @@ class Chatterer(BaseModel):
             raise ImportError("Please install `instructor` with `pip install instructor` to use this feature.")
 
         partial_response_model = instructor.Partial[response_model]
-        async for chunk in with_structured_output(
+        async for chunk in _with_structured_output(
             client=self.client,
             response_model=partial_response_model,
             structured_output_kwargs=self.structured_output_kwargs,
@@ -320,26 +320,24 @@ class Chatterer(BaseModel):
         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_signatures: Optional[FunctionSignature | Iterable[FunctionSignature]] = 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)
+        if not function_signatures:
+            function_signatures = []
+        elif isinstance(function_signatures, FunctionSignature):
+            function_signatures = [function_signatures]
+        messages = augment_prompt_for_toolcall(
+            function_signatures=function_signatures,
+            messages=messages,
+            prompt_for_code_invoke=prompt_for_code_invoke,
+            function_reference_prefix=function_reference_prefix,
+            function_reference_seperator=function_reference_seperator,
+        )
         code_obj: PythonCodeToExecute = self.generate_pydantic(
             response_model=PythonCodeToExecute, messages=messages, config=config, stop=stop, **kwargs
         )
@@ -363,19 +361,14 @@ class Chatterer(BaseModel):
         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)
+        function_signatures: list[FunctionSignature] = FunctionSignature.from_callable(additional_callables)
+        messages = augment_prompt_for_toolcall(
+            function_signatures=function_signatures,
+            messages=messages,
+            prompt_for_code_invoke=prompt_for_code_invoke,
+            function_reference_prefix=function_reference_prefix,
+            function_reference_seperator=function_reference_seperator,
+        )
         code_obj: PythonCodeToExecute = await self.agenerate_pydantic(
             response_model=PythonCodeToExecute, messages=messages, config=config, stop=stop, **kwargs
         )
@@ -392,7 +385,7 @@ class PythonCodeToExecute(BaseModel):
     code: str = Field(description="Python code to execute")
 
 
-def with_structured_output(
+def _with_structured_output(
     client: BaseChatModel,
     response_model: Type["PydanticModelT | Partial[PydanticModelT]"],
     structured_output_kwargs: dict[str, Any],
@@ -424,25 +417,76 @@ def _add_message_last(messages: LanguageModelInput, prompt_to_add: str) -> Langu
 #     return messages
 
 
-def chatbot_example(chatterer: Chatterer = Chatterer.openai()) -> None:
+def augment_prompt_for_toolcall(
+    function_signatures: Iterable[FunctionSignature],
+    messages: LanguageModelInput,
+    prompt_for_code_invoke: Optional[str] = DEFAULT_CODE_GENERATION_PROMPT,
+    function_reference_prefix: Optional[str] = DEFAULT_FUNCTION_REFERENCE_PREFIX_PROMPT,
+    function_reference_seperator: str = DEFAULT_FUNCTION_REFERENCE_SEPARATOR,
+) -> LanguageModelInput:
+    if function_signatures:
+        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)
+    return messages
+
+
+def interactive_shell(
+    chatterer: Chatterer = Chatterer.openai(),
+    system_instruction: BaseMessage | Iterable[BaseMessage] = ([
+        SystemMessage("You are an AI that can answer questions and execute Python code."),
+    ]),
+    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,
+) -> None:
     # Define the CodeExecutionDecision class using Pydantic
 
     from rich.console import Console
     from rich.prompt import Prompt
 
-    class CodeExecutionDecision(BaseModel):
+    class IsCodeExecutionNeeded(BaseModel):
         is_code_execution_needed: bool = Field(
             description="Whether Python tool calling is needed to answer user query."
         )
 
+    class IsFurtherCodeExecutionNeeded(BaseModel):
+        review_on_code_execution: str = Field(description="Review on the code execution.")
+        next_action: str = Field(description="Next action to take.")
+        is_further_code_execution_needed: bool = Field(
+            description="Whether further Python tool calling is needed to answer user query."
+        )
+
+    # Get default REPL tool if not provided.
+    # This tool namespace is persistent across multiple code executions.
+    if repl_tool is None:
+        repl_tool = get_default_repl_tool()
+
+    function_signatures: list[FunctionSignature] = FunctionSignature.from_callable(additional_callables)
+
     # Initialize Rich console
     console = Console()
 
     # Initialize conversation context
-    context: list[BaseMessage] = [SystemMessage("You are an AI that can answer questions and execute Python code.")]
+    context: list[BaseMessage] = []
+    if system_instruction:
+        if isinstance(system_instruction, BaseMessage):
+            context.append(system_instruction)
+        else:
+            context.extend(system_instruction)
 
     # Display welcome message
-    console.print("[bold blue]Welcome to the Rich-based chatbot![/bold blue]")
+    console.print("[bold blue]Welcome to the Interactive Chatterer Shell![/bold blue]")
     console.print("Type 'quit' or 'exit' to end the conversation.")
 
     while True:
@@ -457,36 +501,80 @@ def chatbot_example(chatterer: Chatterer = Chatterer.openai()) -> None:
 
         # Determine if code execution is needed
         decision = chatterer.generate_pydantic(
-            response_model=CodeExecutionDecision,  # Use response_model instead of pydantic_model
-            messages=context,
+            response_model=IsCodeExecutionNeeded,  # Use response_model instead of pydantic_model
+            messages=augment_prompt_for_toolcall(
+                function_signatures=function_signatures,
+                messages=context,
+                prompt_for_code_invoke=prompt_for_code_invoke,
+                function_reference_prefix=function_reference_prefix,
+                function_reference_seperator=function_reference_seperator,
+            ),
         )
 
         if decision.is_code_execution_needed:
             # Execute code if needed
-            code_result = chatterer.invoke_code_execution(messages=context)
+            code_result = chatterer.invoke_code_execution(
+                messages=context,
+                repl_tool=repl_tool,
+                prompt_for_code_invoke=prompt_for_code_invoke,
+                function_signatures=function_signatures,
+                function_reference_prefix=function_reference_prefix,
+                function_reference_seperator=function_reference_seperator,
+                config=config,
+                stop=stop,
+                **kwargs,
+            )
+
             if code_result.code.strip() == "pass":
-                new_message = None
+                tool_use_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)
+                code_session_messages: list[BaseMessage] = []
+                while True:
+                    code_execution_message = SystemMessage(
+                        content=f"Executed code:\n```python\n{code_result.code}\n```\nOutput:\n{code_result.output}"
+                    )
+                    code_session_messages.append(code_execution_message)
+                    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)
+
+                    decision = chatterer.generate_pydantic(
+                        response_model=IsFurtherCodeExecutionNeeded,  # Use response_model instead of pydantic_model
+                        messages=augment_prompt_for_toolcall(
+                            function_signatures=function_signatures,
+                            messages=context + code_session_messages,
+                            prompt_for_code_invoke=prompt_for_code_invoke,
+                            function_reference_prefix=function_reference_prefix,
+                            function_reference_seperator=function_reference_seperator,
+                        ),
+                    )
+                    review_on_code_execution = decision.review_on_code_execution
+                    next_action = decision.next_action
+                    console.print("[bold blue]AI:[/bold blue]")
+                    console.print(f"-[bold yellow]Review on code execution:[/bold yellow] {review_on_code_execution}")
+                    console.print(f"-[bold yellow]Next Action:[/bold yellow] {next_action}")
+                    code_session_messages.append(
+                        AIMessage(
+                            content=f"- Review upon code execution: {decision.review_on_code_execution}\n- Next Action: {decision.next_action}"
+                        )
+                    )
+                    if not decision.is_further_code_execution_needed:
+                        tool_use_message = code_execution_message
+                        break
         else:
             # No code execution required
-            new_message = None
+            tool_use_message = None
 
         # Add system message to context
-        if new_message:
-            context.append(new_message)
+        if tool_use_message:
+            context.append(tool_use_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}")
+        console.print(f"[bold blue]AI:[/bold blue] {response}")
 
 
 if __name__ == "__main__":
-    chatbot_example()
+    interactive_shell()

chatterer/tools/__init__.py

@@ -6,6 +6,7 @@ from .convert_to_text import (
     pdf_to_text,
     pyscripts_to_snippets,
 )
+from .youtube import get_youtube_video_subtitle, get_youtube_video_details
 
 
 def init_webpage_to_markdown():
@@ -22,4 +23,6 @@ __all__ = [
     "pyscripts_to_snippets",
     "citation_chunker",
     "init_webpage_to_markdown",
+    "get_youtube_video_subtitle",
+    "get_youtube_video_details",
 ]

chatterer/tools/youtube.py

@@ -0,0 +1,132 @@
+import json
+import unicodedata
+import urllib.parse
+from dataclasses import dataclass
+from typing import Any, Optional, Self, cast
+
+import requests
+
+
+def get_youtube_video_details(
+    query: str,
+) -> list[dict[str, Optional[str]]]:
+    """Search for video metadata on YouTube using the given query. Returns a list of dictionaries containing `video_id`, `title`, `channel`, `duration`, `views`, `publish_time`, and `long_desc`."""
+    return [
+        {
+            "video_id": video_id,
+            "title": video.title,
+            "channel": video.channel,
+            "duration": video.duration,
+            "views": video.views,
+            "publish_time": video.publish_time,
+            "long_desc": video.long_desc,
+        }
+        for video in YoutubeSearchResult.from_query(base_url="https://youtube.com", query=query, max_results=10)
+        if (video_id := _get_video_id(video.url_suffix))
+    ]
+
+
+def get_youtube_video_subtitle(video_id: str) -> str:
+    """Get the transcript of a YouTube video using the given video ID."""
+
+    from youtube_transcript_api._api import YouTubeTranscriptApi
+
+    get_transcript = YouTubeTranscriptApi.get_transcript  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+    list_transcripts = YouTubeTranscriptApi.list_transcripts  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+
+    result: str = ""
+    buffer_timestamp: str = "0s"
+    buffer_texts: list[str] = []
+    for entry in get_transcript(video_id, languages=(next(iter(list_transcripts(video_id))).language_code,)):  # pyright: ignore[reportUnknownVariableType]
+        entry = cast(dict[object, object], entry)
+        text: str = str(entry.get("text", "")).strip().replace("\n", " ")
+        if not text:
+            continue
+        if len(buffer_texts) >= 10 or _is_special_char(text) or (buffer_texts and _is_special_char(buffer_texts[-1])):
+            result += f"[{buffer_timestamp}] {'. '.join(buffer_texts)}\n"
+            start = entry.get("start", 0)
+            if start:
+                buffer_timestamp = f"{start:.0f}s"
+            buffer_texts = [text]
+        else:
+            buffer_texts.append(text)
+
+    if buffer_texts:
+        result += f"[{buffer_timestamp}] {' '.join(buffer_texts)}"
+    return result
+
+
+def _get_video_id(suffix: str) -> str:
+    return next(iter(urllib.parse.parse_qs(urllib.parse.urlparse(suffix).query)["v"]), "")
+
+
+def _is_special_char(text: str) -> bool:
+    if not text:
+        return False
+    return not unicodedata.category(text[0]).startswith("L")
+
+
+@dataclass
+class YoutubeSearchResult:
+    url_suffix: str
+    id: Optional[str]
+    thumbnails: list[str]
+    title: Optional[str]
+    long_desc: Optional[str]
+    channel: Optional[str]
+    duration: Optional[str]
+    views: Optional[str]
+    publish_time: Optional[str]
+
+    @classmethod
+    def from_query(cls, base_url: str, query: str, max_results: int) -> list[Self]:
+        url: str = f"{base_url}/results?search_query={urllib.parse.quote_plus(query)}"
+        response: str = requests.get(url).text
+        while "ytInitialData" not in response:
+            response = requests.get(url).text
+        results: list[Self] = cls.parse_html(response)
+        return results[:max_results]
+
+    @classmethod
+    def parse_html(cls, html: str) -> list[Self]:
+        results: list[Self] = []
+        start: int = html.index("ytInitialData") + len("ytInitialData") + 3
+        end: int = html.index("};", start) + 1
+        data: Any = json.loads(html[start:end])
+        for contents in data["contents"]["twoColumnSearchResultsRenderer"]["primaryContents"]["sectionListRenderer"][
+            "contents"
+        ]:
+            for video in contents["itemSectionRenderer"]["contents"]:
+                if "videoRenderer" in video.keys():
+                    video_data = video.get("videoRenderer", {})
+                    suffix = (
+                        video_data.get("navigationEndpoint", {})
+                        .get("commandMetadata", {})
+                        .get("webCommandMetadata", {})
+                        .get("url", None)
+                    )
+                    if not suffix:
+                        continue
+                    res = cls(
+                        id=video_data.get("videoId", None),
+                        thumbnails=[
+                            thumb.get("url", None) for thumb in video_data.get("thumbnail", {}).get("thumbnails", [{}])
+                        ],
+                        title=video_data.get("title", {}).get("runs", [[{}]])[0].get("text", None),
+                        long_desc=video_data.get("descriptionSnippet", {}).get("runs", [{}])[0].get("text", None),
+                        channel=video_data.get("longBylineText", {}).get("runs", [[{}]])[0].get("text", None),
+                        duration=video_data.get("lengthText", {}).get("simpleText", 0),
+                        views=video_data.get("viewCountText", {}).get("simpleText", 0),
+                        publish_time=video_data.get("publishedTimeText", {}).get("simpleText", 0),
+                        url_suffix=suffix,
+                    )
+                    results.append(res)
+
+            if results:
+                break
+        return results
+
+
+if __name__ == "__main__":
+    print(get_youtube_video_details("BTS"))
+    # print(get_youtube_transcript("y7jrpS8GHxs"))

chatterer/utils/code_agent.py

@@ -21,7 +21,15 @@ class FunctionSignature(NamedTuple):
     signature: str
 
     @classmethod
-    def from_callable(cls, callable: Callable[..., object]) -> Self:
+    def from_callable(cls, callables: Optional[Callable[..., object] | Iterable[Callable[..., object]]]) -> list[Self]:
+        if callables is None:
+            return []
+        if callable(callables):
+            return [cls._from_callable(callables)]
+        return [cls._from_callable(callable) for callable in callables]
+
+    @classmethod
+    def _from_callable(cls, callable: Callable[..., object]) -> Self:
         """
         Get the name and signature of a function as a string.
         """
@@ -54,21 +62,17 @@ class FunctionSignature(NamedTuple):
         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],
+        function_signatures: 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)
+        body: str = sep.join(fsig.signature for fsig in function_signatures)
         if prefix:
             return f"{prefix}{body}"
         return body
@@ -92,7 +96,7 @@ class CodeExecutionResult(NamedTuple):
         """
         if repl_tool is None:
             repl_tool = get_default_repl_tool()
-        if function_signatures is not None:
+        if function_signatures:
             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)
@@ -111,7 +115,7 @@ class CodeExecutionResult(NamedTuple):
         """
         if repl_tool is None:
             repl_tool = get_default_repl_tool()
-        if function_signatures is not None:
+        if function_signatures:
             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)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatterer
-Version: 0.1.9
+Version: 0.1.10
 Summary: The highest-level interface for various LLM APIs.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -18,6 +18,7 @@ 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"
+Requires-Dist: youtube-transcript-api>=1.0.2; extra == "conversion"
 Provides-Extra: langchain
 Requires-Dist: chatterer[langchain-providers]; extra == "langchain"
 Requires-Dist: langchain-experimental>=0.3.4; extra == "langchain"

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

@@ -1,12 +1,13 @@
-chatterer/__init__.py,sha256=QqW6ITeJ7Qpt42BvVzTgI8M6vKRYIlwSDa0nMO4NsV0,1209
-chatterer/language_model.py,sha256=J7_iLtfjr-0tNTejrY4_vLiEWGTnRGGUb_x9G2CZ-Vg,20083
+chatterer/__init__.py,sha256=BPgCQ6VWGBXSh8xJr_0bpM0hcOOUz0KoxcKxOd9GYyI,1388
+chatterer/language_model.py,sha256=qnVC5_W4IYM0y0o1PTYMGXUlblRv5fsRk0zIiL_vT3Q,24491
 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=XomZMXHKhMyLprQkCfAKetI_uueHH184xWESjTKJeeA,560
+chatterer/tools/__init__.py,sha256=hmWIuLJWotGQodL__i4LLbHdXe7Nl5uKHqNke9tHMro,705
 chatterer/tools/convert_to_text.py,sha256=kBqxCJ0IoiAw2eiPYqep_SPZm-TtYKF7mdACLsWQUuI,15915
+chatterer/tools/youtube.py,sha256=5hwASZWA92d_7Y5RqlCK2tULRBQx8bGnE_0NCnvaKi0,5499
 chatterer/tools/citation_chunking/__init__.py,sha256=gG7Fnkkp28UpcWMbfMY_4gqzZSZ8QzlhalHBoeoq7K0,82
 chatterer/tools/citation_chunking/chunks.py,sha256=50Dpa43RaYftlNox8tM1qI8htZ3_AJ9Uyyn02WsmxYk,2173
 chatterer/tools/citation_chunking/citation_chunker.py,sha256=yx5O9pUkowlNcFyyNf7f3sbq7-CV8AXOzFnviDldPR8,4894
@@ -18,9 +19,9 @@ chatterer/tools/webpage_to_markdown/__init__.py,sha256=bHH4qfnXyw8Zz-yBPLaTezF1s
 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/code_agent.py,sha256=UaWdeGzJMPzRSFy9yrxuveBJsvOPSa0te6OuE18bees,5143
 chatterer/utils/image.py,sha256=F3_D1677UDFlgp-UQBS_ChkNODzf_VOfjYNSUi02MaI,10852
-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,,
+chatterer-0.1.10.dist-info/METADATA,sha256=qPx7b41yUvBG0XFH4ra89LIyOSUZUo_8gZ-adVkTKME,4458
+chatterer-0.1.10.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+chatterer-0.1.10.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
+chatterer-0.1.10.dist-info/RECORD,,