not-again-ai 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

not_again_ai/llm/chat_completion/types.py

@@ -0,0 +1,145 @@
+from enum import Enum
+from typing import Any, Generic, Literal, TypeVar
+
+from pydantic import BaseModel, Field
+
+
+class Role(str, Enum):
+    ASSISTANT = "assistant"
+    DEVELOPER = "developer"
+    SYSTEM = "system"
+    TOOL = "tool"
+    USER = "user"
+
+
+class ContentPartType(str, Enum):
+    TEXT = "text"
+    IMAGE = "image_url"
+
+
+class TextContent(BaseModel):
+    type: Literal[ContentPartType.TEXT] = ContentPartType.TEXT
+    text: str
+
+
+class ImageDetail(str, Enum):
+    AUTO = "auto"
+    LOW = "low"
+    HIGH = "high"
+
+
+class ImageUrl(BaseModel):
+    url: str
+    detail: ImageDetail = ImageDetail.AUTO
+
+
+class ImageContent(BaseModel):
+    type: Literal[ContentPartType.IMAGE] = ContentPartType.IMAGE
+    image_url: ImageUrl
+
+
+ContentT = TypeVar("ContentT", bound=str | list[TextContent | ImageContent])
+
+
+class BaseMessage(BaseModel, Generic[ContentT]):
+    content: ContentT
+    role: Role
+    name: str | None = None
+
+
+class Function(BaseModel):
+    name: str
+    arguments: dict[str, Any]
+
+
+class ToolCall(BaseModel):
+    id: str
+    function: Function
+    type: Literal["function"] = "function"
+
+
+class DeveloperMessage(BaseMessage[str]):
+    role: Literal[Role.DEVELOPER] = Role.DEVELOPER
+
+
+class SystemMessage(BaseMessage[str]):
+    role: Literal[Role.SYSTEM] = Role.SYSTEM
+
+
+class UserMessage(BaseMessage[str | list[TextContent | ImageContent]]):
+    role: Literal[Role.USER] = Role.USER
+
+
+class AssistantMessage(BaseMessage[str]):
+    role: Literal[Role.ASSISTANT] = Role.ASSISTANT
+    refusal: str | None = None
+    tool_calls: list[ToolCall] | None = None
+
+
+class ToolMessage(BaseMessage[str]):
+    # A tool message's name field will be interpreted as "tool_call_id"
+    role: Literal[Role.TOOL] = Role.TOOL
+
+
+MessageT = AssistantMessage | DeveloperMessage | SystemMessage | ToolMessage | UserMessage
+
+
+class ChatCompletionRequest(BaseModel):
+    messages: list[MessageT]
+    model: str
+
+    max_completion_tokens: int | None = Field(default=None)
+    context_window: int | None = Field(default=None)
+    logprobs: bool | None = Field(default=None)
+    n: int | None = Field(default=None)
+
+    tools: list[dict[str, Any]] | None = Field(default=None)
+    tool_choice: str | None = Field(default=None)
+    parallel_tool_calls: bool | None = Field(default=None)
+    json_mode: bool | None = Field(default=None)
+    structured_outputs: dict[str, Any] | None = Field(default=None)
+
+    temperature: float | None = Field(default=None)
+    reasoning_effort: Literal["low", "medium", "high"] | None = Field(default=None)
+    top_p: float | None = Field(default=None)
+    logit_bias: dict[str, float] | None = Field(default=None)
+    top_logprobs: int | None = Field(default=None)
+    frequency_penalty: float | None = Field(default=None)
+    presence_penalty: float | None = Field(default=None)
+    stop: str | list[str] | None = Field(default=None)
+
+    seed: int | None = Field(default=None)
+
+    mirostat: int | None = Field(default=None)
+    mirostat_eta: float | None = Field(default=None)
+    mirostat_tau: float | None = Field(default=None)
+    repeat_last_n: int | None = Field(default=None)
+    tfs_z: float | None = Field(default=None)
+    top_k: int | None = Field(default=None)
+    min_p: float | None = Field(default=None)
+
+
+class ChatCompletionChoice(BaseModel):
+    message: AssistantMessage
+    finish_reason: Literal["stop", "length", "tool_calls", "content_filter"]
+
+    json_message: dict[str, Any] | None = Field(default=None)
+    logprobs: list[dict[str, Any] | list[dict[str, Any]]] | None = Field(default=None)
+
+    extras: Any | None = Field(default=None)
+
+
+class ChatCompletionResponse(BaseModel):
+    choices: list[ChatCompletionChoice]
+
+    errors: str = Field(default="")
+
+    completion_tokens: int
+    prompt_tokens: int
+    completion_detailed_tokens: dict[str, int] | None = Field(default=None)
+    prompt_detailed_tokens: dict[str, int] | None = Field(default=None)
+    response_duration: float
+
+    system_fingerprint: str | None = Field(default=None)
+
+    extras: Any | None = Field(default=None)

not_again_ai/llm/prompting/__init__.py

@@ -0,0 +1,3 @@
+from not_again_ai.llm.prompting.interface import Tokenizer
+
+__all__ = ["Tokenizer"]

not_again_ai/llm/prompting/compile_messages.py

@@ -0,0 +1,98 @@
+import base64
+from copy import deepcopy
+import mimetypes
+from pathlib import Path
+from typing import Any
+
+from liquid import Template
+from openai.lib._pydantic import to_strict_json_schema
+from pydantic import BaseModel
+
+from not_again_ai.llm.chat_completion.types import MessageT, TextContent
+
+
+def compile_messages(messages: list[MessageT], variables: dict[str, str]) -> list[MessageT]:
+    """Compiles messages using Liquid templating and the provided variables.
+    Calls Template(content_part).render(**variables) on each text content part.
+
+    Args:
+        messages: List of MessageT where content can contain Liquid templates.
+        variables: The variables to inject into the templates.
+
+    Returns:
+        The same list of messages with the content parts injected with the variables.
+    """
+    messages_formatted = deepcopy(messages)
+    for message in messages_formatted:
+        if isinstance(message.content, str):
+            # For simple string content, apply template directly
+            message.content = Template(message.content).render(**variables)
+        elif isinstance(message.content, list):
+            # For UserMessage with content parts
+            for content_part in message.content:
+                if isinstance(content_part, TextContent):
+                    content_part.text = Template(content_part.text).render(**variables)
+                # ImageContent parts are left unchanged
+    return messages_formatted
+
+
+def encode_image(image_path: Path) -> str:
+    """Encodes an image file at the given Path to base64.
+
+    Args:
+        image_path: The path to the image file to encode.
+
+    Returns:
+        The base64 encoded image as a string.
+    """
+    with Path.open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode("utf-8")
+
+
+def create_image_url(image_path: Path) -> str:
+    """Creates a data URL for an image file at the given Path.
+
+    Args:
+        image_path: The path to the image file to encode.
+
+    Returns:
+        The data URL for the image.
+    """
+    image_data = encode_image(image_path)
+
+    valid_mime_types = ["image/jpeg", "image/png", "image/webp", "image/gif"]
+
+    # Get the MIME type from the image file extension
+    mime_type = mimetypes.guess_type(image_path)[0]
+
+    # Check if the MIME type is valid
+    # List of valid types is here: https://platform.openai.com/docs/guides/vision/what-type-of-files-can-i-upload
+    if mime_type not in valid_mime_types:
+        raise ValueError(f"Invalid MIME type for image: {mime_type}")
+
+    return f"data:{mime_type};base64,{image_data}"
+
+
+def pydantic_to_json_schema(
+    pydantic_model: type[BaseModel], schema_name: str, description: str | None = None
+) -> dict[str, Any]:
+    """Converts a Pydantic model to a JSON schema expected by Structured Outputs.
+    Must adhere to the supported schemas: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas
+
+    Args:
+        pydantic_model: The Pydantic model to convert.
+        schema_name: The name of the schema.
+        description: An optional description of the schema.
+
+    Returns:
+        A JSON schema dictionary representing the Pydantic model.
+    """
+    converted_pydantic = to_strict_json_schema(pydantic_model)
+    schema = {
+        "name": schema_name,
+        "strict": True,
+        "schema": converted_pydantic,
+    }
+    if description:
+        schema["description"] = description
+    return schema

not_again_ai/llm/prompting/interface.py

@@ -0,0 +1,46 @@
+from collections.abc import Collection, Set
+from typing import Literal
+
+from loguru import logger
+
+from not_again_ai.llm.chat_completion.types import MessageT
+from not_again_ai.llm.prompting.providers.openai_tiktoken import TokenizerOpenAI
+from not_again_ai.llm.prompting.types import BaseTokenizer
+
+
+class Tokenizer(BaseTokenizer):
+    def __init__(
+        self,
+        model: str,
+        provider: str,
+        allowed_special: Literal["all"] | Set[str] | None = None,
+        disallowed_special: Literal["all"] | Collection[str] | None = None,
+    ):
+        self.model = model
+        self.provider = provider
+        self.allowed_special = allowed_special
+        self.disallowed_special = disallowed_special
+
+        self.init_tokenizer(model, provider, allowed_special, disallowed_special)
+
+    def init_tokenizer(
+        self,
+        model: str,
+        provider: str,
+        allowed_special: Literal["all"] | Set[str] | None = None,
+        disallowed_special: Literal["all"] | Collection[str] | None = None,
+    ) -> None:
+        if provider == "openai" or provider == "azure_openai":
+            self.tokenizer = TokenizerOpenAI(model, provider, allowed_special, disallowed_special)
+        else:
+            logger.warning(f"Provider {provider} not supported. Initializing using tiktoken and gpt-4o.")
+            self.tokenizer = TokenizerOpenAI("gpt-4o", "openai", allowed_special, disallowed_special)
+
+    def truncate_str(self, text: str, max_len: int) -> str:
+        return self.tokenizer.truncate_str(text, max_len)
+
+    def num_tokens_in_str(self, text: str) -> int:
+        return self.tokenizer.num_tokens_in_str(text)
+
+    def num_tokens_in_messages(self, messages: list[MessageT]) -> int:
+        return self.tokenizer.num_tokens_in_messages(messages)

not_again_ai/llm/prompting/providers/openai_tiktoken.py

@@ -0,0 +1,122 @@
+from collections.abc import Collection, Set
+from typing import Literal
+
+from loguru import logger
+import tiktoken
+
+from not_again_ai.llm.chat_completion.types import MessageT
+from not_again_ai.llm.prompting.types import BaseTokenizer
+
+
+class TokenizerOpenAI(BaseTokenizer):
+    def __init__(
+        self,
+        model: str,
+        provider: str = "openai",
+        allowed_special: Literal["all"] | Set[str] | None = None,
+        disallowed_special: Literal["all"] | Collection[str] | None = None,
+    ):
+        self.model = model
+        self.provider = provider
+        self.allowed_special = allowed_special
+        self.disallowed_special = disallowed_special
+
+        self.init_tokenizer(model, provider, allowed_special, disallowed_special)
+
+    def init_tokenizer(
+        self,
+        model: str,
+        provider: str = "openai",
+        allowed_special: Literal["all"] | Set[str] | None = None,
+        disallowed_special: Literal["all"] | Collection[str] | None = None,
+    ) -> None:
+        try:
+            self.encoding = tiktoken.encoding_for_model(model)
+        except KeyError:
+            default_encoding = "o200k_base"
+            logger.warning(f"Model {model} not found. Using {default_encoding} encoding.")
+            self.encoding = tiktoken.get_encoding(default_encoding)
+
+        # Set defaults if not provided
+        if not allowed_special:
+            self.allowed_special = set()
+        if not disallowed_special:
+            self.disallowed_special = ()
+
+    def truncate_str(self, text: str, max_len: int) -> str:
+        tokens = self.encoding.encode(
+            text,
+            allowed_special=self.allowed_special if self.allowed_special is not None else set(),
+            disallowed_special=self.disallowed_special if self.disallowed_special is not None else (),
+        )
+        if len(tokens) > max_len:
+            tokens = tokens[:max_len]
+            truncated_text = self.encoding.decode(tokens)
+            return truncated_text
+        else:
+            return text
+
+    def num_tokens_in_str(self, text: str) -> int:
+        return len(
+            self.encoding.encode(
+                text,
+                allowed_special=self.allowed_special if self.allowed_special is not None else set(),
+                disallowed_special=self.disallowed_special if self.disallowed_special is not None else (),
+            )
+        )
+
+    def num_tokens_in_messages(self, messages: list[MessageT]) -> int:
+        if self.model in {
+            "gpt-3.5-turbo-0613",
+            "gpt-3.5-turbo-16k-0613",
+            "gpt-3.5-turbo-1106",
+            "gpt-3.5-turbo-0125",
+            "gpt-4-0314",
+            "gpt-4-32k-0314",
+            "gpt-4-0613",
+            "gpt-4-32k-0613",
+            "gpt-4-1106-preview",
+            "gpt-4-turbo-preview",
+            "gpt-4-0125-preview",
+            "gpt-4-turbo",
+            "gpt-4-turbo-2024-04-09",
+            "gpt-4o",
+            "gpt-4o-2024-05-13",
+            "gpt-4o-2024-08-06",
+            "gpt-4o-2024-11-20",
+            "gpt-4o-mini",
+            "gpt-4o-mini-2024-07-18",
+            "o1",
+            "o1-2024-12-17",
+            "o1-mini",
+            "o1-mini-2024-09-12",
+            "o1-preview",
+            "o1-preview-2024-09-12",
+        }:
+            tokens_per_message = 3  # every message follows <|start|>{role/name}\n{content}<|end|>\n
+            tokens_per_name = 1  # if there's a name, the role is omitted
+        elif self.model == "gpt-3.5-turbo-0301":
+            tokens_per_message = 4
+            tokens_per_name = -1
+        else:
+            logger.warning(f"Model {self.model} not supported. Assuming gpt-4o encoding.")
+            tokens_per_message = 3
+            tokens_per_name = 1
+
+        num_tokens = 0
+        for message in messages:
+            num_tokens += tokens_per_message
+            message_dict = message.model_dump(exclude_none=True)
+            for key, value in message_dict.items():
+                if isinstance(value, str):
+                    num_tokens += len(
+                        self.encoding.encode(
+                            value,
+                            allowed_special=self.allowed_special if self.allowed_special is not None else set(),
+                            disallowed_special=self.disallowed_special if self.disallowed_special is not None else (),
+                        )
+                    )
+                    if key == "name":
+                        num_tokens += tokens_per_name
+        num_tokens += 3
+        return num_tokens

not_again_ai/llm/prompting/types.py

@@ -0,0 +1,43 @@
+from abc import ABC, abstractmethod
+from collections.abc import Collection, Set
+from typing import Literal
+
+from not_again_ai.llm.chat_completion.types import MessageT
+
+
+class BaseTokenizer(ABC):
+    def __init__(
+        self,
+        model: str,
+        provider: str,
+        allowed_special: Literal["all"] | Set[str] | None = None,
+        disallowed_special: Literal["all"] | Collection[str] | None = None,
+    ):
+        self.model = model
+        self.provider = provider
+        self.allowed_special = allowed_special
+        self.disallowed_special = disallowed_special
+
+        self.init_tokenizer(model, provider, allowed_special, disallowed_special)
+
+    @abstractmethod
+    def init_tokenizer(
+        self,
+        model: str,
+        provider: str,
+        allowed_special: Literal["all"] | Set[str] | None = None,
+        disallowed_special: Literal["all"] | Collection[str] | None = None,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def truncate_str(self, text: str, max_len: int) -> str:
+        pass
+
+    @abstractmethod
+    def num_tokens_in_str(self, text: str) -> int:
+        pass
+
+    @abstractmethod
+    def num_tokens_in_messages(self, messages: list[MessageT]) -> int:
+        pass

{not_again_ai-0.14.0.dist-info → not_again_ai-0.15.0.dist-info}/METADATA

@@ -1,12 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: not-again-ai
-Version: 0.14.0
+Version: 0.15.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.
-Home-page: https://github.com/DaveCoDev/not-again-ai
 License: MIT
 Author: DaveCoDev
 Author-email: dave.co.dev@gmail.com
-Requires-Python: >=3.11,<4.0
+Requires-Python: >=3.11, <3.13
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -19,26 +18,25 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Typing :: Typed
 Provides-Extra: data
 Provides-Extra: llm
-Provides-Extra: local-llm
 Provides-Extra: statistics
 Provides-Extra: viz
-Requires-Dist: azure-ai-inference (==1.0.0b5) ; extra == "llm"
-Requires-Dist: azure-identity (>=1.19,<2.0) ; extra == "llm"
-Requires-Dist: jinja2 (>=3.1,<4.0) ; extra == "local-llm"
-Requires-Dist: loguru (>=0.7,<0.8)
-Requires-Dist: numpy (>=2.1,<3.0) ; extra == "statistics" or extra == "viz"
-Requires-Dist: ollama (>=0.3,<0.4) ; extra == "local-llm"
-Requires-Dist: openai (>=1.52,<2.0) ; extra == "llm"
-Requires-Dist: pandas (>=2.2,<3.0) ; extra == "viz"
-Requires-Dist: pydantic (>=2.9,<3.0)
-Requires-Dist: pytest-playwright (>=0.5,<0.6) ; extra == "data"
-Requires-Dist: python-liquid (>=1.12,<2.0) ; extra == "llm"
-Requires-Dist: scikit-learn (>=1.5,<2.0) ; extra == "statistics"
-Requires-Dist: scipy (>=1.14,<2.0) ; extra == "statistics"
-Requires-Dist: seaborn (>=0.13,<0.14) ; extra == "viz"
-Requires-Dist: tiktoken (>=0.8,<0.9) ; extra == "llm"
-Requires-Dist: transformers (>=4.45,<5.0) ; extra == "local-llm"
-Project-URL: Documentation, https://github.com/DaveCoDev/not-again-ai
+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.60) ; extra == "llm"
+Requires-Dist: pandas (>=2.2) ; extra == "viz"
+Requires-Dist: playwright (>=1.49) ; extra == "data"
+Requires-Dist: pydantic (>=2.10)
+Requires-Dist: pytest-playwright (>=0.6) ; 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
 Description-Content-Type: text/markdown
 
@@ -68,11 +66,9 @@ Requires: Python 3.11, or 3.12
 Install the entire package from [PyPI](https://pypi.org/project/not-again-ai/) with: 
 
 ```bash
-$ pip install not_again_ai[llm,local_llm,statistics,viz]
+$ pip install not_again_ai[data,llm,statistics,viz]
 ```
 
-Note that local LLM requires separate installations and will not work out of the box due to how hardware dependent it is. Be sure to check the [notebooks](notebooks/local_llm/) for more details.
-
 The package is split into subpackages, so you can install only the parts you need.
 
 ### Base
@@ -93,16 +89,7 @@ The package is split into subpackages, so you can install only the parts you nee
    1. Using AOAI requires using Entra ID authentication. See https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/managed-identity for how to set this up for your AOAI deployment.
       * Requires the correct role assigned to your user account and being signed into the Azure CLI.
    1. (Optional) Set the `AZURE_OPENAI_ENDPOINT` environment variable.
-1. Setup GitHub Models
-   1. Get a Personal Access Token from https://github.com/settings/tokens and set the `GITHUB_TOKEN` environment variable. The token does not need any permissions.
-   1. Check the [Github Marketplace](https://github.com/marketplace/models) to see which models are available.
-
-
-### Local LLM
- 1. `pip install not_again_ai[llm,local_llm]`
- 1. Some HuggingFace transformers tokenizers are gated behind access requests. If you wish to use these, you will need to request access from HuggingFace on the model card.
-    * Then set the `HF_TOKEN` environment variable to your HuggingFace API token which can be found here: https://huggingface.co/settings/tokens
- 1. If you wish to use Ollama:
+1. If you wish to use Ollama:
      1. Follow the instructions at https://github.com/ollama/ollama to install Ollama for your system. 
      1. (Optional) [Add Ollama as a startup service (recommended)](https://github.com/ollama/ollama/blob/main/docs/linux.md#adding-ollama-as-a-startup-service-recommended)
      1. (Optional) To make the Ollama service accessible on your local network from a Linux server, add the following to the `/etc/systemd/system/ollama.service` file which will make Ollama available at `http://<local_address>:11434`:
@@ -112,7 +99,6 @@ The package is split into subpackages, so you can install only the parts you nee
          Environment="OLLAMA_HOST=0.0.0.0"
          ```
      1. It is recommended to always have the latest version of Ollama. To update Ollama check the [docs](https://github.com/ollama/ollama/blob/main/docs/). The command for Linux is: `curl -fsSL https://ollama.com/install.sh | sh`
- 1. HuggingFace transformers and other requirements are hardware dependent so for providers other than Ollama, this only installs some generic dependencies. Check the [notebooks](notebooks/local_llm/) for more details on what is available and how to install it.
 
 
 ### Statistics
@@ -156,10 +142,8 @@ $ poetry update
 
 To install all dependencies (with all extra dependencies) into an isolated virtual environment:
 
-> Append `--sync` to uninstall dependencies that are no longer in use from the virtual environment.
-
 ```bash
-$ poetry install --all-extras
+$ poetry sync --all-extras
 ```
 
 To [activate](https://python-poetry.org/docs/basic-usage#activating-the-virtual-environment) the
@@ -215,7 +199,7 @@ Automated code quality checks are performed using
 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 install`
+> Note: `nox` is installed into the virtual environment automatically by the `poetry sync`
 > command above. Run `poetry shell` to activate the virtual environment.
 
 To run all default sessions:

not_again_ai-0.15.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+not_again_ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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/chat_completion/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+not_again_ai/llm/chat_completion/providers/ollama_api.py,sha256=iBTMyF8edo8uxxrorNPtShzmCXG7m0RlEBunWLSO4Mo,7999
+not_again_ai/llm/chat_completion/providers/openai_api.py,sha256=S7TZhDIQ_xpp3JakRVcd3Gpw2UjeHCETdA9MfRKUjCU,12294
+not_again_ai/llm/chat_completion/types.py,sha256=q8APUWWzwCKL0Rs_zEFfph9uBcwh5nAT0f0rp4crvk0,4039
+not_again_ai/llm/prompting/__init__.py,sha256=7YnHro1yH01FLGnao27WyqQDFjNYf9npE5UxoR9YrUU,84
+not_again_ai/llm/prompting/compile_messages.py,sha256=HmVCQ-0iVg8vFWZyppxUf9m_ae5c8rK1Zx8ySPD1Bg8,3452
+not_again_ai/llm/prompting/interface.py,sha256=SMKYabmu3zTWbEDukU6aLU_JQ88apeBWWOF_qZ0s3ww,1783
+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
+not_again_ai/viz/barplots.py,sha256=rr_2phZgDaqcF5Ve7mBZrVvNXVzEt84RQPIyyeJxsMo,3384
+not_again_ai/viz/distributions.py,sha256=OyWwJaNI6lMRm_iSrhq-CORLNvXfeuLSgDtVo3umnzU,4354
+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.15.0.dist-info/LICENSE,sha256=btjOgNGpp-ux5xOo1Gx1MddxeWtT9sof3s3Nui29QfA,1071
+not_again_ai-0.15.0.dist-info/METADATA,sha256=_vGJUluFVmoYQrNwLGMh5NWtH6aiJ5BG8G8hlZ5TRpE,15038
+not_again_ai-0.15.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+not_again_ai-0.15.0.dist-info/RECORD,,

{not_again_ai-0.14.0.dist-info → not_again_ai-0.15.0.dist-info}/WHEEL

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

not_again_ai/llm/gh_models/azure_ai_client.py

@@ -1,20 +0,0 @@
-import os
-
-from azure.ai.inference import ChatCompletionsClient
-from azure.core.credentials import AzureKeyCredential
-
-
-def azure_ai_client(
-    token: str | None = None,
-    endpoint: str = "https://models.inference.ai.azure.com",
-) -> ChatCompletionsClient:
-    if not token:
-        token = os.getenv("GITHUB_TOKEN")
-        if not token:
-            raise ValueError("Token must be provided or GITHUB_TOKEN environment variable must be set")
-
-    client = ChatCompletionsClient(
-        endpoint=endpoint,
-        credential=AzureKeyCredential(token),
-    )
-    return client