chatterer 0.1.9__py3-none-any.whl → 0.1.11__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
@@ -35,13 +35,11 @@ DEFAULT_IMAGE_DESCRIPTION_INSTRUCTION = "Provide a detailed description of all v
 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'
@@ -189,7 +187,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 +205,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 +229,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 +250,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 +318,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 +359,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 +383,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],
@@ -400,93 +391,191 @@ def with_structured_output(
     return client.with_structured_output(schema=response_model, **structured_output_kwargs)  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
 
 
-def _add_message_last(messages: LanguageModelInput, prompt_to_add: str) -> LanguageModelInput:
+# 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
+
+
+def _add_message_first(messages: LanguageModelInput, prompt_to_add: str) -> LanguageModelInput:
     if isinstance(messages, str):
-        messages += f"\n{prompt_to_add}"
+        messages = f"{prompt_to_add}\n{messages}"
     elif isinstance(messages, Sequence):
         messages = list(messages)
-        messages.append(SystemMessage(content=prompt_to_add))
+        messages.insert(0, SystemMessage(content=prompt_to_add))
     else:
         messages = messages.to_messages()
-        messages.append(SystemMessage(content=prompt_to_add))
+        messages.insert(0, SystemMessage(content=prompt_to_add))
     return messages
 
 
-# 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 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_first(
+            messages=messages,
+            prompt_to_add=FunctionSignature.as_prompt(
+                function_signatures, function_reference_prefix, function_reference_seperator
+            ),
+        )
+    if prompt_for_code_invoke:
+        messages = _add_message_first(messages=messages, prompt_to_add=prompt_for_code_invoke)
+    return messages
 
-def chatbot_example(chatterer: Chatterer = Chatterer.openai()) -> None:
-    # Define the CodeExecutionDecision class using Pydantic
 
+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:
     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."
         )
 
-    # Initialize Rich console
-    console = Console()
+    # 추가 코드 실행 필요 여부를 판단하는 모델
+    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."
+        )
+
+    # REPL 도구 초기화
+    if repl_tool is None:
+        repl_tool = get_default_repl_tool()
 
-    # Initialize conversation context
-    context: list[BaseMessage] = [SystemMessage("You are an AI that can answer questions and execute Python code.")]
+    function_signatures: list[FunctionSignature] = FunctionSignature.from_callable(additional_callables)
+    console = Console()
+    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:
-        # 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,
+            response_model=IsCodeExecutionNeeded,
+            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 = AIMessage(
+                        content=f"Executed code:\n```python\n{code_result.code}\n```\nOutput:\n{code_result.output}".strip()
+                    )
+                    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,
+                        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.strip()
+                    next_action = decision.next_action.strip()
+                    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: {review_on_code_execution}\n- Next Action: {next_action}".strip()
+                        )
+                    )
+                    if not decision.is_further_code_execution_needed:
+                        tool_use_message = code_execution_message
+                        break
         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
+            tool_use_message = None
+
+        # 코드 실행 결과 컨텍스트에 추가
+        if tool_use_message:
+            context.append(tool_use_message)
+
+        # AI 응답 스트리밍 출력
+        console.print("[bold blue]AI:[/bold blue] ", end="")
+        response = ""
+        for chunk in chatterer.generate_stream(messages=context):
+            response += chunk
+            console.print(chunk, end="")
+
+        # 전체 응답 처리 후 컨텍스트에 추가
+        lines = response.split("\n")
+        if lines:
+            lines[-1] = lines[-1].rstrip()  # 마지막 줄의 오른쪽 공백 제거
+        response = "\n".join(lines).strip()
         context.append(AIMessage(content=response))
-        console.print(f"[bold blue]Chatbot:[/bold blue] {response}")
+        console.print()  # 응답 후 줄바꿈 추가
 
 
 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,146 @@
+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:
+    urllib_parse_result = urllib.parse.urlparse(suffix)
+    if urllib_parse_result.path.startswith("/shorts/"):
+        # Fore shorts (/shorts/...) the video ID is in the path
+        parts = urllib_parse_result.path.split("/")
+        if len(parts) < 3:
+            print(f"Failed to get video ID from {suffix}")
+            return ""
+        return parts[2]
+
+    query: str = urllib.parse.urlparse(suffix).query
+    query_strings = urllib.parse.parse_qs(query)
+    if "v" not in query_strings:
+        print(f"Failed to get video ID from {suffix}")
+        return ""
+    return next(iter(query_strings["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/utils/image.py

@@ -64,7 +64,7 @@ class Base64Image(BaseModel):
 
     IMAGE_TYPES: ClassVar[tuple[str, ...]] = tuple(map(str, get_args(ImageType)))
     IMAGE_PATTERN: ClassVar[re.Pattern[str]] = re.compile(
-        rf"data:image/({'|'.join(IMAGE_TYPES)});base64,[A-Za-z0-9+/]+={0, 2}$"
+        r"data:image/(" + "|".join(IMAGE_TYPES) + r");base64,([A-Za-z0-9+/]+={0,2})"
     )
 
     def __hash__(self) -> int:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatterer
-Version: 0.1.9
+Version: 0.1.11
 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.11.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=DX_mU855JHHqE0gdnieWZNOwX1BjIO4VK4EightRL3w,24353
 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=GhyE05JBF_eos01A_N-X5tZv4wQJ--IjErBbEBeNBpQ,6037
 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/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/utils/code_agent.py,sha256=UaWdeGzJMPzRSFy9yrxuveBJsvOPSa0te6OuE18bees,5143
+chatterer/utils/image.py,sha256=1imiyq6TB9NIIGx3zAA2OwMWuXlifYIAjwfWRWa4WIM,10858
+chatterer-0.1.11.dist-info/METADATA,sha256=S3hRkxG1DlFc_NGrra1xhniiCDDVoVrow2N96OJy8i0,4458
+chatterer-0.1.11.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+chatterer-0.1.11.dist-info/top_level.txt,sha256=7nSQKP0bHxPRc7HyzdbKsJdkvPgYD0214o6slRizv9s,10
+chatterer-0.1.11.dist-info/RECORD,,

{chatterer-0.1.9.dist-info → chatterer-0.1.11.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any