chatlas 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

chatlas/__init__.py

@@ -3,6 +3,7 @@ from ._anthropic import ChatAnthropic, ChatBedrockAnthropic
 from ._auto import ChatAuto
 from ._chat import Chat
 from ._content_image import content_image_file, content_image_plot, content_image_url
+from ._content_pdf import content_pdf_file, content_pdf_url
 from ._github import ChatGithub
 from ._google import ChatGoogle, ChatVertex
 from ._groq import ChatGroq
@@ -38,6 +39,8 @@ __all__ = (
     "content_image_file",
     "content_image_plot",
     "content_image_url",
+    "content_pdf_file",
+    "content_pdf_url",
     "interpolate",
     "interpolate_file",
     "Provider",

chatlas/_anthropic.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import base64
 import json
 import warnings
 from typing import TYPE_CHECKING, Any, Literal, Optional, Union, cast, overload
@@ -12,6 +13,7 @@ from ._content import (
     ContentImageInline,
     ContentImageRemote,
     ContentJson,
+    ContentPDF,
     ContentText,
     ContentToolRequest,
     ContentToolResult,
@@ -31,6 +33,7 @@ if TYPE_CHECKING:
         ToolParam,
         ToolUseBlock,
     )
+    from anthropic.types.document_block_param import DocumentBlockParam
     from anthropic.types.image_block_param import ImageBlockParam
     from anthropic.types.model_param import ModelParam
     from anthropic.types.text_block_param import TextBlockParam
@@ -45,6 +48,7 @@ if TYPE_CHECKING:
         ImageBlockParam,
         ToolUseBlockParam,
         ToolResultBlockParam,
+        DocumentBlockParam,
     ]
 else:
     Message = object
@@ -450,12 +454,21 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
             return {"text": content.text, "type": "text"}
         elif isinstance(content, ContentJson):
             return {"text": "<structured data/>", "type": "text"}
+        elif isinstance(content, ContentPDF):
+            return {
+                "type": "document",
+                "source": {
+                    "type": "base64",
+                    "media_type": "application/pdf",
+                    "data": base64.b64encode(content.data).decode("utf-8"),
+                },
+            }
         elif isinstance(content, ContentImageInline):
             return {
                 "type": "image",
                 "source": {
                     "type": "base64",
-                    "media_type": content.content_type,
+                    "media_type": content.image_content_type,
                     "data": content.data or "",
                 },
             }
@@ -504,7 +517,7 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
         contents = []
         for content in completion.content:
             if content.type == "text":
-                contents.append(ContentText(content.text))
+                contents.append(ContentText(text=content.text))
             elif content.type == "tool_use":
                 if has_data_model and content.name == "_structured_tool_call":
                     if not isinstance(content.input, dict):
@@ -515,11 +528,11 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
                         raise ValueError(
                             "Expected data extraction tool to return a 'data' field."
                         )
-                    contents.append(ContentJson(content.input["data"]))
+                    contents.append(ContentJson(value=content.input["data"]))
                 else:
                     contents.append(
                         ContentToolRequest(
-                            content.id,
+                            id=content.id,
                             name=content.name,
                             arguments=content.input,
                         )

chatlas/_chat.py

@@ -1248,7 +1248,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         id_: str,
     ) -> ContentToolResult:
         if func is None:
-            return ContentToolResult(id_, value=None, error="Unknown tool")
+            return ContentToolResult(id=id_, value=None, error="Unknown tool")
 
         name = func.__name__
 
@@ -1258,10 +1258,10 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             else:
                 result = func(arguments)
 
-            return ContentToolResult(id_, value=result, error=None, name=name)
+            return ContentToolResult(id=id_, value=result, error=None, name=name)
         except Exception as e:
             log_tool_error(name, str(arguments), e)
-            return ContentToolResult(id_, value=None, error=str(e), name=name)
+            return ContentToolResult(id=id_, value=None, error=str(e), name=name)
 
     @staticmethod
     async def _invoke_tool_async(
@@ -1270,7 +1270,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         id_: str,
     ) -> ContentToolResult:
         if func is None:
-            return ContentToolResult(id_, value=None, error="Unknown tool")
+            return ContentToolResult(id=id_, value=None, error="Unknown tool")
 
         name = func.__name__
 
@@ -1280,10 +1280,10 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             else:
                 result = await func(arguments)
 
-            return ContentToolResult(id_, value=result, error=None, name=name)
+            return ContentToolResult(id=id_, value=result, error=None, name=name)
         except Exception as e:
             log_tool_error(func.__name__, str(arguments), e)
-            return ContentToolResult(id_, value=None, error=str(e), name=name)
+            return ContentToolResult(id=id_, value=None, error=str(e), name=name)
 
     def _markdown_display(
         self, echo: Literal["text", "all", "none"]

chatlas/_content.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import json
-from dataclasses import dataclass
 from pprint import pformat
-from typing import Any, Literal, Optional
+from typing import Any, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict
 
 ImageContentTypes = Literal[
     "image/png",
@@ -15,12 +16,28 @@ ImageContentTypes = Literal[
 Allowable content types for images.
 """
 
+ContentTypeEnum = Literal[
+    "text",
+    "image_remote",
+    "image_inline",
+    "tool_request",
+    "tool_result",
+    "json",
+    "pdf",
+]
+"""
+A discriminated union of all content types.
+"""
+
 
-class Content:
+class Content(BaseModel):
     """
     Base class for all content types that can be appear in a [](`~chatlas.Turn`)
     """
 
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    content_type: ContentTypeEnum
+
     def __str__(self):
         raise NotImplementedError
 
@@ -31,13 +48,13 @@ class Content:
         raise NotImplementedError
 
 
-@dataclass
 class ContentText(Content):
     """
     Text content for a [](`~chatlas.Turn`)
     """
 
     text: str
+    content_type: ContentTypeEnum = "text"
 
     def __str__(self):
         return self.text
@@ -62,7 +79,6 @@ class ContentImage(Content):
     pass
 
 
-@dataclass
 class ContentImageRemote(ContentImage):
     """
     Image content from a URL.
@@ -81,6 +97,8 @@ class ContentImageRemote(ContentImage):
     url: str
     detail: Literal["auto", "low", "high"] = "auto"
 
+    content_type: ContentTypeEnum = "image_remote"
+
     def __str__(self):
         return f"![]({self.url})"
 
@@ -94,7 +112,6 @@ class ContentImageRemote(ContentImage):
         )
 
 
-@dataclass
 class ContentImageInline(ContentImage):
     """
     Inline image content.
@@ -105,17 +122,19 @@ class ContentImageInline(ContentImage):
 
     Parameters
     ----------
-    content_type
+    image_content_type
         The content type of the image.
     data
         The base64-encoded image data.
     """
 
-    content_type: ImageContentTypes
+    image_content_type: ImageContentTypes
     data: Optional[str] = None
 
+    content_type: ContentTypeEnum = "image_inline"
+
     def __str__(self):
-        return f"![](data:{self.content_type};base64,{self.data})"
+        return f"![](data:{self.image_content_type};base64,{self.data})"
 
     def _repr_markdown_(self):
         return self.__str__()
@@ -124,11 +143,10 @@ class ContentImageInline(ContentImage):
         n_bytes = len(self.data) if self.data else 0
         return (
             " " * indent
-            + f"<ContentImageInline content_type='{self.content_type}' size={n_bytes}>"
+            + f"<ContentImageInline content_type='{self.image_content_type}' size={n_bytes}>"
         )
 
 
-@dataclass
 class ContentToolRequest(Content):
     """
     A request to call a tool/function
@@ -151,6 +169,8 @@ class ContentToolRequest(Content):
     name: str
     arguments: object
 
+    content_type: ContentTypeEnum = "tool_request"
+
     def __str__(self):
         args_str = self._arguments_str()
         func_call = f"{self.name}({args_str})"
@@ -173,7 +193,6 @@ class ContentToolRequest(Content):
         return str(self.arguments)
 
 
-@dataclass
 class ContentToolResult(Content):
     """
     The result of calling a tool/function
@@ -199,6 +218,8 @@ class ContentToolResult(Content):
     name: Optional[str] = None
     error: Optional[str] = None
 
+    content_type: ContentTypeEnum = "tool_result"
+
     def _get_value(self, pretty: bool = False) -> str:
         if self.error:
             return f"Tool calling failed with error: '{self.error}'"
@@ -207,7 +228,7 @@ class ContentToolResult(Content):
         try:
             json_val = json.loads(self.value)  # type: ignore
             return pformat(json_val, indent=2, sort_dicts=False)
-        except:  # noqa: E722
+        except:  # noqa
             return str(self.value)
 
     # Primarily used for `echo="all"`...
@@ -232,7 +253,6 @@ class ContentToolResult(Content):
         return self._get_value()
 
 
-@dataclass
 class ContentJson(Content):
     """
     JSON content
@@ -248,6 +268,8 @@ class ContentJson(Content):
 
     value: dict[str, Any]
 
+    content_type: ContentTypeEnum = "json"
+
     def __str__(self):
         return json.dumps(self.value, indent=2)
 
@@ -256,3 +278,70 @@ class ContentJson(Content):
 
     def __repr__(self, indent: int = 0):
         return " " * indent + f"<ContentJson value={self.value}>"
+
+
+class ContentPDF(Content):
+    """
+    PDF content
+
+    This content type primarily exists to signal PDF data extraction
+    (i.e., data extracted via [](`~chatlas.Chat`)'s `.extract_data()` method)
+
+    Parameters
+    ----------
+    value
+        The PDF data extracted
+    """
+
+    data: bytes
+
+    content_type: ContentTypeEnum = "pdf"
+
+    def __str__(self):
+        return "<PDF document>"
+
+    def _repr_markdown_(self):
+        return self.__str__()
+
+    def __repr__(self, indent: int = 0):
+        return " " * indent + f"<ContentPDF size={len(self.data)}>"
+
+
+ContentUnion = Union[
+    ContentText,
+    ContentImageRemote,
+    ContentImageInline,
+    ContentToolRequest,
+    ContentToolResult,
+    ContentJson,
+    ContentPDF,
+]
+
+
+def create_content(data: dict[str, Any]) -> ContentUnion:
+    """
+    Factory function to create the appropriate Content subclass based on the data.
+
+    This is useful when deserializing content from JSON.
+    """
+    if not isinstance(data, dict):
+        raise ValueError("Content data must be a dictionary")
+
+    ct = data.get("content_type")
+
+    if ct == "text":
+        return ContentText.model_validate(data)
+    elif ct == "image_remote":
+        return ContentImageRemote.model_validate(data)
+    elif ct == "image_inline":
+        return ContentImageInline.model_validate(data)
+    elif ct == "tool_request":
+        return ContentToolRequest.model_validate(data)
+    elif ct == "tool_result":
+        return ContentToolResult.model_validate(data)
+    elif ct == "json":
+        return ContentJson.model_validate(data)
+    elif ct == "pdf":
+        return ContentPDF.model_validate(data)
+    else:
+        raise ValueError(f"Unknown content type: {ct}")

chatlas/_content_image.py

@@ -8,6 +8,7 @@ import warnings
 from typing import Literal, Union, cast
 
 from ._content import ContentImageInline, ContentImageRemote, ImageContentTypes
+from ._content_pdf import parse_data_url
 from ._utils import MISSING, MISSING_TYPE
 
 __all__ = (
@@ -60,15 +61,11 @@ def content_image_url(
         raise ValueError("detail must be 'auto', 'low', or 'high'")
 
     if url.startswith("data:"):
-        parts = url[5:].split(";", 1)
-        if len(parts) != 2 or not parts[1].startswith("base64,"):
-            raise ValueError("url is not a valid data URL.")
-        content_type = parts[0]
-        base64_data = parts[1][7:]
+        content_type, base64_data = parse_data_url(url)
         if content_type not in ["image/png", "image/jpeg", "image/webp", "image/gif"]:
             raise ValueError(f"Unsupported image content type: {content_type}")
         content_type = cast(ImageContentTypes, content_type)
-        return ContentImageInline(content_type, base64_data)
+        return ContentImageInline(image_content_type=content_type, data=base64_data)
     else:
         return ContentImageRemote(url=url, detail=detail)
 
@@ -191,7 +188,7 @@ def content_image_file(
         img.save(buffer, format=img.format)
         base64_data = base64.b64encode(buffer.getvalue()).decode("utf-8")
 
-    return ContentImageInline(content_type, base64_data)
+    return ContentImageInline(image_content_type=content_type, data=base64_data)
 
 
 def content_image_plot(
@@ -263,7 +260,7 @@ def content_image_plot(
         fig.savefig(buf, format="png", dpi=dpi, bbox_inches="tight")
         buf.seek(0)
         base64_data = base64.b64encode(buf.getvalue()).decode("utf-8")
-        return ContentImageInline("image/png", base64_data)
+        return ContentImageInline(image_content_type="image/png", data=base64_data)
     finally:
         fig.set_size_inches(*size)
 

chatlas/_content_pdf.py

@@ -0,0 +1,94 @@
+import os
+import tempfile
+from typing import Union
+
+import requests
+
+from ._content import ContentPDF
+
+__all__ = (
+    "content_pdf_url",
+    "content_pdf_file",
+)
+
+
+def content_pdf_file(path: Union[str, os.PathLike]) -> ContentPDF:
+    """
+    Prepare a local PDF for input to a chat.
+
+    Not all providers support PDF input, so check the documentation for the
+    provider you are using.
+
+    Parameters
+    ----------
+    path
+        A path to a local PDF file.
+
+    Returns
+    -------
+    [](`~chatlas.types.Content`)
+        Content suitable for a [](`~chatlas.Turn`) object.
+    """
+
+    if not os.path.isfile(path):
+        raise FileNotFoundError(f"PDF file not found: {path}")
+
+    with open(path, "rb") as f:
+        data = f.read()
+
+    return ContentPDF(data=data)
+
+
+def content_pdf_url(url: str) -> ContentPDF:
+    """
+    Use a remote PDF for input to a chat.
+
+    Not all providers support PDF input, so check the documentation for the
+    provider you are using.
+
+    Parameters
+    ----------
+    url
+        A URL to a remote PDF file.
+
+    Returns
+    -------
+    [](`~chatlas.types.Content`)
+        Content suitable for a [](`~chatlas.Turn`) object.
+    """
+
+    if url.startswith("data:"):
+        content_type, base64_data = parse_data_url(url)
+        if content_type != "application/pdf":
+            raise ValueError(f"Unsupported PDF content type: {content_type}")
+        return ContentPDF(data=base64_data.encode("utf-8"))
+    # TODO: need separate ContentPDFRemote type so we can use file upload
+    # apis where they exist. Might need some kind of mutable state so can
+    # record point to uploaded file.
+    data = download_pdf_bytes(url)
+    return ContentPDF(data=data)
+
+
+def parse_data_url(url: str) -> tuple[str, str]:
+    parts = url[5:].split(";", 1)
+    if len(parts) != 2 or not parts[1].startswith("base64,"):
+        raise ValueError("url is not a valid data URL.")
+    return (parts[0], parts[1][7:])
+
+
+def download_pdf_bytes(url):
+    with tempfile.NamedTemporaryFile(suffix=".pdf", delete=True) as temp_file:
+        try:
+            response = requests.get(url, stream=True)
+            response.raise_for_status()
+
+            for chunk in response.iter_content(chunk_size=8192):
+                temp_file.write(chunk)
+
+            temp_file.flush()
+            temp_file.seek(0)
+
+            return temp_file.read()
+
+        except Exception as e:
+            raise e

chatlas/_google.py

@@ -12,6 +12,7 @@ from ._content import (
     ContentImageInline,
     ContentImageRemote,
     ContentJson,
+    ContentPDF,
     ContentText,
     ContentToolRequest,
     ContentToolResult,
@@ -399,10 +400,19 @@ class GoogleProvider(
             return Part.from_text(text=content.text)
         elif isinstance(content, ContentJson):
             return Part.from_text(text="<structured data/>")
+        elif isinstance(content, ContentPDF):
+            from google.genai.types import Blob
+
+            return Part(
+                inline_data=Blob(
+                    data=content.data,
+                    mime_type="application/pdf",
+                )
+            )
         elif isinstance(content, ContentImageInline) and content.data:
             return Part.from_bytes(
                 data=base64.b64decode(content.data),
-                mime_type=content.content_type,
+                mime_type=content.image_content_type,
             )
         elif isinstance(content, ContentImageRemote):
             raise NotImplementedError(
@@ -460,9 +470,9 @@ class GoogleProvider(
             text = part.get("text")
             if text:
                 if has_data_model:
-                    contents.append(ContentJson(json.loads(text)))
+                    contents.append(ContentJson(value=json.loads(text)))
                 else:
-                    contents.append(ContentText(text))
+                    contents.append(ContentText(text=text))
             function_call = part.get("function_call")
             if function_call:
                 # Seems name is required but id is optional?

chatlas/_openai.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import base64
 import json
 from typing import TYPE_CHECKING, Any, Literal, Optional, cast, overload
 
@@ -12,6 +13,7 @@ from ._content import (
     ContentImageInline,
     ContentImageRemote,
     ContentJson,
+    ContentPDF,
     ContentText,
     ContentToolRequest,
     ContentToolResult,
@@ -461,6 +463,19 @@ class OpenAIProvider(Provider[ChatCompletion, ChatCompletionChunk, ChatCompletio
                         contents.append({"type": "text", "text": x.text})
                     elif isinstance(x, ContentJson):
                         contents.append({"type": "text", "text": ""})
+                    elif isinstance(x, ContentPDF):
+                        contents.append(
+                            {
+                                "type": "file",
+                                "file": {
+                                    "filename": "",
+                                    "file_data": (
+                                        "data:application/pdf;base64,"
+                                        f"{base64.b64encode(x.data).decode('utf-8')}"
+                                    ),
+                                },
+                            }
+                        )
                     elif isinstance(x, ContentImageRemote):
                         contents.append(
                             {
@@ -476,7 +491,7 @@ class OpenAIProvider(Provider[ChatCompletion, ChatCompletionChunk, ChatCompletio
                             {
                                 "type": "image_url",
                                 "image_url": {
-                                    "url": f"data:{x.content_type};base64,{x.data}"
+                                    "url": f"data:{x.image_content_type};base64,{x.data}"
                                 },
                             }
                         )
@@ -514,9 +529,9 @@ class OpenAIProvider(Provider[ChatCompletion, ChatCompletionChunk, ChatCompletio
         if message.content is not None:
             if has_data_model:
                 data = json.loads(message.content)
-                contents = [ContentJson(data)]
+                contents = [ContentJson(value=data)]
             else:
-                contents = [ContentText(message.content)]
+                contents = [ContentText(text=message.content)]
 
         tool_calls = message.tool_calls
 
@@ -540,7 +555,7 @@ class OpenAIProvider(Provider[ChatCompletion, ChatCompletionChunk, ChatCompletio
 
                 contents.append(
                     ContentToolRequest(
-                        call.id,
+                        id=call.id,
                         name=func.name,
                         arguments=args,
                     )

chatlas/_turn.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
-from typing import Any, Generic, Literal, Optional, Sequence, TypeVar
+from typing import Generic, Literal, Optional, Sequence, TypeVar
 
-from ._content import Content, ContentText
+from pydantic import BaseModel, ConfigDict, Field
+
+from ._content import Content, ContentText, ContentUnion, create_content
 
 __all__ = ("Turn",)
 
 CompletionT = TypeVar("CompletionT")
 
 
-class Turn(Generic[CompletionT]):
+class Turn(BaseModel, Generic[CompletionT]):
     """
     A user or assistant turn
 
@@ -64,6 +66,14 @@ class Turn(Generic[CompletionT]):
         This is only relevant for assistant turns.
     """
 
+    role: Literal["user", "assistant", "system"]
+    contents: list[ContentUnion] = Field(default_factory=list)
+    tokens: Optional[tuple[int, int]] = None
+    finish_reason: Optional[str] = None
+    completion: Optional[CompletionT] = Field(default=None, exclude=True)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
     def __init__(
         self,
         role: Literal["user", "assistant", "system"],
@@ -72,26 +82,34 @@ class Turn(Generic[CompletionT]):
         tokens: Optional[tuple[int, int]] = None,
         finish_reason: Optional[str] = None,
         completion: Optional[CompletionT] = None,
+        **kwargs,
     ):
-        self.role = role
-
         if isinstance(contents, str):
-            contents = [ContentText(contents)]
+            contents = [ContentText(text=contents)]
 
         contents2: list[Content] = []
         for x in contents:
             if isinstance(x, Content):
                 contents2.append(x)
             elif isinstance(x, str):
-                contents2.append(ContentText(x))
+                contents2.append(ContentText(text=x))
+            elif isinstance(x, dict):
+                contents2.append(create_content(x))
             else:
                 raise ValueError("All contents must be Content objects or str.")
 
-        self.contents = contents2
-        self.text = "".join(x.text for x in self.contents if isinstance(x, ContentText))
-        self.tokens = tokens
-        self.finish_reason = finish_reason
-        self.completion = completion
+        super().__init__(
+            role=role,
+            contents=contents2,
+            tokens=tokens,
+            finish_reason=finish_reason,
+            completion=completion,
+            **kwargs,
+        )
+
+    @property
+    def text(self) -> str:
+        return "".join(x.text for x in self.contents if isinstance(x, ContentText))
 
     def __str__(self) -> str:
         return self.text
@@ -109,18 +127,6 @@ class Turn(Generic[CompletionT]):
             res += "\n" + content.__repr__(indent=indent + 2)
         return res + "\n"
 
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, Turn):
-            return False
-        res = (
-            self.role == other.role
-            and self.contents == other.contents
-            and self.tokens == other.tokens
-            and self.finish_reason == other.finish_reason
-            and self.completion == other.completion
-        )
-        return res
-
 
 def user_turn(*args: Content | str) -> Turn:
     if len(args) == 0:

chatlas/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.0'
-__version_tuple__ = version_tuple = (0, 5, 0)
+__version__ = version = '0.6.0'
+__version_tuple__ = version_tuple = (0, 6, 0)

chatlas/types/openai/_submit.py

@@ -46,11 +46,6 @@ class SubmitInputArgs(TypedDict, total=False):
             "o1-preview-2024-09-12",
             "o1-mini",
             "o1-mini-2024-09-12",
-            "computer-use-preview",
-            "computer-use-preview-2025-02-04",
-            "computer-use-preview-2025-03-11",
-            "gpt-4.5-preview",
-            "gpt-4.5-preview-2025-02-27",
             "gpt-4o",
             "gpt-4o-2024-11-20",
             "gpt-4o-2024-08-06",
@@ -60,6 +55,10 @@ class SubmitInputArgs(TypedDict, total=False):
             "gpt-4o-audio-preview-2024-12-17",
             "gpt-4o-mini-audio-preview",
             "gpt-4o-mini-audio-preview-2024-12-17",
+            "gpt-4o-search-preview",
+            "gpt-4o-mini-search-preview",
+            "gpt-4o-search-preview-2025-03-11",
+            "gpt-4o-mini-search-preview-2025-03-11",
             "chatgpt-4o-latest",
             "gpt-4o-mini",
             "gpt-4o-mini-2024-07-18",

{chatlas-0.5.0.dist-info → chatlas-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatlas
-Version: 0.5.0
+Version: 0.6.0
 Summary: A simple and consistent interface for chatting with LLMs
 Project-URL: Homepage, https://posit-dev.github.io/chatlas
 Project-URL: Documentation, https://posit-dev.github.io/chatlas

{chatlas-0.5.0.dist-info → chatlas-0.6.0.dist-info}/RECORD

@@ -1,29 +1,30 @@
-chatlas/__init__.py,sha256=U-uNJWeVjMj4aSre2evTaVunabzLksZ5Toz19ygQB-o,1251
-chatlas/_anthropic.py,sha256=-Qrq-8jgNIpW_temJYXKTb7VCl2ldnpe-KSX89L5Lhc,24264
+chatlas/__init__.py,sha256=IVHVEEN6pspb-5WqWfBLc9wOQH-1R8vmi1Eeh-OSVFY,1358
+chatlas/_anthropic.py,sha256=IvTC1xJYeKi7Liz_Czt1wmkG_Tx12e2ME663xZTNpdI,24745
 chatlas/_auto.py,sha256=4tpwla09la4VA2PAh3phAMWs2Amgtp_4Qsjx6K02ib0,6032
-chatlas/_chat.py,sha256=hS0sirnZBwMaOJ47wyNgdA61Xd7AJ_xVhj4v8RbLoHA,46014
-chatlas/_content.py,sha256=L_ry6W5D2h6Eag2tZmqIbMP4OQj-vVXRircLcUtgQ6c,6454
-chatlas/_content_image.py,sha256=4nk9wTvLtNmtcytdFp8p9otEV5-0_K6wzIxCyK0PIEI,8367
+chatlas/_chat.py,sha256=czfSjsEbRX5bHLclF1IbYtfHlyZrAOH0xcP-1hzcNNk,46032
+chatlas/_content.py,sha256=yXB1IukyMfK9-Zc8ISm4h1p09O4i79YEJandzyT4UtM,8726
+chatlas/_content_image.py,sha256=EUK6wAint-JatLsiwvaPDu4D3W-NcIsDCkzABkXgfDg,8304
+chatlas/_content_pdf.py,sha256=cffeuJxzhUDukQ-Srkmpy62M8X12skYpU_FVq-Wvya4,2420
 chatlas/_display.py,sha256=eqdRIwQenyJxswmTEjnJ1n9YxxSxsa8vHVmA79449_o,4439
 chatlas/_github.py,sha256=8_vvUIBCprgrQ5UItky5yETfEQPG2fCMM57ga77p28E,4377
-chatlas/_google.py,sha256=ehL8hf8Hogg9qK9OaXqiWainOirz21yy_lx_yvUwKf8,18831
+chatlas/_google.py,sha256=lXqqLwXlqFoKh0GWx-OSgJ1pge0Dv7FH8Sg-MkcXpJs,19138
 chatlas/_groq.py,sha256=iuFvxeXkq81sDHxVV9zbVHjf2ZuNT94P-XkuXvqtGms,4160
 chatlas/_interpolate.py,sha256=ykwLP3x-ya9Q33U4knSU75dtk6pzJAeythEEIW-43Pc,3631
 chatlas/_live_render.py,sha256=UMZltE35LxziDKPMEeDwQ9meZ95SeqwhJi7j-y9pcro,4004
 chatlas/_logging.py,sha256=7a20sAl1PkW1qBNrfd_ieUbQXV8Gf4Vuf0Wn62LNBmk,2290
 chatlas/_merge.py,sha256=SGj_BetgA7gaOqSBKOhYmW3CYeQKTEehFrXvx3y4OYE,3924
 chatlas/_ollama.py,sha256=EgTwmphVwBV7xCIqmPC_cNlr4Uo9N5Xy4eDCb1sJoPI,3764
-chatlas/_openai.py,sha256=9KB4hEh6acFfBvLV0yXwLcjP-CyIpsMbbVt7eJ03_Vg,23870
+chatlas/_openai.py,sha256=xnJPzZzVuRoH7al7Tq01J7SIgF7bZm3UwcO2noDENk4,24523
 chatlas/_perplexity.py,sha256=j-jfOIYefZC5XzGjmya9GCCGQN003cRmiAv6vmo0rTQ,4454
 chatlas/_provider.py,sha256=YmdBbz_u5aP_kBxl6s26OPiSnWG_vZ_fvf9L2qvBmyI,3809
 chatlas/_snowflake.py,sha256=WUNdT3irxgLVqoc1TAeDmxnYsjBWiBw-CoH-dY4mFps,10944
 chatlas/_tokens.py,sha256=3W3EPUp9eWXUiwuzJwEPBv43AUznbK46pm59Htti7z4,2392
 chatlas/_tokens_old.py,sha256=L9d9oafrXvEx2u4nIn_Jjn7adnQyLBnYBuPwJUE8Pl8,5005
 chatlas/_tools.py,sha256=-qt4U1AFkebQoX9kpsBy5QXK8a2PpHX6Amgm44gcQ68,4113
-chatlas/_turn.py,sha256=nKwk20FrOIrZX4xJxdGyUEpwUH2H-UYcoJLlO2ZD5iU,4836
+chatlas/_turn.py,sha256=7pve6YmD-L4c7Oxd6_ZAPkDudJ8AMpa6pP-pSroA1dM,5067
 chatlas/_typing_extensions.py,sha256=YdzmlyPSBpIEcsOkoz12e6jETT1XEMV2Q72haE4cfwY,1036
 chatlas/_utils.py,sha256=2TPy5_8dr9QDF1YShZN-CjxRVHeArSujRiaF0SKnI4o,2895
-chatlas/_version.py,sha256=N2U3TRgLfYxjXfoF4Dy9PxAbZq24zjCym3P3cwuxKP8,511
+chatlas/_version.py,sha256=jF9TuoEIJRaca3ScKo6qaz6PzaMlu7jjuSQIrJ3nX4U,511
 chatlas/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chatlas/types/__init__.py,sha256=P_EDL4eqsigKwB-u2qRmKlYQS5Y65m7oWjGC3cYmxO4,719
 chatlas/types/anthropic/__init__.py,sha256=OwubA-DPHYpYo0XyRyAFwftOI0mOxtHzAyhUSLcDx54,417
@@ -36,9 +37,9 @@ chatlas/types/google/_submit.py,sha256=b-ZqMvI551Ia7pFlWdqUQJjov3neHmVwLFw-P2bgU
 chatlas/types/openai/__init__.py,sha256=Q2RAr1bSH1nHsxICK05nAmKmxdhKmhbBkWD_XHiVSrI,411
 chatlas/types/openai/_client.py,sha256=YGm_EHtRSSHeeOZe-CV7oNvMJpEblEta3UTuU7lSRO8,754
 chatlas/types/openai/_client_azure.py,sha256=jx8D_p46CLDGzTP-k-TtGzj-f3junj6or-86m8DD_0w,858
-chatlas/types/openai/_submit.py,sha256=pJ6_G5R3ouI17-20fvjv0pzs_VizTlMbrBx7GXiOpNs,6294
+chatlas/types/openai/_submit.py,sha256=mflYHZ5Q3dWBR2PdVEq6lhC9qNrQGNvyMiORglYLByE,6271
 chatlas/types/snowflake/__init__.py,sha256=NVKw_gLVnSlMNdE6BpikrQw8GV8LvIn5SR8eI8Afgbs,273
 chatlas/types/snowflake/_submit.py,sha256=Fgcb2Z4mXYwAR2b7Kn3SdEYFlO4gJiUvkDJ3lDoN0IY,799
-chatlas-0.5.0.dist-info/METADATA,sha256=ObTTRN6dDvUuAWuW07VDvkvwbRbeMlH6AwRvLmVFDvM,14409
-chatlas-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-chatlas-0.5.0.dist-info/RECORD,,
+chatlas-0.6.0.dist-info/METADATA,sha256=qJ2toXASnFjXvQOYJg0cXGx5AABxsgWBDBWN-1gZf04,14409
+chatlas-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+chatlas-0.6.0.dist-info/RECORD,,