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

not_again_ai/llm/openai_api/prompts.py

@@ -1,191 +0,0 @@
-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
-
-
-def _validate_message_vision(message: dict[str, list[dict[str, Path | str]] | str]) -> bool:
-    """Validates that a message for a vision model is valid"""
-    valid_fields = ["role", "content", "name", "tool_call_id", "tool_calls"]
-    if not all(key in valid_fields for key in message):
-        raise ValueError(f"Message contains invalid fields: {message.keys()}")
-
-    valid_roles = ["system", "user", "assistant", "tool"]
-    if message["role"] not in valid_roles:
-        raise ValueError(f"Message contains invalid role: {message['role']}")
-
-    if not isinstance(message["content"], list) and not isinstance(message["content"], str):
-        raise ValueError(f"content must be a list of dictionaries or a string: {message['content']}")
-
-    if isinstance(message["content"], list):
-        for content_part in message["content"]:
-            if isinstance(content_part, dict):
-                if "image" not in content_part:
-                    raise ValueError(f"Dictionary content part must contain 'image' key: {content_part}")
-                if "detail" in content_part and content_part["detail"] not in ["low", "high"]:
-                    raise ValueError(f"Optional 'detail' key must be 'low' or 'high': {content_part['detail']}")
-            elif not isinstance(content_part, str):
-                raise ValueError(f"content_part must be a dictionary or a string: {content_part}")
-
-    return True
-
-
-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 chat_prompt(messages_unformatted: list[dict[str, Any]], variables: dict[str, str]) -> list[dict[str, Any]]:
-    """Formats a list of messages for OpenAI's chat completion API,
-    including special syntax for vision models, using Liquid templating.
-
-    Args:
-        messages_unformatted (list[dict[str, list[dict[str, Path | str]] | str]]):
-            A list of dictionaries where each dictionary represents a message.
-            `content` can be a Liquid template string or a list of dictionaries where each dictionary
-            represents a content part. Each content part can be a string or a dictionary with 'image' and 'detail' keys.
-            The 'image' key must be a Path or a string representing a URL. The 'detail' key is optional and must be 'low' or 'high'.
-        variables: A dictionary where each key-value pair represents a variable
-            name and its value for template rendering.
-
-    Returns:
-        A list which represents messages in the format that OpenAI expects for its chat completions API.
-        See here for details: https://platform.openai.com/docs/api-reference/chat/create
-
-    Example:
-        >>> # Assume cat_image and dog_image are Path objects to image files
-        >>> messages = [
-        ...     {"role": "system", "content": "You are a helpful assistant."},
-        ...     {
-        ...         "role": "user",
-        ...          "content": ["Describe the animal in the image in one word.", {"image": cat_image, "detail": "low"}],
-        ...     }
-        ...     {"role": "assistant", "content": "{{ answer }}"},
-        ...     {
-        ...         "role": "user",
-        ...         "content": ["What about this animal?", {"image": dog_image, "detail": "high"}],
-        ...     }
-        ... ]
-        >>> vars = {"answer": "Cat"}
-        >>> chat_prompt(messages, vars)
-        [
-            {"role": "system", "content": "You are a helpful assistant."},
-            {
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": "Describe the animal in the image in one word."},
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/jpeg;base64,<encoding>", "detail": "low"},
-                    },
-                ],
-            },
-            {"role": "assistant", "content": "Cat"},
-            {
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": "What about this animal?"},
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/jpeg;base64,<encoding>", "detail": "high"},
-                    },
-                ],
-            },
-        ]
-    """
-    messages_formatted = deepcopy(messages_unformatted)
-    for message in messages_formatted:
-        if not _validate_message_vision(message):
-            raise ValueError()
-
-        if isinstance(message["content"], list):
-            for i in range(len(message["content"])):
-                content_part = message["content"][i]
-                if isinstance(content_part, dict):
-                    image_path = content_part["image"]
-                    if isinstance(image_path, Path):
-                        temp_content_part: dict[str, Any] = {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": create_image_url(image_path),
-                            },
-                        }
-                        if "detail" in content_part:
-                            temp_content_part["image_url"]["detail"] = content_part["detail"]
-                    elif isinstance(image_path, str):
-                        # Assume its a valid URL
-                        pass
-                    else:
-                        raise ValueError(f"Image path must be a Path or str: {image_path}")
-                    message["content"][i] = temp_content_part
-                elif isinstance(content_part, str):
-                    message["content"][i] = {
-                        "type": "text",
-                        "text": Template(content_part).render(**variables),
-                    }
-        elif isinstance(message["content"], str):
-            message["content"] = Template(message["content"]).render(**variables)
-
-    return messages_formatted
-
-
-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/openai_api/tokens.py

@@ -1,184 +0,0 @@
-from collections.abc import Collection, Set
-from typing import Literal
-
-import tiktoken
-
-
-def load_tokenizer(model: str) -> tiktoken.Encoding:
-    """Load the tokenizer for the given model
-
-    Args:
-        model (str): The name of the language model to load the tokenizer for
-
-    Returns:
-        A tiktoken encoding object
-    """
-    try:
-        encoding = tiktoken.encoding_for_model(model)
-    except KeyError:
-        print("Warning: model not found. Using cl100k_base encoding.")
-        encoding = tiktoken.get_encoding("cl100k_base")
-    return encoding
-
-
-def truncate_str(
-    text: str,
-    max_len: int,
-    tokenizer: tiktoken.Encoding,
-    allowed_special: Literal["all"] | Set[str] = set(),
-    disallowed_special: Literal["all"] | Collection[str] = (),
-) -> str:
-    """Truncates a string to a maximum token length.
-
-    Special tokens are artificial tokens used to unlock capabilities from a model,
-    such as fill-in-the-middle. So we want to be careful about accidentally encoding special
-    tokens, since they can be used to trick a model into doing something we don't want it to do.
-
-    Hence, by default, encode will raise an error if it encounters text that corresponds
-    to a special token. This can be controlled on a per-token level using the `allowed_special`
-    and `disallowed_special` parameters. In particular:
-    - Setting `disallowed_special` to () will prevent this function from raising errors and
-        cause all text corresponding to special tokens to be encoded as natural text.
-    - Setting `allowed_special` to "all" will cause this function to treat all text
-        corresponding to special tokens to be encoded as special tokens.
-
-    Args:
-        text (str): The string to truncate.
-        max_len (int): The maximum number of tokens to keep.
-        tokenizer (tiktoken.Encoding): A tiktoken encoding object
-        allowed_special (str | set[str]):
-        disallowed_special (str | set[str]):
-
-    Returns:
-        str: The truncated string.
-    """
-    tokens = tokenizer.encode(text, allowed_special=allowed_special, disallowed_special=disallowed_special)
-    if len(tokens) > max_len:
-        tokens = tokens[:max_len]
-        # Decode the tokens back to a string
-        truncated_text = tokenizer.decode(tokens)
-        return truncated_text
-    else:
-        return text
-
-
-def num_tokens_in_string(
-    text: str,
-    tokenizer: tiktoken.Encoding,
-    allowed_special: Literal["all"] | Set[str] = set(),
-    disallowed_special: Literal["all"] | Collection[str] = (),
-) -> int:
-    """Return the number of tokens in a string.
-
-    Special tokens are artificial tokens used to unlock capabilities from a model,
-    such as fill-in-the-middle. So we want to be careful about accidentally encoding special
-    tokens, since they can be used to trick a model into doing something we don't want it to do.
-
-    Hence, by default, encode will raise an error if it encounters text that corresponds
-    to a special token. This can be controlled on a per-token level using the `allowed_special`
-    and `disallowed_special` parameters. In particular:
-    - Setting `disallowed_special` to () will prevent this function from raising errors and
-        cause all text corresponding to special tokens to be encoded as natural text.
-    - Setting `allowed_special` to "all" will cause this function to treat all text
-        corresponding to special tokens to be encoded as special tokens.
-
-    Args:
-        text (str): The string to count the tokens.
-        tokenizer (tiktoken.Encoding): A tiktoken encoding object
-        allowed_special (str | set[str]):
-        disallowed_special (str | set[str]):
-
-    Returns:
-        int: The number of tokens in the string.
-    """
-    return len(tokenizer.encode(text, allowed_special=allowed_special, disallowed_special=disallowed_special))
-
-
-def num_tokens_from_messages(
-    messages: list[dict[str, str]],
-    tokenizer: tiktoken.Encoding,
-    model: str = "gpt-3.5-turbo-0125",
-    allowed_special: Literal["all"] | Set[str] = set(),
-    disallowed_special: Literal["all"] | Collection[str] = (),
-) -> int:
-    """Return the number of tokens used by a list of messages.
-    NOTE: Does not support counting tokens used by function calling or prompts with images.
-    Reference: # https://github.com/openai/openai-cookbook/blob/main/examples/How_to_format_inputs_to_ChatGPT_models.ipynb
-    and https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
-
-    Special tokens are artificial tokens used to unlock capabilities from a model,
-    such as fill-in-the-middle. So we want to be careful about accidentally encoding special
-    tokens, since they can be used to trick a model into doing something we don't want it to do.
-
-    Hence, by default, encode will raise an error if it encounters text that corresponds
-    to a special token. This can be controlled on a per-token level using the `allowed_special`
-    and `disallowed_special` parameters. In particular:
-    - Setting `disallowed_special` to () will prevent this function from raising errors and
-        cause all text corresponding to special tokens to be encoded as natural text.
-    - Setting `allowed_special` to "all" will cause this function to treat all text
-        corresponding to special tokens to be encoded as special tokens.
-
-    Args:
-        messages (list[dict[str, str]]): A list of messages to count the tokens
-            should ideally be the result after calling llm.prompts.chat_prompt.
-        tokenizer (tiktoken.Encoding): A tiktoken encoding object
-        model (str): The model to use for tokenization. Defaults to "gpt-3.5-turbo-0125".
-            See https://platform.openai.com/docs/models for a list of OpenAI models.
-        allowed_special (str | set[str]):
-        disallowed_special (str | set[str]):
-
-    Returns:
-        int: The number of tokens used by the messages.
-    """
-    if 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-mini",
-        "gpt-4o-mini-2024-07-18",
-    }:
-        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 model == "gpt-3.5-turbo-0301":
-        tokens_per_message = 4
-        tokens_per_name = -1
-    # Approximate catch-all. Assumes future versions of 3.5 and 4 will have the same token counts as the 0613 versions.
-    elif "gpt-3.5-turbo" in model:
-        return num_tokens_from_messages(messages, tokenizer=tokenizer, model="gpt-3.5-turbo-0613")
-    elif "gpt-4o" in model:
-        return num_tokens_from_messages(messages, tokenizer=tokenizer, model="gpt-4o-2024-05-13")
-    elif "gpt-4" in model:
-        return num_tokens_from_messages(messages, tokenizer=tokenizer, model="gpt-4-0613")
-    else:
-        raise NotImplementedError(
-            f"""num_tokens_from_messages() is not implemented for model {model}.
-See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
-        )
-    num_tokens = 0
-    for message in messages:
-        num_tokens += tokens_per_message
-        for key, value in message.items():
-            num_tokens += len(
-                tokenizer.encode(
-                    value,
-                    allowed_special=allowed_special,
-                    disallowed_special=disallowed_special,
-                )
-            )
-            if key == "name":
-                num_tokens += tokens_per_name
-    num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
-    return num_tokens

not_again_ai/local_llm/__init__.py

@@ -1,27 +0,0 @@
-import importlib.util
-import os
-
-os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
-os.environ["TRANSFORMERS_NO_ADVISORY_WARNINGS"] = "1"
-
-if (
-    importlib.util.find_spec("liquid") is None
-    or importlib.util.find_spec("ollama") is None
-    or importlib.util.find_spec("openai") is None
-    or importlib.util.find_spec("tiktoken") is None
-    or importlib.util.find_spec("transformers") is None
-):
-    raise ImportError(
-        "not_again_ai.local_llm requires the 'llm' and 'local_llm' extra to be installed. "
-        "You can install it using 'pip install not_again_ai[llm,local_llm]'."
-    )
-else:
-    import liquid  # noqa: F401
-    import ollama  # noqa: F401
-    import openai  # noqa: F401
-    import tiktoken  # noqa: F401
-    import transformers  # noqa: F401
-    from transformers.utils import logging
-
-    logging.disable_progress_bar()
-    logging.set_verbosity_error()

not_again_ai/local_llm/chat_completion.py

@@ -1,105 +0,0 @@
-from typing import Any
-
-from azure.ai.inference import ChatCompletionsClient
-from ollama import Client
-from openai import AzureOpenAI, OpenAI
-
-from not_again_ai.llm.gh_models import chat_completion as chat_completion_gh_models
-from not_again_ai.llm.openai_api import chat_completion as chat_completion_openai
-from not_again_ai.local_llm.ollama import chat_completion as chat_completion_ollama
-
-
-def chat_completion(
-    messages: list[dict[str, Any]],
-    model: str,
-    client: OpenAI | AzureOpenAI | Client | ChatCompletionsClient,
-    tools: list[dict[str, Any]] | None = None,
-    max_tokens: int | None = None,
-    temperature: float = 0.7,
-    json_mode: bool = False,
-    seed: int | None = None,
-    **kwargs: Any,
-) -> dict[str, Any]:
-    """Creates a common wrapper around chat completion models from different providers.
-    Currently supports the OpenAI API and Ollama local models.
-    All input parameters are supported by all providers in similar ways and the output is standardized.
-
-    Args:
-        messages (list[dict[str, Any]]): A list of messages to send to the model.
-        model (str): The model name to use.
-        client (OpenAI | AzureOpenAI | Client | ChatCompletionsClient): The client object to use for chat completion.
-        tools (list[dict[str, Any]], optional):A list of tools the model may call.
-            Use this to provide a list of functions the model may generate JSON inputs for. Defaults to None.
-        max_tokens (int, optional): The maximum number of tokens to generate.
-        temperature (float, optional): The temperature of the model. Increasing the temperature will make the model answer more creatively.
-        json_mode (bool, optional): This will structure the response as a valid JSON object.
-        seed (int, optional): The seed to use for the model for reproducible outputs.
-
-    Returns:
-        dict[str, Any]: A dictionary with the following keys
-            message (str | dict): The content of the generated assistant message.
-                If json_mode is True, this will be a dictionary.
-            tool_names (list[str], optional): The names of the tools called by the model.
-                If the model does not support tools, a ResponseError is raised.
-            tool_args_list (list[dict], optional): The arguments of the tools called by the model.
-            prompt_tokens (int): The number of tokens in the messages sent to the model.
-            completion_tokens (int): The number of tokens used by the model to generate the completion.
-            response_duration (float): The time, in seconds, taken to generate the response by using the model.
-            extras (dict): This will contain any additional fields returned by corresponding provider.
-    """
-    # Determine which chat_completion function to call based on the client type
-    if isinstance(client, OpenAI | AzureOpenAI):
-        response = chat_completion_openai.chat_completion(
-            messages=messages,
-            model=model,
-            client=client,
-            tools=tools,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            json_mode=json_mode,
-            seed=seed,
-            **kwargs,
-        )
-    elif isinstance(client, Client):
-        response = chat_completion_ollama.chat_completion(
-            messages=messages,
-            model=model,
-            client=client,
-            tools=tools,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            json_mode=json_mode,
-            seed=seed,
-            **kwargs,
-        )
-    elif isinstance(client, ChatCompletionsClient):
-        response = chat_completion_gh_models.chat_completion(
-            messages=messages,  # type: ignore
-            model=model,
-            client=client,
-            tools=tools,  # type: ignore
-            max_tokens=max_tokens,
-            temperature=temperature,
-            json_mode=json_mode,
-            seed=seed,
-            **kwargs,
-        )
-    else:
-        raise ValueError("Invalid client type")
-
-    # Parse the responses to be consistent
-    response_data = {}
-    response_data["message"] = response.get("message")
-    if response.get("tool_names") and response.get("tool_args_list"):
-        response_data["tool_names"] = response.get("tool_names")
-        response_data["tool_args_list"] = response.get("tool_args_list")
-    response_data["completion_tokens"] = response.get("completion_tokens")
-    response_data["prompt_tokens"] = response.get("prompt_tokens")
-    response_data["response_duration"] = response.get("response_duration")
-
-    # Return any additional fields from the response in an "extras" dictionary
-    extras = {k: v for k, v in response.items() if k not in response_data}
-    if extras:
-        response_data["extras"] = extras
-
-    return response_data

not_again_ai/local_llm/huggingface/chat_completion.py

@@ -1,59 +0,0 @@
-from pathlib import Path
-from typing import Any
-
-from PIL import Image
-
-
-def chat_completion_image(
-    messages: list[dict[str, str]],
-    images: list[Path] | None,
-    model_processor: tuple[Any, Any],
-    max_tokens: int | None = None,
-    temperature: float = 0.7,
-) -> dict[str, Any]:
-    """A wrapper around ision language model inference for multimodal language models from huggingface.
-
-    Args:
-        messages (list[dict[str, str]]): A list of messages to send to the model.
-        images (list[Path] | None): A list of image paths to send to the model.
-        model_processor (tuple[Any, Any]): A tuple containing the model and processor objects.
-        max_tokens (int, optional): The maximum number of tokens to generate. Defaults to None.
-        temperature (float, optional): The temperature of the model. Increasing the temperature will make the model answer more creatively. Defaults to 0.7.
-
-    Returns:
-        dict[str, Any]: A dictionary with the following keys
-            message (str): The content of the generated assistant message.
-            completion_tokens (int): The number of tokens used by the model to generate the completion.
-    """
-
-    model, processor = model_processor
-
-    prompt = processor.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-
-    if images:
-        image_objects = [Image.open(image) for image in images]
-        inputs = processor(prompt, image_objects, return_tensors="pt").to("cuda:0")
-    else:
-        inputs = processor(prompt, return_tensors="pt").to("cuda:0")
-
-    generation_args = {
-        "max_new_tokens": max_tokens,
-        "temperature": temperature,
-        "num_beams": 1,
-        "do_sample": True,
-    }
-
-    generate_ids = model.generate(**inputs, eos_token_id=processor.tokenizer.eos_token_id, **generation_args)
-
-    # Remove input tokens
-    generate_ids = generate_ids[:, inputs["input_ids"].shape[1] :]
-
-    # Get the number of generated tokens
-    completion_tokens = generate_ids.shape[1]
-
-    response = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
-
-    response_data: dict[str, Any] = {}
-    response_data["message"] = response[0]
-    response_data["completion_tokens"] = completion_tokens
-    return response_data

not_again_ai/local_llm/huggingface/helpers.py

@@ -1,23 +0,0 @@
-from typing import Any
-
-from transformers import AutoModelForCausalLM, AutoProcessor
-
-
-def load_model(model_id: str, device_map: str = "cuda", trust_remote_code: bool = True) -> Any:
-    """Load a model from Hugging Face."""
-    model = AutoModelForCausalLM.from_pretrained(
-        model_id,
-        device_map=device_map,
-        trust_remote_code=trust_remote_code,
-        torch_dtype="auto",
-    )
-    return model
-
-
-def load_processor(model_id: str, trust_remote_code: bool = True) -> Any:
-    """Load a processor from Hugging Face. This is typically used for multimodal language models."""
-    processor = AutoProcessor.from_pretrained(
-        model_id,
-        trust_remote_code=trust_remote_code,
-    )
-    return processor