not-again-ai 0.17.0__py3-none-any.whl → 0.19.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/interface.py

@@ -1,6 +1,8 @@
 from collections.abc import AsyncGenerator, Callable
 from typing import Any
 
+from not_again_ai.llm.chat_completion.providers.anthropic_api import anthropic_chat_completion
+from not_again_ai.llm.chat_completion.providers.gemini_api import gemini_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
@@ -15,6 +17,8 @@ def chat_completion(
     - `openai` - OpenAI
     - `azure_openai` - Azure OpenAI
     - `ollama` - Ollama
+    - `anthropic` - Anthropic
+    - `gemini` - Gemini
 
     Args:
         request: Request parameter object
@@ -28,6 +32,10 @@ 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)
+    elif provider == "gemini":
+        return gemini_chat_completion(request, client)
     else:
         raise ValueError(f"Provider {provider} not supported")
 
@@ -40,7 +48,6 @@ async def chat_completion_stream(
     """Stream a chat completion response from the given provider. Currently supported providers:
     - `openai` - OpenAI
     - `azure_openai` - Azure OpenAI
-    - `ollama` - Ollama
 
     Args:
         request: Request parameter object

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"] = not kwargs["parallel_tool_calls"]  # type: ignore
+        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"] = not kwargs["parallel_tool_calls"]  # type: ignore
+        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/gemini_api.py

@@ -0,0 +1,237 @@
+import base64
+from collections.abc import Callable
+import os
+import time
+from typing import Any
+
+from google import genai
+from google.genai import types
+from google.genai.types import FunctionCall, FunctionCallingConfigMode, GenerateContentResponse
+
+from not_again_ai.llm.chat_completion.types import (
+    AssistantMessage,
+    ChatCompletionChoice,
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+    Function,
+    ImageContent,
+    Role,
+    TextContent,
+    ToolCall,
+)
+
+# This should be all of the options we want to support in types.GenerateContentConfig, that are not handled otherwise
+GEMINI_PARAMETER_MAP = {
+    "max_completion_tokens": "max_output_tokens",
+    "temperature": "temperature",
+    "top_p": "top_p",
+    "top_k": "top_k",
+}
+
+GEMINI_FINISH_REASON_MAP = {
+    "STOP": "stop",
+    "MAX_TOKENS": "max_tokens",
+    "SAFETY": "safety",
+    "RECITATION": "recitation",
+    "LANGUAGE": "language",
+    "OTHER": "other",
+    "BLOCKLIST": "blocklist",
+    "PROHIBITED_CONTENT": "prohibited_content",
+    "SPII": "spii",
+    "MALFORMED_FUNCTION_CALL": "malformed_function_call",
+    "IMAGE_SAFETY": "image_safety",
+}
+
+
+def gemini_chat_completion(request: ChatCompletionRequest, client: Callable[..., Any]) -> ChatCompletionResponse:
+    """Experimental Gemini chat completion function."""
+    # Handle messages
+    # Any system messages need to be removed from messages and concatenated into a single string (in order)
+    system = ""
+    contents = []
+    for message in request.messages:
+        if message.role == "system":
+            # Handle both string content and structured content
+            if isinstance(message.content, str):
+                system += message.content + "\n"
+            else:
+                # If it's a list of content parts, extract text content
+                for part in message.content:
+                    if hasattr(part, "text"):
+                        system += part.text + "\n"
+        elif message.role == "tool":
+            tool_name = message.name if message.name is not None else ""
+            function_response_part = types.Part.from_function_response(
+                name=tool_name,
+                response={"result": message.content},
+            )
+            contents.append(
+                types.Content(
+                    role="user",
+                    parts=[function_response_part],
+                )
+            )
+        elif message.role == "assistant":
+            if message.content and isinstance(message.content, str):
+                contents.append(types.Content(role="model", parts=[types.Part(text=message.content)]))
+            function_parts = []
+            if isinstance(message, AssistantMessage) and message.tool_calls:
+                for tool_call in message.tool_calls:
+                    function_call_part = types.Part(
+                        function_call=FunctionCall(
+                            id=tool_call.id,
+                            name=tool_call.function.name,
+                            args=tool_call.function.arguments,
+                        )
+                    )
+                    function_parts.append(function_call_part)
+            if function_parts:
+                contents.append(types.Content(role="model", parts=function_parts))
+        elif message.role == "user":
+            if isinstance(message.content, str):
+                contents.append(types.Content(role="user", parts=[types.Part(text=message.content)]))
+            elif isinstance(message.content, list):
+                parts = []
+                for part in message.content:
+                    if isinstance(part, TextContent):
+                        parts.append(types.Part(text=part.text))
+                    elif isinstance(part, ImageContent):
+                        # Extract MIME type and data from data URI
+                        uri_parts = part.image_url.url.split(",", 1)
+                        if len(uri_parts) == 2:
+                            mime_type = uri_parts[0].split(":")[1].split(";")[0]
+                            base64_data = uri_parts[1]
+                            image_data = base64.b64decode(base64_data)
+                            parts.append(types.Part.from_bytes(mime_type=mime_type, data=image_data))
+                contents.append(types.Content(role="user", parts=parts))
+
+    kwargs: dict[str, Any] = {}
+    kwargs["contents"] = contents
+    kwargs["model"] = request.model
+    config: dict[str, Any] = {}
+    config["system_instruction"] = system.rstrip()
+    config["automatic_function_calling"] = {"disable": True}
+
+    # Handle the possible tool choice options
+    if request.tool_choice:
+        tool_choice = request.tool_choice
+        if tool_choice == "auto":
+            config["tool_config"] = types.FunctionCallingConfig(mode=FunctionCallingConfigMode.AUTO)
+        elif tool_choice == "any":
+            config["tool_config"] = types.FunctionCallingConfig(mode=FunctionCallingConfigMode.ANY)
+        elif tool_choice == "none":
+            config["tool_config"] = types.FunctionCallingConfig(mode=FunctionCallingConfigMode.NONE)
+        elif isinstance(tool_choice, list):
+            config["tool_config"] = types.FunctionCallingConfig(
+                mode=FunctionCallingConfigMode.ANY, allowed_function_names=tool_choice
+            )
+        elif tool_choice not in (None, "auto", "any", "none"):
+            config["tool_config"] = types.FunctionCallingConfig(
+                mode=FunctionCallingConfigMode.ANY, allowed_function_names=[tool_choice]
+            )
+
+    # Handle tools
+    tools = []
+    for tool in request.tools or []:
+        tools.append(types.Tool(function_declarations=[tool]))  # type: ignore
+    if tools:
+        config["tools"] = tools
+
+    # Everything else defined in GEMINI_PARAMETER_MAP goes into kwargs["config"]
+    request_kwargs = request.model_dump(mode="json", exclude_none=True)
+    for key, value in GEMINI_PARAMETER_MAP.items():
+        if value is not None and key in request_kwargs:
+            config[value] = request_kwargs.pop(key)
+
+    kwargs["config"] = types.GenerateContentConfig(**config)
+
+    start_time = time.time()
+    response: GenerateContentResponse = client(**kwargs)
+    end_time = time.time()
+    response_duration = round(end_time - start_time, 4)
+
+    finish_reason = "other"
+    if response.candidates and response.candidates[0].finish_reason:
+        finish_reason_str = str(response.candidates[0].finish_reason)
+        finish_reason = GEMINI_FINISH_REASON_MAP.get(finish_reason_str, "other")
+
+    tool_calls: list[ToolCall] = []
+    tool_call_objs = response.function_calls
+    if tool_call_objs:
+        for tool_call_obj in tool_call_objs:
+            tool_call_id = tool_call_obj.id if tool_call_obj.id else ""
+            tool_calls.append(
+                ToolCall(
+                    id=tool_call_id,
+                    function=Function(
+                        name=tool_call_obj.name if tool_call_obj.name is not None else "",
+                        arguments=tool_call_obj.args if tool_call_obj.args is not None else {},
+                    ),
+                )
+            )
+
+    assistant_message = ""
+    if (
+        response.candidates
+        and response.candidates[0].content
+        and response.candidates[0].content.parts
+        and response.candidates[0].content.parts[0].text
+    ):
+        assistant_message = response.candidates[0].content.parts[0].text
+
+    choice = ChatCompletionChoice(
+        message=AssistantMessage(
+            role=Role.ASSISTANT,
+            content=assistant_message,
+            tool_calls=tool_calls,
+        ),
+        finish_reason=finish_reason,
+    )
+
+    completion_tokens = 0
+    # Add null check for usage_metadata
+    if response.usage_metadata is not None:
+        if response.usage_metadata.thoughts_token_count:
+            completion_tokens = response.usage_metadata.thoughts_token_count
+        if response.usage_metadata.candidates_token_count:
+            completion_tokens += response.usage_metadata.candidates_token_count
+
+    # Set safe default for prompt_tokens
+    prompt_tokens = 0
+    if response.usage_metadata is not None and response.usage_metadata.prompt_token_count:
+        prompt_tokens = response.usage_metadata.prompt_token_count
+
+    chat_completion_response = ChatCompletionResponse(
+        choices=[choice],
+        completion_tokens=completion_tokens,
+        prompt_tokens=prompt_tokens,
+        response_duration=response_duration,
+    )
+    return chat_completion_response
+
+
+def create_client_callable(client_class: type[genai.Client], **client_args: Any) -> Callable[..., Any]:
+    """Creates a callable that instantiates and uses a Google genai client.
+
+    Args:
+        client_class: The Google genai 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.models.generate_content(**kwargs)
+        return completion
+
+    return client_callable
+
+
+def gemini_client(api_key: str | None = None) -> Callable[..., Any]:
+    if not api_key:
+        api_key = os.environ.get("GEMINI_API_KEY")
+    client_callable = create_client_callable(genai.Client, api_key=api_key)
+    return client_callable

not_again_ai/llm/chat_completion/types.py

@@ -138,8 +138,7 @@ class ChatCompletionRequest(BaseModel):
 
 class ChatCompletionChoice(BaseModel):
     message: AssistantMessage
-    finish_reason: Literal["stop", "length", "tool_calls", "content_filter"]
-
+    finish_reason: str
     json_message: dict[str, Any] | None = Field(default=None)
     logprobs: list[dict[str, Any] | list[dict[str, Any]]] | None = Field(default=None)
 
@@ -155,6 +154,8 @@ 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)

not_again_ai/llm/image_gen/__init__.py

@@ -0,0 +1,4 @@
+from not_again_ai.llm.image_gen.interface import create_image
+from not_again_ai.llm.image_gen.types import ImageGenRequest
+
+__all__ = ["ImageGenRequest", "create_image"]

not_again_ai/llm/image_gen/interface.py

@@ -0,0 +1,24 @@
+from collections.abc import Callable
+from typing import Any
+
+from not_again_ai.llm.image_gen.providers.openai_api import openai_create_image
+from not_again_ai.llm.image_gen.types import ImageGenRequest, ImageGenResponse
+
+
+def create_image(request: ImageGenRequest, provider: str, client: Callable[..., Any]) -> ImageGenResponse:
+    """Get a image response from the given provider. Currently supported providers:
+    - `openai` - OpenAI
+    - `azure_openai` - Azure OpenAI
+
+    Args:
+        request: Request parameter object
+        provider: The supported provider name
+        client: Client information, see the provider's implementation for what can be provided
+
+    Returns:
+        ImageGenResponse: The image generation response.
+    """
+    if provider == "openai" or provider == "azure_openai":
+        return openai_create_image(request, client)
+    else:
+        raise ValueError(f"Provider {provider} not supported")

not_again_ai/llm/image_gen/providers/openai_api.py

@@ -0,0 +1,144 @@
+import base64
+from collections.abc import Callable
+import time
+from typing import Any, Literal
+
+from azure.identity import DefaultAzureCredential, get_bearer_token_provider
+from openai import AzureOpenAI, OpenAI
+from openai.types.images_response import ImagesResponse
+
+from not_again_ai.llm.image_gen.types import ImageGenRequest, ImageGenResponse
+
+
+def openai_create_image(request: ImageGenRequest, client: Callable[..., Any]) -> ImageGenResponse:
+    """Create an image using OpenAI API.
+
+    Args:
+        request (ImageGenRequest): The request object containing parameters for image generation.
+        client (Callable[..., Any]): The OpenAI client callable.
+
+    Returns:
+        ImageGenResponse: The response object containing the generated image and metadata.
+    """
+    kwargs = request.model_dump(exclude_none=True)
+    if kwargs.get("images"):
+        kwargs["image"] = kwargs.pop("images", None)
+
+    start_time = time.time()
+    response: ImagesResponse = client(**kwargs)
+    end_time = time.time()
+    response_duration = round(end_time - start_time, 4)
+
+    images: list[bytes] = []
+    if response.data:
+        for data in response.data:
+            images.append(base64.b64decode(data.b64_json or ""))
+
+    input_tokens = response.usage.input_tokens if response.usage else -1
+    output_tokens = response.usage.output_tokens if response.usage else -1
+    input_tokens_details = response.usage.input_tokens_details.to_dict() if response.usage else {}
+    image_gen_response = ImageGenResponse(
+        images=images,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        input_tokens_details=input_tokens_details,
+        response_duration=response_duration,
+    )
+    return image_gen_response
+
+
+def create_client_callable(client_class: type[OpenAI | AzureOpenAI], **client_args: Any) -> Callable[..., Any]:
+    """
+    Creates the correct callable depending on the parameters provided.
+    """
+    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)
+        # If mask or image is not none, use client.images.edit instead of client.images.generate
+        if kwargs.get("mask") or kwargs.get("image"):
+            completion = client.images.edit(**kwargs)
+        else:
+            completion = client.images.generate(**kwargs)
+        return completion
+
+    return client_callable
+
+
+class InvalidOAIAPITypeError(Exception):
+    """Raised when an invalid OAIAPIType string is provided."""
+
+
+def openai_client(
+    api_type: Literal["openai", "azure_openai"] = "openai",
+    api_key: str | None = None,
+    organization: str | None = None,
+    aoai_api_version: str = "2024-06-01",
+    azure_endpoint: str | None = None,
+    timeout: float | None = None,
+    max_retries: int | None = None,
+) -> Callable[..., Any]:
+    """Create an OpenAI or Azure OpenAI client instance based on the specified API type and other provided parameters.
+
+    It is preferred to use RBAC authentication for Azure OpenAI. You must be signed in with the Azure CLI and have correct role assigned.
+    See https://techcommunity.microsoft.com/t5/microsoft-developer-community/using-keyless-authentication-with-azure-openai/ba-p/4111521
+
+    Args:
+        api_type (str, optional): Type of the API to be used. Accepted values are 'openai' or 'azure_openai'.
+            Defaults to 'openai'.
+        api_key (str, optional): The API key to authenticate the client. If not provided,
+            OpenAI automatically uses `OPENAI_API_KEY` from the environment.
+            If provided for Azure OpenAI, it will be used for authentication instead of the Azure AD token provider.
+        organization (str, optional): The ID of the organization. If not provided,
+            OpenAI automotically uses `OPENAI_ORG_ID` from the environment.
+        aoai_api_version (str, optional): Only applicable if using Azure OpenAI https://learn.microsoft.com/azure/ai-services/openai/reference#rest-api-versioning
+        azure_endpoint (str, optional): The endpoint to use for Azure OpenAI.
+        timeout (float, optional): By default requests time out after 10 minutes.
+        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.
+
+    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').
+    """
+    if api_type not in ["openai", "azure_openai"]:
+        raise InvalidOAIAPITypeError(f"Invalid OAIAPIType: {api_type}. Must be 'openai' or 'azure_openai'.")
+
+    if api_type == "openai":
+        return create_client_callable(
+            OpenAI,
+            api_key=api_key,
+            organization=organization,
+            timeout=timeout,
+            max_retries=max_retries,
+        )
+    elif api_type == "azure_openai":
+        if api_key:
+            return create_client_callable(
+                AzureOpenAI,
+                api_version=aoai_api_version,
+                azure_endpoint=azure_endpoint,
+                api_key=api_key,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        else:
+            azure_credential = DefaultAzureCredential()
+            ad_token_provider = get_bearer_token_provider(
+                azure_credential, "https://cognitiveservices.azure.com/.default"
+            )
+            return create_client_callable(
+                AzureOpenAI,
+                api_version=aoai_api_version,
+                azure_endpoint=azure_endpoint,
+                azure_ad_token_provider=ad_token_provider,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+    else:
+        raise NotImplementedError(f"API type '{api_type}' is invalid.")

not_again_ai/llm/image_gen/types.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ImageGenRequest(BaseModel):
+    prompt: str
+    model: str
+    images: list[Path] | None = Field(default=None)
+    mask: Path | None = Field(default=None)
+    n: int = Field(default=1)
+    quality: str | None = Field(default=None)
+    size: str | None = Field(default=None)
+    background: str | None = Field(default=None)
+    moderation: str | None = Field(default=None)
+
+
+class ImageGenResponse(BaseModel):
+    images: list[bytes]
+    input_tokens: int
+    output_tokens: int
+    response_duration: float
+    input_tokens_details: dict[str, 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.17.0.dist-info → not_again_ai-0.19.0.dist-info}/METADATA

@@ -1,11 +1,13 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: not-again-ai
-Version: 0.17.0
+Version: 0.19.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,56 @@ 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<1.0,>=0.7
+Requires-Dist: pydantic<3.0,>=2.11
 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.50; extra == 'llm'
+Requires-Dist: azure-identity<2.0,>=1.21; extra == 'llm'
+Requires-Dist: google-genai<2.0,>1.12; extra == 'llm'
+Requires-Dist: ollama<1.0,>=0.4; extra == 'llm'
+Requires-Dist: openai<2.0,>=1.76; 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/).
+**Documentation** available within individual **[notebooks](notebooks)** or docstrings within the source code.
 
 # 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 +117,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 --all-groups
 ```
 
-To deactivate the environment:
+To upgrade all dependencies to their latest versions:
 
-```bash
-(.venv) $ exit
+```shell
+uv lock --upgrade
 ```
 
 ## Packaging
@@ -164,48 +153,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 +218,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 +232,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 +248,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 +274,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 +292,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 +310,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.17.0.dist-info → not_again_ai-0.19.0.dist-info}/RECORD

@@ -1,29 +1,36 @@
 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/__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=u9DLDOv3Vp2IfvmgsRM2va6EK9NKdmkk0tXO2P9nLuY,2308
+not_again_ai/llm/chat_completion/interface.py,sha256=OU6ghG7RlveahkHZWdRHFg0uzbSrSh2Dz7u5-4rrypA,2700
+not_again_ai/llm/chat_completion/types.py,sha256=0pBo1Fgm__JU3NyMShGouAIolcANPpTfXn8WJHODlQw,5472
 not_again_ai/llm/chat_completion/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+not_again_ai/llm/chat_completion/providers/anthropic_api.py,sha256=Eix3_GgQvDyPr6pKfSDrfqRg_bTb0pqMI8fdQrx9e84,6211
+not_again_ai/llm/chat_completion/providers/gemini_api.py,sha256=ovyTssfN3achMr2Laa2Hu557CjYN6o7UkO5IGXg6lzk,9461
 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/chat_completion/types.py,sha256=yjSrcR9N5hrrMQAjzNvRIfQXQ-lVRgZfrIoKuhMbmjo,5399
 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/image_gen/__init__.py,sha256=v31PgYdTxMQRRxXPFl40BW5Y8RSHrZuwabuD-yC9gfI,170
+not_again_ai/llm/image_gen/interface.py,sha256=XGE0aDvQwe-aWRuGNLMECO6KnMiK8qLv2APvr0hZ0tY,930
+not_again_ai/llm/image_gen/types.py,sha256=Qhdov5azWwmmbqqE3Ln7t-Fb_Ipyp8r3z0_80omyASc,672
+not_again_ai/llm/image_gen/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+not_again_ai/llm/image_gen/providers/openai_api.py,sha256=3IEhdId1UU_imvDebytTt0dSCjEEyPHf2o4vVt6RqSE,6198
 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 +39,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.17.0.dist-info/LICENSE,sha256=btjOgNGpp-ux5xOo1Gx1MddxeWtT9sof3s3Nui29QfA,1071
-not_again_ai-0.17.0.dist-info/METADATA,sha256=rguTCxLjkxsY-JDXsCbZ2Jl9wwCUOsvCiQVWYC6BBxI,15035
-not_again_ai-0.17.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-not_again_ai-0.17.0.dist-info/RECORD,,
+not_again_ai-0.19.0.dist-info/METADATA,sha256=LeCIas912YMtvKEJcChoPqYrM3ay_EurUZehvlQ9t8o,12004
+not_again_ai-0.19.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+not_again_ai-0.19.0.dist-info/licenses/LICENSE,sha256=btjOgNGpp-ux5xOo1Gx1MddxeWtT9sof3s3Nui29QfA,1071
+not_again_ai-0.19.0.dist-info/RECORD,,

{not_again_ai-0.17.0.dist-info → not_again_ai-0.19.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