chatterer 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

chatterer/language_model.py

@@ -1,3 +1,4 @@
+import re
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -11,7 +12,6 @@ from typing import (
     Type,
     TypeAlias,
     TypeVar,
-    cast,
     overload,
 )
 
@@ -19,10 +19,11 @@ from langchain_core.language_models.base import LanguageModelInput
 from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.runnables.base import Runnable
 from langchain_core.runnables.config import RunnableConfig
+from langchain_core.utils.utils import secret_from_env
 from pydantic import BaseModel, Field
 
-from .messages import AIMessage, BaseMessage, HumanMessage, SystemMessage
-from .utils.code_agent import CodeExecutionResult, FunctionSignature, get_default_repl_tool
+from .messages import AIMessage, BaseMessage, HumanMessage, UsageMetadata
+from .utils.code_agent import CodeExecutionResult, FunctionSignature, augment_prompt_for_toolcall
 
 if TYPE_CHECKING:
     from instructor import Partial
@@ -53,6 +54,8 @@ DEFAULT_FUNCTION_REFERENCE_PREFIX_PROMPT = (
 )
 DEFAULT_FUNCTION_REFERENCE_SEPARATOR = "\n---\n"  # Separator to distinguish different function references
 
+PYTHON_CODE_PATTERN: re.Pattern[str] = re.compile(r"```(?:python\s*\n)?(.*?)```", re.DOTALL)
+
 
 class Chatterer(BaseModel):
     """Language model for generating text from a given input."""
@@ -60,37 +63,25 @@ class Chatterer(BaseModel):
     client: BaseChatModel
     structured_output_kwargs: dict[str, Any] = Field(default_factory=dict)
 
-    @overload
-    def __call__(
-        self,
-        messages: LanguageModelInput,
-        response_model: Type[PydanticModelT],
-        config: Optional[RunnableConfig] = None,
-        stop: Optional[list[str]] = None,
-        **kwargs: Any,
-    ) -> PydanticModelT: ...
-
-    @overload
-    def __call__(
-        self,
-        messages: LanguageModelInput,
-        response_model: None = None,
-        config: Optional[RunnableConfig] = None,
-        stop: Optional[list[str]] = None,
-        **kwargs: Any,
-    ) -> str: ...
-
-    def __call__(
-        self,
-        messages: LanguageModelInput,
-        response_model: Optional[Type[PydanticModelT]] = None,
-        config: Optional[RunnableConfig] = None,
-        stop: Optional[list[str]] = None,
-        **kwargs: Any,
-    ) -> str | PydanticModelT:
-        if response_model:
-            return self.generate_pydantic(response_model, messages, config, stop, **kwargs)
-        return self.client.invoke(input=messages, config=config, stop=stop, **kwargs).text()
+    @classmethod
+    def from_provider(
+        cls,
+        provider_and_model: str,
+        structured_output_kwargs: Optional[dict[str, Any]] = {"strict": True},
+    ) -> Self:
+        backend, model = provider_and_model.split(":", 1)
+        if backend == "openai":
+            return cls.openai(model=model, structured_output_kwargs=structured_output_kwargs)
+        elif backend == "anthropic":
+            return cls.anthropic(model_name=model, structured_output_kwargs=structured_output_kwargs)
+        elif backend == "google":
+            return cls.google(model=model, structured_output_kwargs=structured_output_kwargs)
+        elif backend == "ollama":
+            return cls.ollama(model=model, structured_output_kwargs=structured_output_kwargs)
+        elif backend == "openrouter":
+            return cls.open_router(model=model, structured_output_kwargs=structured_output_kwargs)
+        else:
+            raise ValueError(f"Unsupported backend model: {backend}")
 
     @classmethod
     def openai(
@@ -141,6 +132,78 @@ class Chatterer(BaseModel):
             structured_output_kwargs=structured_output_kwargs or {},
         )
 
+    @classmethod
+    def open_router(
+        cls,
+        model: str = "openrouter/quasar-alpha",
+        structured_output_kwargs: Optional[dict[str, Any]] = None,
+    ) -> Self:
+        from langchain_openai import ChatOpenAI
+
+        return cls(
+            client=ChatOpenAI(
+                model=model,
+                base_url="https://openrouter.ai/api/v1",
+                api_key=secret_from_env("OPENROUTER_API_KEY", default=None)(),
+            ),
+            structured_output_kwargs=structured_output_kwargs or {},
+        )
+
+    @property
+    def invoke(self):
+        return self.client.invoke
+
+    @property
+    def ainvoke(self):
+        return self.client.ainvoke
+
+    @property
+    def stream(self):
+        return self.client.stream
+
+    @property
+    def astream(self):
+        return self.client.astream
+
+    @property
+    def bind_tools(self):  # pyright: ignore[reportUnknownParameterType]
+        return self.client.bind_tools  # pyright: ignore[reportUnknownParameterType, reportUnknownVariableType, reportUnknownMemberType]
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.client, name)
+
+    @overload
+    def __call__(
+        self,
+        messages: LanguageModelInput,
+        response_model: Type[PydanticModelT],
+        config: Optional[RunnableConfig] = None,
+        stop: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> PydanticModelT: ...
+
+    @overload
+    def __call__(
+        self,
+        messages: LanguageModelInput,
+        response_model: None = None,
+        config: Optional[RunnableConfig] = None,
+        stop: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> str: ...
+
+    def __call__(
+        self,
+        messages: LanguageModelInput,
+        response_model: Optional[Type[PydanticModelT]] = None,
+        config: Optional[RunnableConfig] = None,
+        stop: Optional[list[str]] = None,
+        **kwargs: Any,
+    ) -> str | PydanticModelT:
+        if response_model:
+            return self.generate_pydantic(response_model, messages, config, stop, **kwargs)
+        return self.client.invoke(input=messages, config=config, stop=stop, **kwargs).text()
+
     def generate(
         self,
         messages: LanguageModelInput,
@@ -279,39 +342,30 @@ class Chatterer(BaseModel):
             )
         ])
 
-    @staticmethod
-    def get_num_tokens_from_message(message: BaseMessage) -> Optional[tuple[int, int]]:
-        try:
-            if isinstance(message, AIMessage) and (usage_metadata := message.usage_metadata):
-                input_tokens = int(usage_metadata["input_tokens"])
-                output_tokens = int(usage_metadata["output_tokens"])
+    def get_approximate_token_count(self, message: BaseMessage) -> int:
+        return self.client.get_num_tokens_from_messages([message])  # pyright: ignore[reportUnknownMemberType]
+
+    def get_usage_metadata(self, message: BaseMessage) -> UsageMetadata:
+        if isinstance(message, AIMessage):
+            usage_metadata = message.usage_metadata
+            if usage_metadata is not None:
+                input_tokens = usage_metadata["input_tokens"]
+                output_tokens = usage_metadata["output_tokens"]
+                return {
+                    "input_tokens": input_tokens,
+                    "output_tokens": output_tokens,
+                    "total_tokens": input_tokens + output_tokens,
+                }
             else:
-                # Dynamic extraction for unknown structures
-                input_tokens: Optional[int] = None
-                output_tokens: Optional[int] = None
-
-                def _find_tokens(obj: object) -> None:
-                    nonlocal input_tokens, output_tokens
-                    if isinstance(obj, dict):
-                        for key, value in cast(dict[object, object], obj).items():
-                            if isinstance(value, int):
-                                if "input" in str(key) or "prompt" in str(key):
-                                    input_tokens = value
-                                elif "output" in str(key) or "completion" in str(key):
-                                    output_tokens = value
-                            else:
-                                _find_tokens(value)
-                    elif isinstance(obj, list):
-                        for item in cast(list[object], obj):
-                            _find_tokens(item)
-
-                _find_tokens(message.model_dump())
-
-            if input_tokens is None or output_tokens is None:
-                return None
-            return input_tokens, output_tokens
-        except Exception:
-            return None
+                approx_tokens = self.get_approximate_token_count(message)
+                return {"input_tokens": 0, "output_tokens": approx_tokens, "total_tokens": approx_tokens}
+        else:
+            approx_tokens = self.get_approximate_token_count(message)
+            return {
+                "input_tokens": approx_tokens,
+                "output_tokens": 0,
+                "total_tokens": approx_tokens,
+            }
 
     def invoke_code_execution(
         self,
@@ -382,6 +436,15 @@ class Chatterer(BaseModel):
 class PythonCodeToExecute(BaseModel):
     code: str = Field(description="Python code to execute")
 
+    def model_post_init(self, context: object) -> None:
+        super().model_post_init(context)
+
+        codes: list[str] = []
+        for match in PYTHON_CODE_PATTERN.finditer(self.code):
+            codes.append(match.group(1))
+        if codes:
+            self.code = "\n".join(codes)
+
 
 def _with_structured_output(
     client: BaseChatModel,
@@ -389,189 +452,3 @@ def _with_structured_output(
     structured_output_kwargs: dict[str, Any],
 ) -> Runnable[LanguageModelInput, dict[object, object] | BaseModel]:
     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:
-#     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"{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 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 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."
-        )
-
-    def respond(messages: list[BaseMessage]) -> str:
-        # AI 응답 스트리밍 출력
-        console.print("[bold blue]AI:[/bold blue] ", end="")
-        response = ""
-        for chunk in chatterer.generate_stream(messages=messages):
-            response += chunk
-            console.print(chunk, end="")
-        console.print()  # 응답 후 줄바꿈 추가
-        return response.strip()
-
-    def code_session_returning_end_of_turn() -> bool:
-        code_session_messages: list[BaseMessage] = []
-        while True:
-            code_execution: CodeExecutionResult = 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_execution.code.strip() in ("", "quit", "exit", "pass"):
-                return False
-
-            last_tool_use_message = AIMessage(
-                content=f"Executed code:\n```python\n{code_execution.code}\n```\nOutput:\n{code_execution.output}".strip()
-            )
-            code_session_messages.append(last_tool_use_message)
-            console.print("[bold yellow]Executed code:[/bold yellow]")
-            console.print(f"[code]{code_execution.code}[/code]")
-            console.print("[bold yellow]Output:[/bold yellow]")
-            console.print(code_execution.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:
-                response: str = respond(context + code_session_messages)
-                context.append(last_tool_use_message)
-                context.append(AIMessage(content=response))
-                return True
-
-    # REPL 도구 초기화
-    if repl_tool is None:
-        repl_tool = get_default_repl_tool()
-
-    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)
-
-    # 환영 메시지
-    console.print("[bold blue]Welcome to the Interactive Chatterer Shell![/bold blue]")
-    console.print("Type 'quit' or 'exit' to end the conversation.")
-
-    while True:
-        # 사용자 입력 받기
-        user_input = Prompt.ask("[bold green]You[/bold green]")
-        if user_input.lower() in ["quit", "exit"]:
-            console.print("[bold blue]Goodbye![/bold blue]")
-            break
-
-        context.append(HumanMessage(content=user_input))
-
-        # 코드 실행 필요 여부 판단
-        decision = chatterer.generate_pydantic(
-            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 and code_session_returning_end_of_turn():
-            continue
-
-        # AI 응답 스트리밍 출력
-        context.append(AIMessage(content=respond(context)))
-
-
-if __name__ == "__main__":
-    interactive_shell()

chatterer/messages.py

@@ -1,4 +1,13 @@
-from langchain_core.messages import AIMessage, BaseMessage, FunctionMessage, HumanMessage, SystemMessage
+from langchain_core.language_models.base import LanguageModelInput
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    BaseMessageChunk,
+    FunctionMessage,
+    HumanMessage,
+    SystemMessage,
+)
+from langchain_core.messages.ai import UsageMetadata
 
 __all__ = [
     "AIMessage",
@@ -6,4 +15,7 @@ __all__ = [
     "HumanMessage",
     "SystemMessage",
     "FunctionMessage",
+    "BaseMessageChunk",
+    "UsageMetadata",
+    "LanguageModelInput",
 ]

chatterer/tools/__init__.py

@@ -1,19 +1,23 @@
+from .caption_markdown_images import MarkdownLink, acaption_markdown_images, caption_markdown_images
 from .citation_chunking import citation_chunker
+from .convert_pdf_to_markdown import PdfToMarkdown, extract_text_from_pdf, open_pdf, render_pdf_as_image
 from .convert_to_text import (
+    CodeSnippets,
     anything_to_markdown,
     get_default_html_to_markdown_options,
     html_to_markdown,
     pdf_to_text,
     pyscripts_to_snippets,
 )
-from .youtube import get_youtube_video_subtitle, get_youtube_video_details
-
-
-def init_webpage_to_markdown():
-    from . import webpage_to_markdown
-
-    return webpage_to_markdown
-
+from .upstage_document_parser import UpstageDocumentParseParser
+from .webpage_to_markdown import (
+    PlayWrightBot,
+    PlaywrightLaunchOptions,
+    PlaywrightOptions,
+    PlaywrightPersistencyOptions,
+    get_default_playwright_launch_options,
+)
+from .youtube import get_youtube_video_details, get_youtube_video_subtitle
 
 __all__ = [
     "html_to_markdown",
@@ -22,7 +26,21 @@ __all__ = [
     "get_default_html_to_markdown_options",
     "pyscripts_to_snippets",
     "citation_chunker",
-    "init_webpage_to_markdown",
+    "webpage_to_markdown",
     "get_youtube_video_subtitle",
     "get_youtube_video_details",
+    "CodeSnippets",
+    "PlayWrightBot",
+    "PlaywrightLaunchOptions",
+    "PlaywrightOptions",
+    "PlaywrightPersistencyOptions",
+    "get_default_playwright_launch_options",
+    "UpstageDocumentParseParser",
+    "acaption_markdown_images",
+    "caption_markdown_images",
+    "MarkdownLink",
+    "PdfToMarkdown",
+    "extract_text_from_pdf",
+    "open_pdf",
+    "render_pdf_as_image",
 ]