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

chatlas/__init__.py

@@ -1,5 +1,6 @@
 from . import types
 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 ._github import ChatGithub
@@ -10,12 +11,19 @@ from ._ollama import ChatOllama
 from ._openai import ChatAzureOpenAI, ChatOpenAI
 from ._perplexity import ChatPerplexity
 from ._provider import Provider
+from ._snowflake import ChatSnowflake
 from ._tokens import token_usage
 from ._tools import Tool
 from ._turn import Turn
 
+try:
+    from ._version import version as __version__
+except ImportError:  # pragma: no cover
+    __version__ = "0.0.0"  # stub value for docs
+
 __all__ = (
     "ChatAnthropic",
+    "ChatAuto",
     "ChatBedrockAnthropic",
     "ChatGithub",
     "ChatGoogle",
@@ -24,6 +32,7 @@ __all__ = (
     "ChatOpenAI",
     "ChatAzureOpenAI",
     "ChatPerplexity",
+    "ChatSnowflake",
     "ChatVertex",
     "Chat",
     "content_image_file",

chatlas/_anthropic.py

@@ -72,7 +72,7 @@ def ChatAnthropic(
     ::: {.callout-note}
     ## API key
 
-    Note that a Claude Prop membership does not give you the ability to call
+    Note that a Claude Pro membership does not give you the ability to call
     models via the API. You will need to go to the [developer
     console](https://console.anthropic.com/account/keys) to sign up (and pay
     for) a developer account that will give you an API key that you can use with
@@ -82,7 +82,7 @@ def ChatAnthropic(
     ::: {.callout-note}
     ## Python requirements
 
-    `ChatAnthropic` requires the `anthropic` package (e.g., `pip install anthropic`).
+    `ChatAnthropic` requires the `anthropic` package: `pip install "chatlas[anthropic]"`.
     :::
 
     Examples
@@ -164,7 +164,7 @@ def ChatAnthropic(
     """
 
     if model is None:
-        model = log_model_default("claude-3-5-sonnet-latest")
+        model = log_model_default("claude-3-7-sonnet-latest")
 
     return Chat(
         provider=AnthropicProvider(
@@ -572,8 +572,8 @@ def ChatBedrockAnthropic(
     ::: {.callout-note}
     ## Python requirements
 
-    `ChatBedrockAnthropic`, requires the `anthropic` package with the `bedrock` extras
-    (e.g., `pip install anthropic[bedrock]`).
+    `ChatBedrockAnthropic`, requires the `anthropic` package with the `bedrock` extras:
+    `pip install "chatlas[bedrock-anthropic]"`
     :::
 
     Examples

chatlas/_auto.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Callable, Literal, Optional
+
+from ._anthropic import ChatAnthropic, ChatBedrockAnthropic
+from ._chat import Chat
+from ._github import ChatGithub
+from ._google import ChatGoogle, ChatVertex
+from ._groq import ChatGroq
+from ._ollama import ChatOllama
+from ._openai import ChatAzureOpenAI, ChatOpenAI
+from ._perplexity import ChatPerplexity
+from ._snowflake import ChatSnowflake
+from ._turn import Turn
+
+AutoProviders = Literal[
+    "anthropic",
+    "bedrock-anthropic",
+    "github",
+    "google",
+    "groq",
+    "ollama",
+    "openai",
+    "azure-openai",
+    "perplexity",
+    "snowflake",
+    "vertex",
+]
+
+_provider_chat_model_map: dict[AutoProviders, Callable[..., Chat]] = {
+    "anthropic": ChatAnthropic,
+    "bedrock-anthropic": ChatBedrockAnthropic,
+    "github": ChatGithub,
+    "google": ChatGoogle,
+    "groq": ChatGroq,
+    "ollama": ChatOllama,
+    "openai": ChatOpenAI,
+    "azure-openai": ChatAzureOpenAI,
+    "perplexity": ChatPerplexity,
+    "snowflake": ChatSnowflake,
+    "vertex": ChatVertex,
+}
+
+
+def ChatAuto(
+    system_prompt: Optional[str] = None,
+    turns: Optional[list[Turn]] = None,
+    *,
+    provider: Optional[AutoProviders] = None,
+    model: Optional[str] = None,
+    **kwargs,
+) -> Chat:
+    """
+    Use environment variables (env vars) to configure the Chat provider and model.
+
+    Creates a `:class:~chatlas.Chat` instance based on the specified provider.
+    The provider may be specified through the `provider` parameter and/or the
+    `CHATLAS_CHAT_PROVIDER` env var. If both are set, the env var takes
+    precedence. Similarly, the provider's model may be specified through the
+    `model` parameter and/or the `CHATLAS_CHAT_MODEL` env var. Also, additional
+    configuration may be provided through the `kwargs` parameter and/or the
+    `CHATLAS_CHAT_ARGS` env var (as a JSON string). In this case, when both are
+    set, they are merged, with the env var arguments taking precedence.
+
+    As a result, `ChatAuto()` provides a convenient way to set a default
+    provider and model in your Python code, while allowing you to override
+    these settings through env vars (i.e., without modifying your code).
+
+    Prerequisites
+    -------------
+
+    ::: {.callout-note}
+    ## API key
+
+    Follow the instructions for the specific provider to obtain an API key.
+    :::
+
+    ::: {.callout-note}
+    ## Python requirements
+
+    Follow the instructions for the specific provider to install the required
+    Python packages.
+    :::
+
+
+    Examples
+    --------
+    First, set the environment variables for the provider, arguments, and API key:
+
+    ```bash
+    export CHATLAS_CHAT_PROVIDER=anthropic
+    export CHATLAS_CHAT_MODEL=claude-3-haiku-20240229
+    export CHATLAS_CHAT_ARGS='{"kwargs": {"max_retries": 3}}'
+    export ANTHROPIC_API_KEY=your_api_key
+    ```
+
+    Then, you can use the `ChatAuto` function to create a Chat instance:
+
+    ```python
+    from chatlas import ChatAuto
+
+    chat = ChatAuto()
+    chat.chat("What is the capital of France?")
+    ```
+
+    Parameters
+    ----------
+    provider
+        The name of the default chat provider to use. Providers are strings
+        formatted in kebab-case, e.g. to use `ChatBedrockAnthropic` set
+        `provider="bedrock-anthropic"`.
+
+        This value can also be provided via the `CHATLAS_CHAT_PROVIDER`
+        environment variable, which takes precedence over `provider`
+        when set.
+    model
+        The name of the default model to use. This value can also be provided
+        via the `CHATLAS_CHAT_MODEL` environment variable, which takes
+        precedence over `model` when set.
+    system_prompt
+        A system prompt to set the behavior of the assistant.
+    turns
+        A list of turns to start the chat with (i.e., continuing a previous
+        conversation). If not provided, the conversation begins from scratch. Do
+        not provide non-`None` values for both `turns` and `system_prompt`. Each
+        message in the list should be a dictionary with at least `role` (usually
+        `system`, `user`, or `assistant`, but `tool` is also possible). Normally
+        there is also a `content` field, which is a string.
+    **kwargs
+        Additional keyword arguments to pass to the Chat constructor. See the
+        documentation for each provider for more details on the available
+        options.
+
+        These arguments can also be provided via the `CHATLAS_CHAT_ARGS`
+        environment variable as a JSON string. When provided, the options
+        in the `CHATLAS_CHAT_ARGS` envvar take precedence over the options
+        passed to `kwargs`.
+
+        Note that `system_prompt` and `turns` in `kwargs` or in
+        `CHATLAS_CHAT_ARGS` are ignored.
+
+    Returns
+    -------
+    Chat
+        A chat instance using the specified provider.
+
+    Raises
+    ------
+    ValueError
+        If no valid provider is specified either through parameters or
+        environment variables.
+    """
+    the_provider = os.environ.get("CHATLAS_CHAT_PROVIDER", provider)
+
+    if the_provider is None:
+        raise ValueError(
+            "Provider name is required as parameter or `CHATLAS_CHAT_PROVIDER` must be set."
+        )
+    if the_provider not in _provider_chat_model_map:
+        raise ValueError(
+            f"Provider name '{the_provider}' is not a known chatlas provider: "
+            f"{', '.join(_provider_chat_model_map.keys())}"
+        )
+
+    # `system_prompt` and `turns` always come from `ChatAuto()`
+    base_args = {"system_prompt": system_prompt, "turns": turns}
+
+    if env_model := os.environ.get("CHATLAS_CHAT_MODEL"):
+        model = env_model
+
+    if model:
+        base_args["model"] = model
+
+    env_kwargs = {}
+    if env_kwargs_str := os.environ.get("CHATLAS_CHAT_ARGS"):
+        env_kwargs = json.loads(env_kwargs_str)
+
+    kwargs = {**kwargs, **env_kwargs, **base_args}
+    kwargs = {k: v for k, v in kwargs.items() if v is not None}
+
+    return _provider_chat_model_map[the_provider](**kwargs)

chatlas/_chat.py

@@ -408,7 +408,9 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             Whether to run the app in a background thread. If `None`, the app will
             run in a background thread if the current environment is a notebook.
         echo
-            Whether to echo text content, all content (i.e., tool calls), or no content. Defaults to `"none"` when `stream=True` and `"text"` when `stream=False`.
+            Whether to echo text content, all content (i.e., tool calls), or no
+            content. Defaults to `"none"` when `stream=True` and `"text"` when
+            `stream=False`.
         kwargs
             Additional keyword arguments to pass to the method used for requesting
             the response.

chatlas/_content.py

@@ -199,21 +199,24 @@ class ContentToolResult(Content):
     name: Optional[str] = None
     error: Optional[str] = None
 
-    def _get_value_and_language(self) -> tuple[str, str]:
+    def _get_value(self, pretty: bool = False) -> str:
         if self.error:
-            return f"Tool calling failed with error: '{self.error}'", ""
+            return f"Tool calling failed with error: '{self.error}'"
+        if not pretty:
+            return str(self.value)
         try:
-            json_val = json.loads(self.value)
-            return pformat(json_val, indent=2, sort_dicts=False), "python"
+            json_val = json.loads(self.value)  # type: ignore
+            return pformat(json_val, indent=2, sort_dicts=False)
         except:  # noqa: E722
-            return str(self.value), ""
+            return str(self.value)
 
+    # Primarily used for `echo="all"`...
     def __str__(self):
         comment = f"# tool result ({self.id})"
-        value, language = self._get_value_and_language()
-
-        return f"""```{language}\n{comment}\n{value}\n```"""
+        value = self._get_value(pretty=True)
+        return f"""```python\n{comment}\n{value}\n```"""
 
+    # ... and for displaying in the notebook
     def _repr_markdown_(self):
         return self.__str__()
 
@@ -224,9 +227,9 @@ class ContentToolResult(Content):
             res += f" error='{self.error}'"
         return res + ">"
 
+    # The actual value to send to the model
     def get_final_value(self) -> str:
-        value, _language = self._get_value_and_language()
-        return value
+        return self._get_value()
 
 
 @dataclass

chatlas/_display.py

@@ -6,6 +6,7 @@ from uuid import uuid4
 from rich.live import Live
 from rich.logging import RichHandler
 
+from ._live_render import LiveRender
 from ._logging import logger
 from ._typing_extensions import TypedDict
 
@@ -44,13 +45,22 @@ class LiveMarkdownDisplay(MarkdownDisplay):
         from rich.console import Console
 
         self.content: str = ""
-        self.live = Live(
+        live = Live(
             auto_refresh=False,
-            vertical_overflow="visible",
             console=Console(
                 **echo_options["rich_console"],
             ),
         )
+
+        # Monkeypatch LiveRender() with our own version that add "crop_above"
+        # https://github.com/Textualize/rich/blob/43d3b047/rich/live.py#L87-L89
+        live.vertical_overflow = "crop_above"
+        live._live_render = LiveRender(  # pyright: ignore[reportAttributeAccessIssue]
+            live.get_renderable(), vertical_overflow="crop_above"
+        )
+
+        self.live = live
+
         self._markdown_options = echo_options["rich_markdown"]
 
     def update(self, content: str):

chatlas/_github.py

@@ -43,7 +43,7 @@ def ChatGithub(
     ::: {.callout-note}
     ## Python requirements
 
-    `ChatGithub` requires the `openai` package (e.g., `pip install openai`).
+    `ChatGithub` requires the `openai` package: `pip install "chatlas[github]"`.
     :::
 
 

chatlas/_google.py

@@ -61,8 +61,7 @@ def ChatGoogle(
     ::: {.callout-note}
     ## Python requirements
 
-    `ChatGoogle` requires the `google-genai` package
-    (e.g., `pip install google-genai`).
+    `ChatGoogle` requires the `google-genai` package: `pip install "chatlas[google]"`.
     :::
 
     Examples
@@ -413,7 +412,7 @@ class GoogleProvider(
         elif isinstance(content, ContentToolRequest):
             return Part(
                 function_call=FunctionCall(
-                    id=content.id,
+                    id=content.id if content.name != content.id else None,
                     name=content.name,
                     # Goes in a dict, so should come out as a dict
                     args=cast(dict[str, Any], content.arguments),
@@ -428,7 +427,7 @@ class GoogleProvider(
                 # TODO: seems function response parts might need role='tool'???
                 # https://github.com/googleapis/python-genai/blame/c8cfef85c/README.md#L344
                 function_response=FunctionResponse(
-                    id=content.id,
+                    id=content.id if content.name != content.id else None,
                     name=content.name,
                     response=resp,
                 )
@@ -530,8 +529,7 @@ def ChatVertex(
     ::: {.callout-note}
     ## Python requirements
 
-    `ChatGoogle` requires the `google-genai` package
-    (e.g., `pip install google-genai`).
+    `ChatGoogle` requires the `google-genai` package: `pip install "chatlas[vertex]"`.
     :::
 
     ::: {.callout-note}

chatlas/_groq.py

@@ -41,7 +41,7 @@ def ChatGroq(
     ::: {.callout-note}
     ## Python requirements
 
-    `ChatGroq` requires the `openai` package (e.g., `pip install openai`).
+    `ChatGroq` requires the `openai` package: `pip install "chatlas[groq]"`.
     :::
 
     Examples

chatlas/_live_render.py

@@ -0,0 +1,116 @@
+# A 'patched' version of LiveRender that adds the 'crop_above' vertical overflow method.
+# Derives from https://github.com/Textualize/rich/pull/3637
+import sys
+from typing import Optional, Tuple
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal  # pragma: no cover
+
+from rich._loop import loop_last
+from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
+from rich.control import Control
+from rich.segment import ControlType, Segment
+from rich.style import StyleType
+from rich.text import Text
+
+VerticalOverflowMethod = Literal["crop", "crop_above", "ellipsis", "visible"]
+
+
+class LiveRender:
+    """Creates a renderable that may be updated.
+
+    Args:
+        renderable (RenderableType): Any renderable object.
+        style (StyleType, optional): An optional style to apply to the renderable. Defaults to "".
+    """
+
+    def __init__(
+        self,
+        renderable: RenderableType,
+        style: StyleType = "",
+        vertical_overflow: VerticalOverflowMethod = "ellipsis",
+    ) -> None:
+        self.renderable = renderable
+        self.style = style
+        self.vertical_overflow = vertical_overflow
+        self._shape: Optional[Tuple[int, int]] = None
+
+    def set_renderable(self, renderable: RenderableType) -> None:
+        """Set a new renderable.
+
+        Args:
+            renderable (RenderableType): Any renderable object, including str.
+        """
+        self.renderable = renderable
+
+    def position_cursor(self) -> Control:
+        """Get control codes to move cursor to beginning of live render.
+
+        Returns:
+            Control: A control instance that may be printed.
+        """
+        if self._shape is not None:
+            _, height = self._shape
+            return Control(
+                ControlType.CARRIAGE_RETURN,
+                (ControlType.ERASE_IN_LINE, 2),
+                *(
+                    (
+                        (ControlType.CURSOR_UP, 1),
+                        (ControlType.ERASE_IN_LINE, 2),
+                    )
+                    * (height - 1)
+                ),
+            )
+        return Control()
+
+    def restore_cursor(self) -> Control:
+        """Get control codes to clear the render and restore the cursor to its previous position.
+
+        Returns:
+            Control: A Control instance that may be printed.
+        """
+        if self._shape is not None:
+            _, height = self._shape
+            return Control(
+                ControlType.CARRIAGE_RETURN,
+                *((ControlType.CURSOR_UP, 1), (ControlType.ERASE_IN_LINE, 2)) * height,
+            )
+        return Control()
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        renderable = self.renderable
+        style = console.get_style(self.style)
+        lines = console.render_lines(renderable, options, style=style, pad=False)
+        shape = Segment.get_shape(lines)
+
+        _, height = shape
+        if height > options.size.height:
+            if self.vertical_overflow == "crop":
+                lines = lines[: options.size.height]
+                shape = Segment.get_shape(lines)
+            elif self.vertical_overflow == "crop_above":
+                lines = lines[-(options.size.height) :]
+                shape = Segment.get_shape(lines)
+            elif self.vertical_overflow == "ellipsis":
+                lines = lines[: (options.size.height - 1)]
+                overflow_text = Text(
+                    "...",
+                    overflow="crop",
+                    justify="center",
+                    end="",
+                    style="live.ellipsis",
+                )
+                lines.append(list(console.render(overflow_text)))
+                shape = Segment.get_shape(lines)
+        self._shape = shape
+
+        new_line = Segment.line()
+        for last, line in loop_last(lines):
+            yield from line
+            if not last:
+                yield new_line

chatlas/_ollama.py

@@ -51,7 +51,7 @@ def ChatOllama(
     ::: {.callout-note}
     ## Python requirements
 
-    `ChatOllama` requires the `openai` package (e.g., `pip install openai`).
+    `ChatOllama` requires the `openai` package: `pip install "chatlas[ollama]"`.
     :::
 
 

chatlas/_openai.py

@@ -79,7 +79,7 @@ def ChatOpenAI(
     ::: {.callout-note}
     ## Python requirements
 
-    `ChatOpenAI` requires the `openai` package (e.g., `pip install openai`).
+    `ChatOpenAI` requires the `openai` package: `pip install "chatlas[openai]"`.
     :::
 
     Examples
@@ -592,7 +592,8 @@ def ChatAzureOpenAI(
     ::: {.callout-note}
     ## Python requirements
 
-    `ChatAzureOpenAI` requires the `openai` package (e.g., `pip install openai`).
+    `ChatAzureOpenAI` requires the `openai` package:
+    `pip install "chatlas[azure-openai]"`.
     :::
 
     Examples

chatlas/_perplexity.py

@@ -43,7 +43,7 @@ def ChatPerplexity(
     ::: {.callout-note}
     ## Python requirements
 
-    `ChatPerplexity` requires the `openai` package (e.g., `pip install openai`).
+    `ChatPerplexity` requires the `openai` package: `pip install "chatlas[perplexity]"`.
     :::
 
 

chatlas/_snowflake.py

@@ -0,0 +1,321 @@
+from typing import TYPE_CHECKING, Literal, Optional, TypedDict, overload
+
+from pydantic import BaseModel
+
+from ._chat import Chat
+from ._content import Content
+from ._logging import log_model_default
+from ._provider import Provider
+from ._tools import Tool
+from ._turn import Turn, normalize_turns
+from ._utils import drop_none
+
+if TYPE_CHECKING:
+    from snowflake.snowpark import Column
+
+    # Types inferred from the return type of the `snowflake.cortex.complete` function
+    Completion = str | Column
+    CompletionChunk = str
+
+    from .types.snowflake import SubmitInputArgs
+
+
+# The main prompt input type for Snowflake
+# This was copy-pasted from `snowflake.cortex._complete.ConversationMessage`
+class ConversationMessage(TypedDict):
+    role: str
+    content: str
+
+
+def ChatSnowflake(
+    *,
+    system_prompt: Optional[str] = None,
+    model: Optional[str] = None,
+    turns: Optional[list[Turn]] = None,
+    connection_name: Optional[str] = None,
+    account: Optional[str] = None,
+    user: Optional[str] = None,
+    password: Optional[str] = None,
+    private_key_file: Optional[str] = None,
+    private_key_file_pwd: Optional[str] = None,
+    kwargs: Optional[dict[str, "str | int"]] = None,
+) -> Chat["SubmitInputArgs", "Completion"]:
+    """
+    Chat with a Snowflake Cortex LLM
+
+    https://docs.snowflake.com/en/user-guide/snowflake-cortex/llm-functions
+
+    Prerequisites
+    -------------
+
+    ::: {.callout-note}
+    ## Python requirements
+
+    `ChatSnowflake`, requires the `snowflake-ml-python` package:
+    `pip install "chatlas[snowflake]"`.
+    :::
+
+    ::: {.callout-note}
+    ## Snowflake credentials
+
+    Snowflake provides a handful of ways to authenticate, but it's recommended
+    to use [key-pair
+    auth](https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#label-python-connection-toml)
+    to generate a `private_key_file`. It's also recommended to place your
+    credentials in a [`connections.toml`
+    file](https://docs.snowflake.com/en/developer-guide/snowpark/python/creating-session#connect-by-using-the-connections-toml-file).
+
+    This way, once your credentials are in the `connections.toml` file, you can
+    simply call `ChatSnowflake(connection_name="my_connection")` to
+    authenticate. If you don't want to use a `connections.toml` file, you can
+    specify the connection parameters directly (with `account`, `user`,
+    `password`, etc.).
+    :::
+
+
+    Parameters
+    ----------
+    system_prompt
+        A system prompt to set the behavior of the assistant.
+    model
+        The model to use for the chat. The default, None, will pick a reasonable
+        default, and warn you about it. We strongly recommend explicitly
+        choosing a model for all but the most casual use.
+    turns
+        A list of turns to start the chat with (i.e., continuing a previous
+        conversation). If not provided, the conversation begins from scratch. Do
+        not provide non-None values for both `turns` and `system_prompt`. Each
+        message in the list should be a dictionary with at least `role` (usually
+        `system`, `user`, or `assistant`, but `tool` is also possible). Normally
+        there is also a `content` field, which is a string.
+    connection_name
+        The name of the connection (i.e., section) within the connections.toml file.
+        This is useful if you want to keep your credentials in a connections.toml file
+        rather than specifying them directly in the arguments.
+        https://docs.snowflake.com/en/developer-guide/snowpark/python/creating-session#connect-by-using-the-connections-toml-file
+    account
+        Your Snowflake account identifier. Required if `connection_name` is not provided.
+        https://docs.snowflake.com/en/user-guide/admin-account-identifier
+    user
+        Your Snowflake user name. Required if `connection_name` is not provided.
+    password
+        Your Snowflake password. Required if doing password authentication and
+        `connection_name` is not provided.
+    private_key_file
+        The path to your private key file. Required if you are using key pair authentication.
+        https://docs.snowflake.com/en/user-guide/key-pair-auth
+    private_key_file_pwd
+        The password for your private key file. Required if you are using key pair authentication.
+        https://docs.snowflake.com/en/user-guide/key-pair-auth
+    kwargs
+        Additional keyword arguments passed along to the Snowflake connection builder. These can
+        include any parameters supported by the `snowflake-ml-python` package.
+        https://docs.snowflake.com/en/developer-guide/snowpark/python/creating-session#connect-by-specifying-connection-parameters
+    """
+
+    if model is None:
+        model = log_model_default("llama3.1-70b")
+
+    return Chat(
+        provider=SnowflakeProvider(
+            model=model,
+            connection_name=connection_name,
+            account=account,
+            user=user,
+            password=password,
+            private_key_file=private_key_file,
+            private_key_file_pwd=private_key_file_pwd,
+            kwargs=kwargs,
+        ),
+        turns=normalize_turns(
+            turns or [],
+            system_prompt,
+        ),
+    )
+
+
+class SnowflakeProvider(Provider["Completion", "CompletionChunk", "CompletionChunk"]):
+    def __init__(
+        self,
+        *,
+        model: str,
+        connection_name: Optional[str],
+        account: Optional[str],
+        user: Optional[str],
+        password: Optional[str],
+        private_key_file: Optional[str],
+        private_key_file_pwd: Optional[str],
+        kwargs: Optional[dict[str, "str | int"]],
+    ):
+        try:
+            from snowflake.snowpark import Session
+        except ImportError:
+            raise ImportError(
+                "`ChatSnowflake()` requires the `snowflake-ml-python` package. "
+                "Please install it via `pip install snowflake-ml-python`."
+            )
+
+        configs: dict[str, str | int] = drop_none(
+            {
+                "connection_name": connection_name,
+                "account": account,
+                "user": user,
+                "password": password,
+                "private_key_file": private_key_file,
+                "private_key_file_pwd": private_key_file_pwd,
+                **(kwargs or {}),
+            }
+        )
+
+        self._model = model
+        self._session = Session.builder.configs(configs).create()
+
+    @overload
+    def chat_perform(
+        self,
+        *,
+        stream: Literal[False],
+        turns: list[Turn],
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]] = None,
+        kwargs: Optional["SubmitInputArgs"] = None,
+    ): ...
+
+    @overload
+    def chat_perform(
+        self,
+        *,
+        stream: Literal[True],
+        turns: list[Turn],
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]] = None,
+        kwargs: Optional["SubmitInputArgs"] = None,
+    ): ...
+
+    def chat_perform(
+        self,
+        *,
+        stream: bool,
+        turns: list[Turn],
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]] = None,
+        kwargs: Optional["SubmitInputArgs"] = None,
+    ):
+        from snowflake.cortex import complete
+
+        kwargs = self._chat_perform_args(stream, turns, tools, data_model, kwargs)
+        return complete(**kwargs)
+
+    @overload
+    async def chat_perform_async(
+        self,
+        *,
+        stream: Literal[False],
+        turns: list[Turn],
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]] = None,
+        kwargs: Optional["SubmitInputArgs"] = None,
+    ): ...
+
+    @overload
+    async def chat_perform_async(
+        self,
+        *,
+        stream: Literal[True],
+        turns: list[Turn],
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]] = None,
+        kwargs: Optional["SubmitInputArgs"] = None,
+    ): ...
+
+    async def chat_perform_async(
+        self,
+        *,
+        stream: bool,
+        turns: list[Turn],
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]] = None,
+        kwargs: Optional["SubmitInputArgs"] = None,
+    ):
+        raise NotImplementedError(
+            "Snowflake does not currently support async completions."
+        )
+
+    def _chat_perform_args(
+        self,
+        stream: bool,
+        turns: list[Turn],
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]] = None,
+        kwargs: Optional["SubmitInputArgs"] = None,
+    ):
+        # Cortex doesn't seem to support tools
+        if tools:
+            raise ValueError("Snowflake does not currently support tools.")
+
+        # TODO: implement data_model when this PR makes it into snowflake-ml-python
+        # https://github.com/snowflakedb/snowflake-ml-python/pull/141
+        # https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-llm-rest-api#structured-output-example
+        if data_model:
+            raise NotImplementedError(
+                "The snowflake-ml-python package currently doesn't support structured output. "
+                "Upvote this PR to help prioritize it: "
+                "https://github.com/snowflakedb/snowflake-ml-python/pull/141"
+            )
+
+        kwargs_full: "SubmitInputArgs" = {
+            "stream": stream,
+            "prompt": self._as_prompt_input(turns),
+            "model": self._model,
+            **(kwargs or {}),
+        }
+
+        return kwargs_full
+
+    def stream_text(self, chunk):
+        return chunk
+
+    def stream_merge_chunks(self, completion, chunk):
+        if completion is None:
+            return chunk
+        return completion + chunk
+
+    def stream_turn(self, completion, has_data_model) -> Turn:
+        return self._as_turn(completion, has_data_model)
+
+    def value_turn(self, completion, has_data_model) -> Turn:
+        return self._as_turn(completion, has_data_model)
+
+    def token_count(
+        self,
+        *args: "Content | str",
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ) -> int:
+        raise NotImplementedError(
+            "Snowflake does not currently support token counting."
+        )
+
+    async def token_count_async(
+        self,
+        *args: "Content | str",
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ) -> int:
+        raise NotImplementedError(
+            "Snowflake does not currently support token counting."
+        )
+
+    def _as_prompt_input(self, turns: list[Turn]) -> list["ConversationMessage"]:
+        res: list["ConversationMessage"] = []
+        for turn in turns:
+            res.append(
+                {
+                    "role": turn.role,
+                    "content": turn.text,
+                }
+            )
+        return res
+
+    def _as_turn(self, completion, has_data_model) -> Turn:
+        return Turn("assistant", completion)

chatlas/_utils.py

@@ -61,6 +61,13 @@ def is_async_callable(
     return False
 
 
+T = TypeVar("T")
+
+
+def drop_none(x: dict[str, T | None]) -> dict[str, T]:
+    return {k: v for k, v in x.items() if v is not None}
+
+
 # https://docs.pytest.org/en/latest/example/simple.html#pytest-current-test-environment-variable
 def is_testing():
     return os.environ.get("PYTEST_CURRENT_TEST", None) is not None

chatlas/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)

chatlas/types/anthropic/_submit.py

@@ -8,10 +8,15 @@ from typing import Iterable, Literal, Mapping, Optional, TypedDict, Union
 import anthropic
 import anthropic.types.message_param
 import anthropic.types.text_block_param
+import anthropic.types.thinking_config_disabled_param
+import anthropic.types.thinking_config_enabled_param
+import anthropic.types.tool_bash_20250124_param
 import anthropic.types.tool_choice_any_param
 import anthropic.types.tool_choice_auto_param
+import anthropic.types.tool_choice_none_param
 import anthropic.types.tool_choice_tool_param
 import anthropic.types.tool_param
+import anthropic.types.tool_text_editor_20250124_param
 
 
 class SubmitInputArgs(TypedDict, total=False):
@@ -19,6 +24,8 @@ class SubmitInputArgs(TypedDict, total=False):
     messages: Iterable[anthropic.types.message_param.MessageParam]
     model: Union[
         Literal[
+            "claude-3-7-sonnet-latest",
+            "claude-3-7-sonnet-20250219",
             "claude-3-5-haiku-latest",
             "claude-3-5-haiku-20241022",
             "claude-3-5-sonnet-latest",
@@ -41,13 +48,28 @@ class SubmitInputArgs(TypedDict, total=False):
         anthropic.NotGiven,
     ]
     temperature: float | anthropic.NotGiven
+    thinking: Union[
+        anthropic.types.thinking_config_enabled_param.ThinkingConfigEnabledParam,
+        anthropic.types.thinking_config_disabled_param.ThinkingConfigDisabledParam,
+        anthropic.NotGiven,
+    ]
     tool_choice: Union[
         anthropic.types.tool_choice_auto_param.ToolChoiceAutoParam,
         anthropic.types.tool_choice_any_param.ToolChoiceAnyParam,
         anthropic.types.tool_choice_tool_param.ToolChoiceToolParam,
+        anthropic.types.tool_choice_none_param.ToolChoiceNoneParam,
+        anthropic.NotGiven,
+    ]
+    tools: Union[
+        Iterable[
+            Union[
+                anthropic.types.tool_param.ToolParam,
+                anthropic.types.tool_bash_20250124_param.ToolBash20250124Param,
+                anthropic.types.tool_text_editor_20250124_param.ToolTextEditor20250124Param,
+            ]
+        ],
         anthropic.NotGiven,
     ]
-    tools: Union[Iterable[anthropic.types.tool_param.ToolParam], anthropic.NotGiven]
     top_k: int | anthropic.NotGiven
     top_p: float | anthropic.NotGiven
     extra_headers: Optional[Mapping[str, Union[str, anthropic.Omit]]]

chatlas/types/openai/_submit.py

@@ -46,6 +46,11 @@ 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",
@@ -110,8 +115,8 @@ class SubmitInputArgs(TypedDict, total=False):
     reasoning_effort: Union[Literal["low", "medium", "high"], None, openai.NotGiven]
     response_format: Union[
         openai.types.shared_params.response_format_text.ResponseFormatText,
-        openai.types.shared_params.response_format_json_object.ResponseFormatJSONObject,
         openai.types.shared_params.response_format_json_schema.ResponseFormatJSONSchema,
+        openai.types.shared_params.response_format_json_object.ResponseFormatJSONObject,
         openai.NotGiven,
     ]
     seed: Union[int, None, openai.NotGiven]

chatlas/types/snowflake/__init__.py

@@ -0,0 +1,8 @@
+# ---------------------------------------------------------
+# Do not modify this file. It was generated by `scripts/generate_typed_dicts.py`.
+# ---------------------------------------------------------
+
+
+from ._submit import SubmitInputArgs
+
+__all__ = ("SubmitInputArgs",)

chatlas/types/snowflake/_submit.py

@@ -0,0 +1,24 @@
+# ---------------------------------------------------------
+# Do not modify this file. It was generated by `scripts/generate_typed_dicts.py`.
+# ---------------------------------------------------------
+
+
+from typing import Optional, TypedDict, Union
+
+import snowflake.cortex._complete
+import snowflake.snowpark.column
+import snowflake.snowpark.session
+
+
+class SubmitInputArgs(TypedDict, total=False):
+    model: Union[str, snowflake.snowpark.column.Column]
+    prompt: Union[
+        str,
+        list[snowflake.cortex._complete.ConversationMessage],
+        snowflake.snowpark.column.Column,
+    ]
+    options: Optional[snowflake.cortex._complete.CompleteOptions]
+    session: Optional[snowflake.snowpark.session.Session]
+    stream: bool
+    timeout: Optional[float]
+    deadline: Optional[float]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatlas
-Version: 0.4.0
+Version: 0.5.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
@@ -20,6 +20,12 @@ Requires-Python: >=3.9
 Requires-Dist: jinja2
 Requires-Dist: pydantic>=2.0
 Requires-Dist: rich
+Provides-Extra: anthropic
+Requires-Dist: anthropic; extra == 'anthropic'
+Provides-Extra: azure-openai
+Requires-Dist: openai; extra == 'azure-openai'
+Provides-Extra: bedrock-anthropic
+Requires-Dist: anthropic[bedrock]; extra == 'bedrock-anthropic'
 Provides-Extra: dev
 Requires-Dist: anthropic[bedrock]; extra == 'dev'
 Requires-Dist: google-genai>=1.2.0; extra == 'dev'
@@ -30,7 +36,9 @@ Requires-Dist: pillow; extra == 'dev'
 Requires-Dist: python-dotenv; extra == 'dev'
 Requires-Dist: ruff>=0.6.5; extra == 'dev'
 Requires-Dist: shiny; extra == 'dev'
+Requires-Dist: snowflake-ml-python; extra == 'dev'
 Requires-Dist: tiktoken; extra == 'dev'
+Requires-Dist: torch; (python_version <= '3.11') and extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: griffe>=1; extra == 'docs'
 Requires-Dist: ipykernel; extra == 'docs'
@@ -42,11 +50,27 @@ Requires-Dist: pandas; extra == 'docs'
 Requires-Dist: pyyaml; extra == 'docs'
 Requires-Dist: quartodoc>=0.7; extra == 'docs'
 Requires-Dist: sentence-transformers; extra == 'docs'
+Provides-Extra: github
+Requires-Dist: openai; extra == 'github'
+Provides-Extra: google
+Requires-Dist: google-genai; extra == 'google'
+Provides-Extra: groq
+Requires-Dist: openai; extra == 'groq'
+Provides-Extra: ollama
+Requires-Dist: openai; extra == 'ollama'
+Provides-Extra: openai
+Requires-Dist: openai; extra == 'openai'
+Provides-Extra: perplexity
+Requires-Dist: openai; extra == 'perplexity'
+Provides-Extra: snowflake
+Requires-Dist: snowflake-ml-python; extra == 'snowflake'
 Provides-Extra: test
 Requires-Dist: pyright>=1.1.379; extra == 'test'
 Requires-Dist: pytest-asyncio; extra == 'test'
 Requires-Dist: pytest>=8.3.2; extra == 'test'
 Requires-Dist: syrupy>=4; extra == 'test'
+Provides-Extra: vertex
+Requires-Dist: google-genai; extra == 'vertex'
 Description-Content-Type: text/markdown
 
 <h1 class="unnumbered unlisted"> chatlas <a href="https://posit-dev.github.io/chatlas"><img src="docs/images/logo.png" align="right" height="138" alt="chatlas website" /></a> </h1> 
@@ -98,6 +122,7 @@ It also supports the following enterprise cloud providers:
 
 * AWS Bedrock: [`ChatBedrockAnthropic()`](https://posit-dev.github.io/chatlas/reference/ChatBedrockAnthropic.html).
 * Azure OpenAI: [`ChatAzureOpenAI()`](https://posit-dev.github.io/chatlas/reference/ChatAzureOpenAI.html).
+* Snowflake Cortex: [`ChatSnowflake()`](https://posit-dev.github.io/chatlas/reference/ChatSnowflake.html).
 * Vertex AI: [`ChatVertex()`](https://posit-dev.github.io/chatlas/reference/ChatVertex.html).
 
 To use a model provider that isn't listed here, you have two options:

chatlas-0.5.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+chatlas/__init__.py,sha256=U-uNJWeVjMj4aSre2evTaVunabzLksZ5Toz19ygQB-o,1251
+chatlas/_anthropic.py,sha256=-Qrq-8jgNIpW_temJYXKTb7VCl2ldnpe-KSX89L5Lhc,24264
+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/_display.py,sha256=eqdRIwQenyJxswmTEjnJ1n9YxxSxsa8vHVmA79449_o,4439
+chatlas/_github.py,sha256=8_vvUIBCprgrQ5UItky5yETfEQPG2fCMM57ga77p28E,4377
+chatlas/_google.py,sha256=ehL8hf8Hogg9qK9OaXqiWainOirz21yy_lx_yvUwKf8,18831
+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/_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/_typing_extensions.py,sha256=YdzmlyPSBpIEcsOkoz12e6jETT1XEMV2Q72haE4cfwY,1036
+chatlas/_utils.py,sha256=2TPy5_8dr9QDF1YShZN-CjxRVHeArSujRiaF0SKnI4o,2895
+chatlas/_version.py,sha256=N2U3TRgLfYxjXfoF4Dy9PxAbZq24zjCym3P3cwuxKP8,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
+chatlas/types/anthropic/_client.py,sha256=G0LRhoFBcsSOMr5qhP-0rAScsVXaVlHCpggfVp54bnQ,690
+chatlas/types/anthropic/_client_bedrock.py,sha256=mNazQlu0pQt8JdzrYn3LKNgE4n732GjhQUJdQQK9QkY,785
+chatlas/types/anthropic/_submit.py,sha256=xoQyZ3SUUttWDPAjZTPfFch7D1bIU0AJNsenViYhAKs,2974
+chatlas/types/google/__init__.py,sha256=ZJhi8Kwvio2zp8T1TQqmvdHqkS-Khb6BGESPjREADgo,337
+chatlas/types/google/_client.py,sha256=t7aKbxYq_xOA1Z3RnWcjewifdQFSHi7vKEj6MyKMCJk,729
+chatlas/types/google/_submit.py,sha256=b-ZqMvI551Ia7pFlWdqUQJjov3neHmVwLFw-P2bgU8w,1883
+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/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.4.0.dist-info/RECORD

@@ -1,38 +0,0 @@
-chatlas/__init__.py,sha256=HtvcxTy7A3CO7d6JSZIGDqIPGBRuo7Vte11nazn_VNE,1004
-chatlas/_anthropic.py,sha256=fygtGcKi5qM1w40AZbcnJcsPUkBEyWuqpoyCOKG-kOc,24259
-chatlas/_chat.py,sha256=15j4w1cvFXrqsf7sGMv8B_TidEiow-szbRr6G-HiSqM,45990
-chatlas/_content.py,sha256=79FTmKrByS-rlg6XTbKQh4klaA4O3MJiljMrYrkr1mU,6334
-chatlas/_content_image.py,sha256=4nk9wTvLtNmtcytdFp8p9otEV5-0_K6wzIxCyK0PIEI,8367
-chatlas/_display.py,sha256=_IcQcvpyTNjGHOpY70_LOrDWwTjzdkziy6pTvxHEiWI,4053
-chatlas/_github.py,sha256=D3L7Qu35K-M1qEW7-w-Oq-pF-9mVetia3MHYNNLEYtU,4373
-chatlas/_google.py,sha256=RUXKUChiEqLzhIO3aWQn2dooJEmHNaX8gFK1a5Pzw1Q,18763
-chatlas/_groq.py,sha256=3VnYiKdxJTHPhEgUKnL2nY5uYL2L4PKBo7GZMwR0D8k,4158
-chatlas/_interpolate.py,sha256=ykwLP3x-ya9Q33U4knSU75dtk6pzJAeythEEIW-43Pc,3631
-chatlas/_logging.py,sha256=7a20sAl1PkW1qBNrfd_ieUbQXV8Gf4Vuf0Wn62LNBmk,2290
-chatlas/_merge.py,sha256=SGj_BetgA7gaOqSBKOhYmW3CYeQKTEehFrXvx3y4OYE,3924
-chatlas/_ollama.py,sha256=ze-RoHEbf62dYmXDDKjNGqaEZaKCZdcBEyFwQMDQxkQ,3760
-chatlas/_openai.py,sha256=Z1y_NdWr3TyrrFGtvYEaTU7cdMQAqLzMiK67-kIa8vM,23852
-chatlas/_perplexity.py,sha256=Bw_mlM8N8egGKIrbNerTn2pMlybugADOshjYOfN1ixM,4446
-chatlas/_provider.py,sha256=YmdBbz_u5aP_kBxl6s26OPiSnWG_vZ_fvf9L2qvBmyI,3809
-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/_typing_extensions.py,sha256=YdzmlyPSBpIEcsOkoz12e6jETT1XEMV2Q72haE4cfwY,1036
-chatlas/_utils.py,sha256=qAiWuDx-uG8BGFZ_PWvum9wpN-WogdItO32X4pRhhLs,2762
-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
-chatlas/types/anthropic/_client.py,sha256=G0LRhoFBcsSOMr5qhP-0rAScsVXaVlHCpggfVp54bnQ,690
-chatlas/types/anthropic/_client_bedrock.py,sha256=mNazQlu0pQt8JdzrYn3LKNgE4n732GjhQUJdQQK9QkY,785
-chatlas/types/anthropic/_submit.py,sha256=cSSomSJ2zfAHu8ilzMN3XxRTLANh00oK_t5kH6N2lCI,2091
-chatlas/types/google/__init__.py,sha256=ZJhi8Kwvio2zp8T1TQqmvdHqkS-Khb6BGESPjREADgo,337
-chatlas/types/google/_client.py,sha256=t7aKbxYq_xOA1Z3RnWcjewifdQFSHi7vKEj6MyKMCJk,729
-chatlas/types/google/_submit.py,sha256=b-ZqMvI551Ia7pFlWdqUQJjov3neHmVwLFw-P2bgU8w,1883
-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=VX2D1eQHF19XRIt-oq90cBSw_3ChokGpwVG7-b2AJOU,6091
-chatlas-0.4.0.dist-info/METADATA,sha256=-ayykYk3sVvvPRlW6jj15U6S76ywblY0p1sD8trc640,13389
-chatlas-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-chatlas-0.4.0.dist-info/RECORD,,