not-again-ai 0.16.1__py3-none-any.whl → 0.18.0__py3-none-any.whl

not_again_ai/llm/__init__.py

@@ -1,15 +0,0 @@
-import importlib.util
-
-if (
-    importlib.util.find_spec("liquid") is None
-    or importlib.util.find_spec("openai") is None
-    or importlib.util.find_spec("tiktoken") is None
-):
-    raise ImportError(
-        "not_again_ai.llm requires the 'llm' extra to be installed. "
-        "You can install it using 'pip install not_again_ai[llm]'."
-    )
-else:
-    import liquid  # noqa: F401
-    import openai  # noqa: F401
-    import tiktoken  # noqa: F401

not_again_ai/llm/chat_completion/__init__.py

@@ -1,4 +1,4 @@
-from not_again_ai.llm.chat_completion.interface import chat_completion
+from not_again_ai.llm.chat_completion.interface import chat_completion, chat_completion_stream
 from not_again_ai.llm.chat_completion.types import ChatCompletionRequest
 
-__all__ = ["ChatCompletionRequest", "chat_completion"]
+__all__ = ["ChatCompletionRequest", "chat_completion", "chat_completion_stream"]

not_again_ai/llm/chat_completion/interface.py

@@ -1,9 +1,10 @@
-from collections.abc import Callable
+from collections.abc import AsyncGenerator, Callable
 from typing import Any
 
-from not_again_ai.llm.chat_completion.providers.ollama_api import ollama_chat_completion
-from not_again_ai.llm.chat_completion.providers.openai_api import openai_chat_completion
-from not_again_ai.llm.chat_completion.types import ChatCompletionRequest, ChatCompletionResponse
+from not_again_ai.llm.chat_completion.providers.anthropic_api import anthropic_chat_completion
+from not_again_ai.llm.chat_completion.providers.ollama_api import ollama_chat_completion, ollama_chat_completion_stream
+from not_again_ai.llm.chat_completion.providers.openai_api import openai_chat_completion, openai_chat_completion_stream
+from not_again_ai.llm.chat_completion.types import ChatCompletionChunk, ChatCompletionRequest, ChatCompletionResponse
 
 
 def chat_completion(
@@ -28,5 +29,37 @@ def chat_completion(
         return openai_chat_completion(request, client)
     elif provider == "ollama":
         return ollama_chat_completion(request, client)
+    elif provider == "anthropic":
+        return anthropic_chat_completion(request, client)
+    else:
+        raise ValueError(f"Provider {provider} not supported")
+
+
+async def chat_completion_stream(
+    request: ChatCompletionRequest,
+    provider: str,
+    client: Callable[..., Any],
+) -> AsyncGenerator[ChatCompletionChunk, None]:
+    """Stream a chat completion response from the given provider. Currently supported providers:
+    - `openai` - OpenAI
+    - `azure_openai` - Azure OpenAI
+    - `ollama` - Ollama
+    - `anthropic` - Anthropic
+
+    Args:
+        request: Request parameter object
+        provider: The supported provider name
+        client: Client information, see the provider's implementation for what can be provided
+
+    Returns:
+        AsyncGenerator[ChatCompletionChunk, None]
+    """
+    request.stream = True
+    if provider == "openai" or provider == "azure_openai":
+        async for chunk in openai_chat_completion_stream(request, client):
+            yield chunk
+    elif provider == "ollama":
+        async for chunk in ollama_chat_completion_stream(request, client):
+            yield chunk
     else:
         raise ValueError(f"Provider {provider} not supported")

not_again_ai/llm/chat_completion/providers/anthropic_api.py

@@ -0,0 +1,180 @@
+from collections.abc import Callable
+import os
+import time
+from typing import Any
+
+from anthropic import Anthropic
+from anthropic.types import Message
+
+from not_again_ai.llm.chat_completion.types import (
+    AssistantMessage,
+    ChatCompletionChoice,
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+    Function,
+    ToolCall,
+)
+
+ANTHROPIC_PARAMETER_MAP = {
+    "max_completion_tokens": "max_tokens",
+}
+
+
+def anthropic_chat_completion(request: ChatCompletionRequest, client: Callable[..., Any]) -> ChatCompletionResponse:
+    """Anthropic chat completion function.
+
+    TODO
+    - Image messages
+    - Thinking
+    - Citations
+    - Stop sequences
+    - Documents
+    """
+    kwargs = request.model_dump(mode="json", exclude_none=True)
+
+    # For each key in ANTHROPIC_PARAMETER_MAP
+    # If it is not None, set the key in kwargs to the value of the corresponding value in ANTHROPIC_PARAMETER_MAP
+    # If it is None, remove that key from kwargs
+    for key, value in ANTHROPIC_PARAMETER_MAP.items():
+        if value is not None and key in kwargs:
+            kwargs[value] = kwargs.pop(key)
+        elif value is None and key in kwargs:
+            del kwargs[key]
+
+    # Handle messages
+    # Any system messages need to be removed from messages and concatenated into a single string (in order)
+    # Any tool messages need to be converted to a special user message
+    # Any assistant messages with tool calls need to be converted.
+    system = ""
+    new_messages = []
+    for message in kwargs["messages"]:
+        if message["role"] == "system":
+            system += message["content"] + "\n"
+        elif message["role"] == "tool":
+            new_messages.append(
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": message["name"],
+                            "content": message["content"],
+                        }
+                    ],
+                }
+            )
+        elif message["role"] == "assistant":
+            content = []
+            if message.get("content", None):
+                content.append(
+                    {
+                        "type": "text",
+                        "content": message["content"],
+                    }
+                )
+            for tool_call in message.get("tool_calls", []):
+                content.append(
+                    {
+                        "type": "tool_use",
+                        "id": tool_call["id"],
+                        "name": tool_call["function"]["name"],
+                        "input": tool_call["function"]["arguments"],
+                    }
+                )
+            new_messages.append(
+                {
+                    "role": "assistant",
+                    "content": content,
+                }
+            )
+        else:
+            new_messages.append(message)
+    kwargs["messages"] = new_messages
+    system = system.strip()
+    if system:
+        kwargs["system"] = system
+
+    # Handle tool choice and parallel tool calls
+    if kwargs.get("tool_choice") is not None:
+        tool_choice_value = kwargs.pop("tool_choice")
+        tool_choice = {}
+        if tool_choice_value == "none":
+            tool_choice["type"] = "none"
+        elif tool_choice_value in ["auto", "any"]:
+            tool_choice["type"] = "auto"
+            if kwargs.get("parallel_tool_calls") is not None:
+                tool_choice["disable_parallel_tool_use"] = str(not kwargs["parallel_tool_calls"])
+        else:
+            tool_choice["name"] = tool_choice_value
+            tool_choice["type"] = "tool"
+            if kwargs.get("parallel_tool_calls") is not None:
+                tool_choice["disable_parallel_tool_use"] = str(not kwargs["parallel_tool_calls"])
+        kwargs["tool_choice"] = tool_choice
+    kwargs.pop("parallel_tool_calls", None)
+
+    start_time = time.time()
+    response: Message = client(**kwargs)
+    end_time = time.time()
+    response_duration = round(end_time - start_time, 4)
+
+    tool_calls: list[ToolCall] = []
+    assistant_message = ""
+    for block in response.content:
+        if block.type == "text":
+            assistant_message += block.text
+        elif block.type == "tool_use":
+            tool_calls.append(
+                ToolCall(
+                    id=block.id,
+                    function=Function(
+                        name=block.name,
+                        arguments=block.input,  # type: ignore
+                    ),
+                )
+            )
+
+    choice = ChatCompletionChoice(
+        message=AssistantMessage(
+            content=assistant_message,
+            tool_calls=tool_calls,
+        ),
+        finish_reason=response.stop_reason or "stop",
+    )
+
+    chat_completion_response = ChatCompletionResponse(
+        choices=[choice],
+        errors="",
+        completion_tokens=response.usage.output_tokens,
+        prompt_tokens=response.usage.input_tokens,
+        cache_read_input_tokens=response.usage.cache_read_input_tokens,
+        cache_creation_input_tokens=response.usage.cache_creation_input_tokens,
+        response_duration=response_duration,
+    )
+    return chat_completion_response
+
+
+def create_client_callable(client_class: type[Anthropic], **client_args: Any) -> Callable[..., Any]:
+    """Creates a callable that instantiates and uses an Anthropic client.
+
+    Args:
+        client_class: The Anthropic client class to instantiate
+        **client_args: Arguments to pass to the client constructor
+
+    Returns:
+        A callable that creates a client and returns completion results
+    """
+    filtered_args = {k: v for k, v in client_args.items() if v is not None}
+
+    def client_callable(**kwargs: Any) -> Any:
+        client = client_class(**filtered_args)
+        completion = client.beta.messages.create(**kwargs)
+        return completion
+
+    return client_callable
+
+
+def anthropic_client(api_key: str | None = None) -> Callable[..., Any]:
+    if not api_key:
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+    client_callable = create_client_callable(Anthropic, api_key=api_key)
+    return client_callable

not_again_ai/llm/chat_completion/providers/ollama_api.py

@@ -1,4 +1,4 @@
-from collections.abc import Callable
+from collections.abc import AsyncGenerator, Callable
 import json
 import os
 import re
@@ -6,14 +6,20 @@ import time
 from typing import Any, Literal, cast
 
 from loguru import logger
-from ollama import ChatResponse, Client, ResponseError
+from ollama import AsyncClient, ChatResponse, Client, ResponseError
 
 from not_again_ai.llm.chat_completion.types import (
     AssistantMessage,
     ChatCompletionChoice,
+    ChatCompletionChoiceStream,
+    ChatCompletionChunk,
+    ChatCompletionDelta,
     ChatCompletionRequest,
     ChatCompletionResponse,
     Function,
+    PartialFunction,
+    PartialToolCall,
+    Role,
     ToolCall,
 )
 
@@ -51,14 +57,8 @@ def validate(request: ChatCompletionRequest) -> None:
         raise ValueError("`max_tokens` and `max_completion_tokens` cannot both be provided.")
 
 
-def ollama_chat_completion(
-    request: ChatCompletionRequest,
-    client: Callable[..., Any],
-) -> ChatCompletionResponse:
-    validate(request)
-
+def format_kwargs(request: ChatCompletionRequest) -> dict[str, Any]:
     kwargs = request.model_dump(mode="json", exclude_none=True)
-
     # For each key in OLLAMA_PARAMETER_MAP
     # If it is not None, set the key in kwargs to the value of the corresponding value in OLLAMA_PARAMETER_MAP
     # If it is None, remove that key from kwargs
@@ -141,6 +141,16 @@ def ollama_chat_completion(
             logger.warning("Ollama model only supports a single image per message. Using only the first images.")
         message["images"] = images
 
+    return kwargs
+
+
+def ollama_chat_completion(
+    request: ChatCompletionRequest,
+    client: Callable[..., Any],
+) -> ChatCompletionResponse:
+    validate(request)
+    kwargs = format_kwargs(request)
+
     try:
         start_time = time.time()
         response: ChatResponse = client(**kwargs)
@@ -164,7 +174,7 @@ def ollama_chat_completion(
             tool_name = tool_call.function.name
             if request.tools and tool_name not in [tool["function"]["name"] for tool in request.tools]:
                 errors += f"Tool call {tool_call} has an invalid tool name: {tool_name}\n"
-            tool_args = tool_call.function.arguments
+            tool_args = dict(tool_call.function.arguments)
             parsed_tool_calls.append(
                 ToolCall(
                     id="",
@@ -206,7 +216,65 @@ def ollama_chat_completion(
     )
 
 
-def ollama_client(host: str | None = None, timeout: float | None = None) -> Callable[..., Any]:
+async def ollama_chat_completion_stream(
+    request: ChatCompletionRequest,
+    client: Callable[..., Any],
+) -> AsyncGenerator[ChatCompletionChunk, None]:
+    validate(request)
+    kwargs = format_kwargs(request)
+
+    start_time = time.time()
+    stream = await client(**kwargs)
+
+    async for chunk in stream:
+        errors = ""
+        # Handle tool calls
+        tool_calls: list[PartialToolCall] | None = None
+        if chunk.message.tool_calls:
+            parsed_tool_calls: list[PartialToolCall] = []
+            for tool_call in chunk.message.tool_calls:
+                tool_name = tool_call.function.name
+                if request.tools and tool_name not in [tool["function"]["name"] for tool in request.tools]:
+                    errors += f"Tool call {tool_call} has an invalid tool name: {tool_name}\n"
+                tool_args = tool_call.function.arguments
+
+                parsed_tool_calls.append(
+                    PartialToolCall(
+                        id="",
+                        function=PartialFunction(
+                            name=tool_name,
+                            arguments=tool_args,
+                        ),
+                    )
+                )
+            tool_calls = parsed_tool_calls
+
+        current_time = time.time()
+        response_duration = round(current_time - start_time, 4)
+
+        delta = ChatCompletionDelta(
+            content=chunk.message.content or "",
+            role=Role.ASSISTANT,
+            tool_calls=tool_calls,
+        )
+        choice_obj = ChatCompletionChoiceStream(
+            delta=delta,
+            finish_reason=chunk.done_reason,
+            index=0,
+        )
+        chunk_obj = ChatCompletionChunk(
+            choices=[choice_obj],
+            errors=errors.strip(),
+            completion_tokens=chunk.get("eval_count", None),
+            prompt_tokens=chunk.get("prompt_eval_count", None),
+            response_duration=response_duration,
+        )
+        yield chunk_obj
+
+
+def ollama_client(
+    host: str | None = None, timeout: float | None = None, async_client: bool = False
+) -> Callable[..., Any]:
     """Create an Ollama client instance based on the specified host or will read from the OLLAMA_HOST environment variable.
 
     Args:
@@ -226,7 +294,7 @@ def ollama_client(host: str | None = None, timeout: float | None = None) -> Call
             host = "http://localhost:11434"
 
     def client_callable(**kwargs: Any) -> Any:
-        client = Client(host=host, timeout=timeout)
+        client = AsyncClient(host=host, timeout=timeout) if async_client else Client(host=host, timeout=timeout)
         return client.chat(**kwargs)
 
     return client_callable

not_again_ai/llm/chat_completion/providers/openai_api.py

@@ -1,17 +1,23 @@
-from collections.abc import Callable
+from collections.abc import AsyncGenerator, Callable, Coroutine
 import json
 import time
 from typing import Any, Literal
 
 from azure.identity import DefaultAzureCredential, get_bearer_token_provider
-from openai import AzureOpenAI, OpenAI
+from openai import AsyncAzureOpenAI, AsyncOpenAI, AzureOpenAI, OpenAI
 
 from not_again_ai.llm.chat_completion.types import (
     AssistantMessage,
     ChatCompletionChoice,
+    ChatCompletionChoiceStream,
+    ChatCompletionChunk,
+    ChatCompletionDelta,
     ChatCompletionRequest,
     ChatCompletionResponse,
     Function,
+    PartialFunction,
+    PartialToolCall,
+    Role,
     ToolCall,
 )
 
@@ -36,12 +42,7 @@ def validate(request: ChatCompletionRequest) -> None:
         raise ValueError("`max_tokens` and `max_completion_tokens` cannot both be provided.")
 
 
-def openai_chat_completion(
-    request: ChatCompletionRequest,
-    client: Callable[..., Any],
-) -> ChatCompletionResponse:
-    validate(request)
-
+def format_kwargs(request: ChatCompletionRequest) -> dict[str, Any]:
     # Format the response format parameters to be compatible with OpenAI API
     if request.json_mode:
         response_format: dict[str, Any] = {"type": "json_object"}
@@ -61,7 +62,6 @@ def openai_chat_completion(
         elif value is None and key in kwargs:
             del kwargs[key]
 
-    # Iterate over each message and
     for message in kwargs["messages"]:
         role = message.get("role", None)
         # For each ToolMessage, change the "name" field to be named "tool_call_id" instead
@@ -84,6 +84,49 @@ def openai_chat_completion(
     if request.tool_choice is not None and request.tool_choice not in ["none", "auto", "required"]:
         kwargs["tool_choice"] = {"type": "function", "function": {"name": request.tool_choice}}
 
+    return kwargs
+
+
+def process_logprobs(logprobs_content: list[dict[str, Any]]) -> list[dict[str, Any] | list[dict[str, Any]]]:
+    """Process logprobs content from OpenAI API response.
+
+    Args:
+        logprobs_content: List of logprob entries from the API response
+
+    Returns:
+        Processed logprobs list containing either single token info or lists of top token infos
+    """
+    logprobs_list: list[dict[str, Any] | list[dict[str, Any]]] = []
+    for logprob in logprobs_content:
+        if logprob.get("top_logprobs", None):
+            curr_logprob_infos: list[dict[str, Any]] = []
+            for top_logprob in logprob.get("top_logprobs", []):
+                curr_logprob_infos.append(
+                    {
+                        "token": top_logprob.get("token", ""),
+                        "logprob": top_logprob.get("logprob", 0),
+                        "bytes": top_logprob.get("bytes", 0),
+                    }
+                )
+            logprobs_list.append(curr_logprob_infos)
+        else:
+            logprobs_list.append(
+                {
+                    "token": logprob.get("token", ""),
+                    "logprob": logprob.get("logprob", 0),
+                    "bytes": logprob.get("bytes", 0),
+                }
+            )
+    return logprobs_list
+
+
+def openai_chat_completion(
+    request: ChatCompletionRequest,
+    client: Callable[..., Any],
+) -> ChatCompletionResponse:
+    validate(request)
+    kwargs = format_kwargs(request)
+
     start_time = time.time()
     response = client(**kwargs)
     end_time = time.time()
@@ -133,28 +176,7 @@ def openai_chat_completion(
         # Handle logprobs
         logprobs: list[dict[str, Any] | list[dict[str, Any]]] | None = None
         if choice.get("logprobs", None) and choice["logprobs"].get("content", None) is not None:
-            logprobs_list: list[dict[str, Any] | list[dict[str, Any]]] = []
-            for logprob in choice["logprobs"]["content"]:
-                if logprob.get("top_logprobs", None):
-                    curr_logprob_infos: list[dict[str, Any]] = []
-                    for top_logprob in logprob.get("top_logprobs", []):
-                        curr_logprob_infos.append(
-                            {
-                                "token": top_logprob.get("token", ""),
-                                "logprob": top_logprob.get("logprob", 0),
-                                "bytes": top_logprob.get("bytes", 0),
-                            }
-                        )
-                    logprobs_list.append(curr_logprob_infos)
-                else:
-                    logprobs_list.append(
-                        {
-                            "token": logprob.get("token", ""),
-                            "logprob": logprob.get("logprob", 0),
-                            "bytes": logprob.get("bytes", 0),
-                        }
-                    )
-            logprobs = logprobs_list
+            logprobs = process_logprobs(choice["logprobs"]["content"])
 
         # Handle extras that OpenAI or Azure OpenAI return
         if choice.get("content_filter_results", None):
@@ -195,6 +217,107 @@ def openai_chat_completion(
     )
 
 
+async def openai_chat_completion_stream(
+    request: ChatCompletionRequest,
+    client: Callable[..., Any],
+) -> AsyncGenerator[ChatCompletionChunk, None]:
+    validate(request)
+    kwargs = format_kwargs(request)
+
+    start_time = time.time()
+    stream = await client(**kwargs)
+
+    async for chunk in stream:
+        errors = ""
+        # This kind of a hack. To make this processing generic for clients that do not return the correct
+        # data structure, we convert the chunk to a dict
+        if not isinstance(chunk, dict):
+            chunk = chunk.to_dict()
+
+        choices: list[ChatCompletionChoiceStream] = []
+        for choice in chunk["choices"]:
+            content = choice.get("delta", {}).get("content", "")
+            if not content:
+                content = ""
+
+            role = Role.ASSISTANT
+            if choice.get("delta", {}).get("role", None):
+                role = Role(choice["delta"]["role"])
+
+            # Handle tool calls
+            tool_calls: list[PartialToolCall] | None = None
+            if choice["delta"].get("tool_calls", None):
+                parsed_tool_calls: list[PartialToolCall] = []
+                for tool_call in choice["delta"]["tool_calls"]:
+                    tool_name = tool_call.get("function", {}).get("name", None)
+                    if not tool_name:
+                        tool_name = ""
+                    tool_args = tool_call.get("function", {}).get("arguments", "")
+                    if not tool_args:
+                        tool_args = ""
+
+                    tool_id = tool_call.get("id", None)
+                    parsed_tool_calls.append(
+                        PartialToolCall(
+                            id=tool_id,
+                            function=PartialFunction(
+                                name=tool_name,
+                                arguments=tool_args,
+                            ),
+                        )
+                    )
+                tool_calls = parsed_tool_calls
+
+            refusal = None
+            if choice["delta"].get("refusal", None):
+                refusal = choice["delta"]["refusal"]
+
+            delta = ChatCompletionDelta(
+                content=content,
+                role=role,
+                tool_calls=tool_calls,
+                refusal=refusal,
+            )
+
+            index = choice.get("index", 0)
+            finish_reason = choice.get("finish_reason", None)
+
+            # Handle logprobs
+            logprobs: list[dict[str, Any] | list[dict[str, Any]]] | None = None
+            if choice.get("logprobs", None) and choice["logprobs"].get("content", None) is not None:
+                logprobs = process_logprobs(choice["logprobs"]["content"])
+
+            choice_obj = ChatCompletionChoiceStream(
+                delta=delta,
+                finish_reason=finish_reason,
+                logprobs=logprobs,
+                index=index,
+            )
+            choices.append(choice_obj)
+
+        current_time = time.time()
+        response_duration = round(current_time - start_time, 4)
+
+        if "usage" in chunk and chunk["usage"] is not None:
+            completion_tokens = chunk["usage"].get("completion_tokens", None)
+            prompt_tokens = chunk["usage"].get("prompt_tokens", None)
+            system_fingerprint = chunk.get("system_fingerprint", None)
+        else:
+            completion_tokens = None
+            prompt_tokens = None
+            system_fingerprint = None
+
+        chunk_obj = ChatCompletionChunk(
+            choices=choices,
+            errors=errors.strip(),
+            completion_tokens=completion_tokens,
+            prompt_tokens=prompt_tokens,
+            response_duration=response_duration,
+            system_fingerprint=system_fingerprint,
+        )
+        yield chunk_obj
+
+
 def create_client_callable(client_class: type[OpenAI | AzureOpenAI], **client_args: Any) -> Callable[..., Any]:
     """Creates a callable that instantiates and uses an OpenAI client.
 
@@ -215,6 +338,20 @@ def create_client_callable(client_class: type[OpenAI | AzureOpenAI], **client_ar
     return client_callable
 
 
+def create_client_callable_stream(
+    client_class: type[AsyncOpenAI | AsyncAzureOpenAI], **client_args: Any
+) -> Callable[..., Any]:
+    filtered_args = {k: v for k, v in client_args.items() if v is not None}
+
+    def client_callable(**kwargs: Any) -> Coroutine[Any, Any, Any]:
+        client = client_class(**filtered_args)
+        kwargs["stream_options"] = {"include_usage": True}
+        stream = client.chat.completions.create(**kwargs)
+        return stream
+
+    return client_callable
+
+
 class InvalidOAIAPITypeError(Exception):
     """Raised when an invalid OAIAPIType string is provided."""
 
@@ -227,6 +364,7 @@ def openai_client(
     azure_endpoint: str | None = None,
     timeout: float | None = None,
     max_retries: int | None = None,
+    async_client: bool = False,
 ) -> Callable[..., Any]:
     """Create an OpenAI or Azure OpenAI client instance based on the specified API type and other provided parameters.
 
@@ -247,11 +385,11 @@ def openai_client(
         max_retries (int, optional): Certain errors are automatically retried 2 times by default,
             with a short exponential backoff. Connection errors (for example, due to a network connectivity problem),
             408 Request Timeout, 409 Conflict, 429 Rate Limit, and >=500 Internal errors are all retried by default.
+        async_client (bool, optional): Whether to return an async client. Defaults to False.
 
     Returns:
         Callable[..., Any]: A callable that creates a client and returns completion results
 
-
     Raises:
         InvalidOAIAPITypeError: If an invalid API type string is provided.
         NotImplementedError: If the specified API type is recognized but not yet supported (e.g., 'azure_openai').
@@ -260,17 +398,21 @@ def openai_client(
         raise InvalidOAIAPITypeError(f"Invalid OAIAPIType: {api_type}. Must be 'openai' or 'azure_openai'.")
 
     if api_type == "openai":
-        return create_client_callable(
-            OpenAI,
+        client_class = AsyncOpenAI if async_client else OpenAI
+        callable_creator = create_client_callable_stream if async_client else create_client_callable
+        return callable_creator(
+            client_class,  # type: ignore
             api_key=api_key,
             organization=organization,
             timeout=timeout,
             max_retries=max_retries,
         )
     elif api_type == "azure_openai":
+        azure_client_class = AsyncAzureOpenAI if async_client else AzureOpenAI
+        callable_creator = create_client_callable_stream if async_client else create_client_callable
         if api_key:
-            return create_client_callable(
-                AzureOpenAI,
+            return callable_creator(
+                azure_client_class,  # type: ignore
                 api_version=aoai_api_version,
                 azure_endpoint=azure_endpoint,
                 api_key=api_key,
@@ -282,8 +424,8 @@ def openai_client(
             ad_token_provider = get_bearer_token_provider(
                 azure_credential, "https://cognitiveservices.azure.com/.default"
             )
-            return create_client_callable(
-                AzureOpenAI,
+            return callable_creator(
+                azure_client_class,  # type: ignore
                 api_version=aoai_api_version,
                 azure_endpoint=azure_endpoint,
                 azure_ad_token_provider=ad_token_provider,

not_again_ai/llm/chat_completion/types.py

@@ -52,12 +52,23 @@ class Function(BaseModel):
     arguments: dict[str, Any]
 
 
+class PartialFunction(BaseModel):
+    name: str
+    arguments: str | dict[str, Any]
+
+
 class ToolCall(BaseModel):
     id: str
     function: Function
     type: Literal["function"] = "function"
 
 
+class PartialToolCall(BaseModel):
+    id: str | None
+    function: PartialFunction
+    type: Literal["function"] = "function"
+
+
 class DeveloperMessage(BaseMessage[str]):
     role: Literal[Role.DEVELOPER] = Role.DEVELOPER
 
@@ -87,6 +98,7 @@ MessageT = AssistantMessage | DeveloperMessage | SystemMessage | ToolMessage | U
 class ChatCompletionRequest(BaseModel):
     messages: list[MessageT]
     model: str
+    stream: bool = Field(default=False)
 
     max_completion_tokens: int | None = Field(default=None)
     context_window: int | None = Field(default=None)
@@ -126,7 +138,9 @@ class ChatCompletionRequest(BaseModel):
 
 class ChatCompletionChoice(BaseModel):
     message: AssistantMessage
-    finish_reason: Literal["stop", "length", "tool_calls", "content_filter"]
+    finish_reason: Literal[
+        "stop", "length", "tool_calls", "content_filter", "end_turn", "max_tokens", "stop_sequence", "tool_use"
+    ]
 
     json_message: dict[str, Any] | None = Field(default=None)
     logprobs: list[dict[str, Any] | list[dict[str, Any]]] | None = Field(default=None)
@@ -143,8 +157,42 @@ class ChatCompletionResponse(BaseModel):
     prompt_tokens: int
     completion_detailed_tokens: dict[str, int] | None = Field(default=None)
     prompt_detailed_tokens: dict[str, int] | None = Field(default=None)
+    cache_read_input_tokens: int | None = Field(default=None)
+    cache_creation_input_tokens: int | None = Field(default=None)
     response_duration: float
 
     system_fingerprint: str | None = Field(default=None)
 
     extras: Any | None = Field(default=None)
+
+
+class ChatCompletionDelta(BaseModel):
+    content: str
+    role: Role = Field(default=Role.ASSISTANT)
+
+    tool_calls: list[PartialToolCall] | None = Field(default=None)
+
+    refusal: str | None = Field(default=None)
+
+
+class ChatCompletionChoiceStream(BaseModel):
+    delta: ChatCompletionDelta
+    index: int
+    finish_reason: Literal["stop", "length", "tool_calls", "content_filter"] | None
+
+    logprobs: list[dict[str, Any] | list[dict[str, Any]]] | None = Field(default=None)
+
+    extras: Any | None = Field(default=None)
+
+
+class ChatCompletionChunk(BaseModel):
+    choices: list[ChatCompletionChoiceStream]
+
+    errors: str = Field(default="")
+
+    completion_tokens: int | None = Field(default=None)
+    prompt_tokens: int | None = Field(default=None)
+    response_duration: float | None = Field(default=None)
+
+    system_fingerprint: str | None = Field(default=None)
+    extras: Any | None = Field(default=None)

not_again_ai/llm/prompting/compile_prompt.py

@@ -5,7 +5,7 @@ import mimetypes
 from pathlib import Path
 from typing import Any
 
-from liquid import Template
+from liquid import render
 from openai.lib._pydantic import to_strict_json_schema
 from pydantic import BaseModel
 
@@ -15,7 +15,7 @@ from not_again_ai.llm.chat_completion.types import MessageT
 def _apply_templates(value: Any, variables: dict[str, str]) -> Any:
     """Recursively applies Liquid templating to all string fields within the given value."""
     if isinstance(value, str):
-        return Template(value).render(**variables)
+        return render(value, **variables)
     elif isinstance(value, list):
         return [_apply_templates(item, variables) for item in value]
     elif isinstance(value, dict):
@@ -31,7 +31,7 @@ def _apply_templates(value: Any, variables: dict[str, str]) -> Any:
 
 def compile_messages(messages: Sequence[MessageT], variables: dict[str, str]) -> Sequence[MessageT]:
     """Compiles messages using Liquid templating and the provided variables.
-    Calls Template(content_part).render(**variables) on each text content part.
+    Calls render(content_part, **variables) on each text content part.
 
     Args:
         messages: List of MessageT where content can contain Liquid templates.

{not_again_ai-0.16.1.dist-info → not_again_ai-0.18.0.dist-info}/METADATA

@@ -1,11 +1,13 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: not-again-ai
-Version: 0.16.1
+Version: 0.18.0
 Summary: Designed to once and for all collect all the little things that come up over and over again in AI projects and put them in one place.
-License: MIT
-Author: DaveCoDev
-Author-email: dave.co.dev@gmail.com
-Requires-Python: >=3.11, <3.13
+Project-URL: Homepage, https://github.com/DaveCoDev/not-again-ai
+Project-URL: Documentation, https://davecodev.github.io/not-again-ai/
+Project-URL: Repository, https://github.com/DaveCoDev/not-again-ai
+Author-email: DaveCoDev <dave.co.dev@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -16,52 +18,55 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: loguru>=0.7
+Requires-Dist: pydantic>=2.10
 Provides-Extra: data
+Requires-Dist: playwright<2.0,>=1.51; extra == 'data'
+Requires-Dist: pytest-playwright<1.0,>=0.7; extra == 'data'
 Provides-Extra: llm
+Requires-Dist: anthropic<1.0,>=0.49; extra == 'llm'
+Requires-Dist: azure-identity<2.0,>=1.21; extra == 'llm'
+Requires-Dist: ollama<1.0,>=0.4; extra == 'llm'
+Requires-Dist: openai<2.0,>=1.68; extra == 'llm'
+Requires-Dist: python-liquid<3.0,>=2.0; extra == 'llm'
+Requires-Dist: tiktoken<1.0,>=0.9; extra == 'llm'
 Provides-Extra: statistics
+Requires-Dist: numpy<3.0,>=2.2; extra == 'statistics'
+Requires-Dist: scikit-learn<2.0,>=1.6; extra == 'statistics'
+Requires-Dist: scipy>=1.15; extra == 'statistics'
 Provides-Extra: viz
-Requires-Dist: azure-identity (>=1.19) ; extra == "llm"
-Requires-Dist: loguru (>=0.7)
-Requires-Dist: numpy (>=2.2) ; extra == "statistics"
-Requires-Dist: numpy (>=2.2) ; extra == "viz"
-Requires-Dist: ollama (>=0.4) ; extra == "llm"
-Requires-Dist: openai (>=1) ; extra == "llm"
-Requires-Dist: pandas (>=2.2) ; extra == "viz"
-Requires-Dist: playwright (>=1.50) ; extra == "data"
-Requires-Dist: pydantic (>=2.10)
-Requires-Dist: pytest-playwright (>=0.7) ; extra == "data"
-Requires-Dist: python-liquid (>=1.12) ; extra == "llm"
-Requires-Dist: scikit-learn (>=1.6) ; extra == "statistics"
-Requires-Dist: scipy (>=1.15) ; extra == "statistics"
-Requires-Dist: seaborn (>=0.13) ; extra == "viz"
-Requires-Dist: tiktoken (>=0.8) ; extra == "llm"
-Project-URL: Documentation, https://davecodev.github.io/not-again-ai/
-Project-URL: Homepage, https://github.com/DaveCoDev/not-again-ai
-Project-URL: Repository, https://github.com/DaveCoDev/not-again-ai
+Requires-Dist: numpy<3.0,>=2.2; extra == 'viz'
+Requires-Dist: pandas<3.0,>=2.2; extra == 'viz'
+Requires-Dist: seaborn<1.0,>=0.13; extra == 'viz'
 Description-Content-Type: text/markdown
 
 # not-again-ai
 
 [![GitHub Actions][github-actions-badge]](https://github.com/johnthagen/python-blueprint/actions)
-[![Packaged with Poetry][poetry-badge]](https://python-poetry.org/)
+[![uv][uv-badge]](https://github.com/astral-sh/uv)
 [![Nox][nox-badge]](https://github.com/wntrblm/nox)
 [![Ruff][ruff-badge]](https://github.com/astral-sh/ruff)
 [![Type checked with mypy][mypy-badge]](https://mypy-lang.org/)
 
 [github-actions-badge]: https://github.com/johnthagen/python-blueprint/workflows/python/badge.svg
-[poetry-badge]: https://img.shields.io/badge/packaging-poetry-cyan.svg
+[uv-badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json
 [nox-badge]: https://img.shields.io/badge/%F0%9F%A6%8A-Nox-D85E00.svg
 [black-badge]: https://img.shields.io/badge/code%20style-black-000000.svg
 [ruff-badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
 [mypy-badge]: https://www.mypy-lang.org/static/mypy_badge.svg
 
-**not-again-ai** is a collection of various building blocks that come up over and over again when developing AI products. The key goals of this package are to have simple, yet flexible interfaces and to minimize dependencies. It is encouraged to also **a)** use this as a template for your own Python package. **b)** instead of installing the package, copy and paste functions into your own projects. We make this easier by limiting the number of dependencies and use an MIT license.
+**not-again-ai** is a collection of various building blocks that come up over and over again when developing AI products. 
+The key goals of this package are to have simple, yet flexible interfaces and to minimize dependencies. 
+It is encouraged to also **a)** use this as a template for your own Python package. 
+**b)** instead of installing the package, copy and paste functions into your own projects. 
+We make this easier by limiting the number of dependencies and use an MIT license.
 
 **Documentation** available within individual **[notebooks](notebooks)**, docstrings within the source, or auto-generated at [DaveCoDev.github.io/not-again-ai/](https://DaveCoDev.github.io/not-again-ai/).
 
 # Installation
 
-Requires: Python 3.11, or 3.12
+Requires: Python 3.11, or 3.12 which can be installed with [uv](https://docs.astral.sh/uv/getting-started/installation/) by running the command `uv python install 3.12`
 
 Install the entire package from [PyPI](https://pypi.org/project/not-again-ai/) with: 
 
@@ -111,52 +116,35 @@ The package is split into subpackages, so you can install only the parts you nee
 
 # Development Information
 
-The following information is relevant if you would like to contribute or use this package as a template for yourself. 
+This package uses [uv](https://docs.astral.sh/uv/) to manage dependencies and
+isolated [Python virtual environments](https://docs.python.org/3/library/venv.html).
 
-This package uses [Poetry](https://python-poetry.org/) to manage dependencies and
-isolated [Python virtual environments](https://docs.python.org/3/library/venv.html). To proceed, be sure to first install [pipx](https://github.com/pypa/pipx#install-pipx)
-and then [install Poetry](https://python-poetry.org/docs/#installing-with-pipx).
+To proceed,
+[install uv globally](https://docs.astral.sh/uv/getting-started/installation/)
+onto your system.
 
-Install Poetry Plugin: Export
+To install a specific version of Python:
 
-```bash
-$ pipx inject poetry poetry-plugin-export
-```
-
-(Optional) configure Poetry to use an in-project virtual environment.
-```bash
-$ poetry config virtualenvs.in-project true
+```shell
+uv python install 3.12
 ```
 
 ## Dependencies
 
 Dependencies are defined in [`pyproject.toml`](./pyproject.toml) and specific versions are locked
-into [`poetry.lock`](./poetry.lock). This allows for exact reproducible environments across
+into [`uv.lock`](./uv.lock). This allows for exact reproducible environments across
 all machines that use the project, both during development and in production.
 
-To upgrade all dependencies to the versions defined in [`pyproject.toml`](./pyproject.toml):
-
-```bash
-$ poetry update
-```
-
-To install all dependencies (with all extra dependencies) into an isolated virtual environment:
-
-```bash
-$ poetry sync --all-extras
-```
+To install all dependencies into an isolated virtual environment:
 
-To [activate](https://python-poetry.org/docs/basic-usage#activating-the-virtual-environment) the
-virtual environment that is automatically created by Poetry:
-
-```bash
-$ poetry shell
+```shell
+uv sync --all-extras
 ```
 
-To deactivate the environment:
+To upgrade all dependencies to their latest versions:
 
-```bash
-(.venv) $ exit
+```shell
+uv lock --upgrade
 ```
 
 ## Packaging
@@ -164,48 +152,40 @@ To deactivate the environment:
 This project is designed as a Python package, meaning that it can be bundled up and redistributed
 as a single compressed file.
 
-Packaging is configured by:
-
-- [`pyproject.toml`](./pyproject.toml)
+Packaging is configured by the [`pyproject.toml`](./pyproject.toml).
 
 To package the project as both a 
 [source distribution](https://packaging.python.org/en/latest/flow/#the-source-distribution-sdist) and
 a [wheel](https://packaging.python.org/en/latest/specifications/binary-distribution-format/):
 
 ```bash
-$ poetry build
+$ uv build
 ```
 
 This will generate `dist/not-again-ai-<version>.tar.gz` and `dist/not_again_ai-<version>-py3-none-any.whl`.
 
-Read more about the [advantages of wheels](https://pythonwheels.com/) to understand why generating
-wheel distributions are important.
 
 ## Publish Distributions to PyPI
 
 Source and wheel redistributable packages can
-be [published to PyPI](https://python-poetry.org/docs/cli#publish) or installed
+be [published to PyPI](https://docs.astral.sh/uv/guides/package/) or installed
 directly from the filesystem using `pip`.
 
-```bash
-$ poetry publish
+```shell
+uv publish
 ```
 
 # Enforcing Code Quality
 
-Automated code quality checks are performed using 
-[Nox](https://nox.thea.codes/en/stable/) and
-[`nox-poetry`](https://nox-poetry.readthedocs.io/en/stable/). Nox will automatically create virtual
-environments and run commands based on [`noxfile.py`](./noxfile.py) for unit testing, PEP 8 style
-guide checking, type checking and documentation generation.
-
-> Note: `nox` is installed into the virtual environment automatically by the `poetry sync`
-> command above. Run `poetry shell` to activate the virtual environment.
+Automated code quality checks are performed using [Nox](https://nox.thea.codes/en/stable/). Nox
+will automatically create virtual environments and run commands based on
+[`noxfile.py`](./noxfile.py) for unit testing, PEP 8 style guide checking, type checking and
+documentation generation.
 
 To run all default sessions:
 
-```bash
-(.venv) $ nox
+```shell
+uv run nox
 ```
 
 ## Unit Testing
@@ -237,7 +217,7 @@ pytest and code coverage are configured in [`pyproject.toml`](./pyproject.toml).
 To run selected tests:
 
 ```bash
-(.venv) $ nox -s test -- -k "test_web"
+(.venv) $ uv run nox -s test -- -k "test_web"
 ```
 
 ## Code Style Checking
@@ -251,13 +231,13 @@ code. PEP 8 code compliance is verified using [Ruff][Ruff]. Ruff is configured i
 To lint code, run:
 
 ```bash
-(.venv) $ nox -s lint
+(.venv) $ uv run nox -s lint
 ```
 
 To automatically fix fixable lint errors, run:
 
 ```bash
-(.venv) $ nox -s lint_fix
+(.venv) $ uv run nox -s lint_fix
 ```
 
 ## Automated Code Formatting
@@ -267,13 +247,13 @@ To automatically fix fixable lint errors, run:
 To automatically format code, run:
 
 ```bash
-(.venv) $ nox -s fmt
+(.venv) $ uv run nox -s fmt
 ```
 
 To verify code has been formatted, such as in a CI job:
 
 ```bash
-(.venv) $ nox -s fmt_check
+(.venv) $ uv run nox -s fmt_check
 ```
 
 ## Type Checking
@@ -293,11 +273,9 @@ def factorial(n: int) -> int:
 mypy is configured in [`pyproject.toml`](./pyproject.toml). To type check code, run:
 
 ```bash
-(.venv) $ nox -s type_check
+(.venv) $ uv run nox -s type_check
 ```
 
-See also [awesome-python-typing](https://github.com/typeddjango/awesome-python-typing).
-
 ### Distributing Type Annotations
 
 [PEP 561](https://www.python.org/dev/peps/pep-0561/) defines how a Python package should
@@ -313,7 +291,7 @@ installed package to indicate that inline type annotations should be checked.
 Check for typos using [typos](https://github.com/crate-ci/typos)
 
 ```bash
-(.venv) $ nox -s typos
+(.venv) $ uv run nox -s typos
 ```
 
 ## Continuous Integration
@@ -331,81 +309,5 @@ Install the [Ruff extension](https://marketplace.visualstudio.com/items?itemName
 
 Default settings are configured in [`.vscode/settings.json`](./.vscode/settings.json) which will enable Ruff with consistent settings.
 
-# Generating Documentation
-
-## Generating a User Guide
-
-[Material for MkDocs](https://squidfunk.github.io/mkdocs-material/) is a powerful static site
-generator that combines easy-to-write Markdown, with a number of Markdown extensions that increase
-the power of Markdown. This makes it a great fit for user guides and other technical documentation.
-
-The example MkDocs project included in this project is configured to allow the built documentation
-to be hosted at any URL or viewed offline from the file system.
-
-To build the user guide, run,
-
-```bash
-(.venv) $ nox -s docs
-```
-
-and open `docs/user_guide/site/index.html` using a web browser.
-
-To build the user guide, additionally validating external URLs, run:
-
-```bash
-(.venv) $ nox -s docs_check_urls
-```
-
-To build the user guide in a format suitable for viewing directly from the file system, run:
-
-```bash
-(.venv) $ nox -s docs_offline
-```
-
-To build and serve the user guide with automatic rebuilding as you change the contents,
-run:
-
-```bash
-(.venv) $ nox -s docs_serve
-``` 
-
-and open <http://127.0.0.1:8000> in a browser.
-
-Each time the `main` Git branch is updated, the 
-[`.github/workflows/pages.yml`](.github/workflows/pages.yml) GitHub Action will
-automatically build the user guide and publish it to [GitHub Pages](https://pages.github.com/).
-This is configured in the `docs_github_pages` Nox session.
-
-## Generating API Documentation
-
-This project uses [mkdocstrings](https://github.com/mkdocstrings/mkdocstrings) plugin for
-MkDocs, which renders
-[Google-style docstrings](https://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html)
-into an MkDocs project. Google-style docstrings provide a good mix of easy-to-read docstrings in
-code as well as nicely-rendered output.
-
-```python
-"""Computes the factorial through a recursive algorithm.
-
-Args:
-    n: A positive input value.
-
-Raises:
-    InvalidFactorialError: If n is less than 0.
-
-Returns:
-    Computed factorial.
-"""
-```
-
-## Misc
-
-If you get a `Failed to create the collection: Prompt dismissed..` error when running `poetry update` on Ubuntu, try setting the following environment variable:
-
-    ```bash
-    export PYTHON_KEYRING_BACKEND=keyring.backends.null.Keyring
-    ```
-
 # Attributions
 [python-blueprint](https://github.com/johnthagen/python-blueprint) for the Python package skeleton.
-

{not_again_ai-0.16.1.dist-info → not_again_ai-0.18.0.dist-info}/RECORD

@@ -1,29 +1,30 @@
 not_again_ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+not_again_ai/py.typed,sha256=UaCuPFa3H8UAakbt-5G8SPacldTOGvJv18pPjUJ5gDY,93
 not_again_ai/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 not_again_ai/base/file_system.py,sha256=KNQmacO4Q__CQuq2oPzWrg3rQO48n3evglc9bNiP7KM,949
 not_again_ai/base/parallel.py,sha256=fcYhKBYBWvob84iKp3O93wvFFdXeidljZsShgBLTNGA,3448
 not_again_ai/data/__init__.py,sha256=1jF6mwvtB2PT7IEc3xpbRtZm3g3Lyf8zUqH4AEE4qlQ,244
 not_again_ai/data/web.py,sha256=wjx9cc33jcoJBGonYCIpwygPBFOwz7F-dx_ominmbnI,1838
-not_again_ai/llm/__init__.py,sha256=_wNUL6FDaT369Z8W48FsaC_NkcOZ-ib2MMUvnaLOS-0,451
-not_again_ai/llm/chat_completion/__init__.py,sha256=a2qmmmrXjMKyHGZDjt_xdqYbSrEOBea_VvZArzMboe0,200
-not_again_ai/llm/chat_completion/interface.py,sha256=FCyE-1gLdhwuS0Lv8iTbZvraa4iZjnKB8qb31WF53uk,1204
+not_again_ai/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+not_again_ai/llm/chat_completion/__init__.py,sha256=HozawvdRkTFgq8XR16GJUHN1ukEa4Ya68wVPVrl-afs,250
+not_again_ai/llm/chat_completion/interface.py,sha256=xRZXQ75dxrkt5WNtOTtrAa2Oy4ZB-PG2WihW9FBmW-s,2525
+not_again_ai/llm/chat_completion/types.py,sha256=Z_pQjVK_7rEvAE2fj5srKxHPFJBLPV8e0iCFibnzT7M,5596
 not_again_ai/llm/chat_completion/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-not_again_ai/llm/chat_completion/providers/ollama_api.py,sha256=plW_nN452rd85NqxPKjSLlHn-Z9s4rQXynsxatX8xkA,8295
-not_again_ai/llm/chat_completion/providers/openai_api.py,sha256=e8rOVeDq-gB8AQ5fycUjIgNSrgjYU3s8LdGUuYeahM8,12557
-not_again_ai/llm/chat_completion/types.py,sha256=RnOy_CphOaFU1f0ag-zTJPgAPXOnTH4WHD1P688GQKM,4222
+not_again_ai/llm/chat_completion/providers/anthropic_api.py,sha256=_-NPc5pfhsRwwy-GYc1vAiyc0agmGLyo5_7-mcPEnBU,6189
+not_again_ai/llm/chat_completion/providers/ollama_api.py,sha256=Puo2eE2VynvZOoqrUlNYtPgRGCRMVa8syc3TfBxS1hs,10661
+not_again_ai/llm/chat_completion/providers/openai_api.py,sha256=1wdeV50KYX_KIf2uofsICKYoHVSvj4kTRpS1Vuw3NSQ,17887
 not_again_ai/llm/embedding/__init__.py,sha256=wscUfROukvw0M0vYccfaVTdXV0P-eICAT5mqM0LaHHc,182
 not_again_ai/llm/embedding/interface.py,sha256=Hj3UiktXEeCUeMwpIDtRkwBfKgaJSnJvclLNyjwUAtE,1144
+not_again_ai/llm/embedding/types.py,sha256=J4FFLx35Aow2kOaafDReeY9cUNqhWMjaAk5gXkX7SVk,506
 not_again_ai/llm/embedding/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 not_again_ai/llm/embedding/providers/ollama_api.py,sha256=m-OCis9WAUT2baGsGVPzejlive40eSNyO6tHmPh6joM,3201
 not_again_ai/llm/embedding/providers/openai_api.py,sha256=JFFqbq0O5snIEnr9VESdp5xehikQBPbs7nwyE6acFsY,5441
-not_again_ai/llm/embedding/types.py,sha256=J4FFLx35Aow2kOaafDReeY9cUNqhWMjaAk5gXkX7SVk,506
 not_again_ai/llm/prompting/__init__.py,sha256=7YnHro1yH01FLGnao27WyqQDFjNYf9npE5UxoR9YrUU,84
-not_again_ai/llm/prompting/compile_prompt.py,sha256=lnbTOoTc7PumyP_GhfHaLZHp3UUpSB7VAeWOilS1wpI,4703
+not_again_ai/llm/prompting/compile_prompt.py,sha256=uBn655yTiQ325z1CUgnkU2k7ICIvaYRJOm50B7w2lSs,4683
 not_again_ai/llm/prompting/interface.py,sha256=SMKYabmu3zTWbEDukU6aLU_JQ88apeBWWOF_qZ0s3ww,1783
+not_again_ai/llm/prompting/types.py,sha256=xz70dnawL9rji7Zr1_mOekY-uUlvKJJf7k9nXJsOXc4,1219
 not_again_ai/llm/prompting/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 not_again_ai/llm/prompting/providers/openai_tiktoken.py,sha256=8YrEiK3ZHyKVGiVsJ_Rd6eVdISIvcub7ooj-HB7Prsc,4536
-not_again_ai/llm/prompting/types.py,sha256=xz70dnawL9rji7Zr1_mOekY-uUlvKJJf7k9nXJsOXc4,1219
-not_again_ai/py.typed,sha256=UaCuPFa3H8UAakbt-5G8SPacldTOGvJv18pPjUJ5gDY,93
 not_again_ai/statistics/__init__.py,sha256=gA8r9JQFbFSN0ykrHy4G1IQgcky4f2eM5Oo24oVI5Ik,466
 not_again_ai/statistics/dependence.py,sha256=4xaniMkLlTjdXcNVXdwepEAiZ-WaaGYfR9haJC1lU2Q,4434
 not_again_ai/viz/__init__.py,sha256=MeaWae_QRbDEHJ4MWYoY1-Ad6S0FhSDaRhQncS2cpSc,447
@@ -32,7 +33,7 @@ not_again_ai/viz/distributions.py,sha256=OyWwJaNI6lMRm_iSrhq-CORLNvXfeuLSgDtVo3u
 not_again_ai/viz/scatterplot.py,sha256=5CUOWeknbBOaZPeX9oPin5sBkRKEwk8qeFH45R-9LlY,2292
 not_again_ai/viz/time_series.py,sha256=pOGZqXp_2nd6nKo-PUQNCtmMh__69jxQ6bQibTGLwZA,5212
 not_again_ai/viz/utils.py,sha256=hN7gwxtBt3U6jQni2K8j5m5pCXpaJDoNzGhBBikEU28,238
-not_again_ai-0.16.1.dist-info/LICENSE,sha256=btjOgNGpp-ux5xOo1Gx1MddxeWtT9sof3s3Nui29QfA,1071
-not_again_ai-0.16.1.dist-info/METADATA,sha256=6j9ar7vYJ77yTkg1NDzw9PbYK0-ioo5NGI2joAPHpp0,15035
-not_again_ai-0.16.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-not_again_ai-0.16.1.dist-info/RECORD,,
+not_again_ai-0.18.0.dist-info/METADATA,sha256=n41TWZaLvs_XPNbSEQojju9DI4nPhkjE055xX7ZJGjQ,12021
+not_again_ai-0.18.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+not_again_ai-0.18.0.dist-info/licenses/LICENSE,sha256=btjOgNGpp-ux5xOo1Gx1MddxeWtT9sof3s3Nui29QfA,1071
+not_again_ai-0.18.0.dist-info/RECORD,,

{not_again_ai-0.16.1.dist-info → not_again_ai-0.18.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any