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

not_again_ai/local_llm/ollama/chat_completion.py

@@ -1,111 +0,0 @@
-import contextlib
-import json
-import re
-import time
-from typing import Any
-
-from ollama import Client, ResponseError
-
-from not_again_ai.local_llm.ollama.tokens import load_tokenizer, num_tokens_from_messages, num_tokens_in_string
-
-
-def chat_completion(
-    messages: list[dict[str, Any]],
-    model: str,
-    client: Client,
-    tools: list[dict[str, Any]] | None = None,
-    max_tokens: int | None = None,
-    context_window: int | None = None,
-    temperature: float = 0.8,
-    json_mode: bool = False,
-    seed: int | None = None,
-    **kwargs: Any,
-) -> dict[str, Any]:
-    """Gets a Ollama chat completion response, see https://github.com/ollama/ollama/blob/main/docs/api.md#generate-a-chat-completion
-    For a full list of valid parameters: https://github.com/ollama/ollama/blob/main/docs/modelfile.md#valid-parameters-and-values
-
-    Args:
-        messages (list[dict[str, Any]]): A list of messages to send to the model.
-        model (str): The model to use.
-        client (Client): The Ollama client.
-        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. Ollama calls this `num_predict`.
-        context_window (int, optional): The number of tokens to consider as context. Ollama calls this `num_ctx`.
-        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.
-            It is important to instruct the model to use JSON in the prompt. Otherwise, the model may generate large amounts whitespace.
-        seed (int, optional): The seed to use for the model for reproducible outputs. Defaults to None.
-
-    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.
-    """
-
-    options = {
-        "num_predict": max_tokens,
-        "num_ctx": context_window,
-        "temperature": temperature,
-    }
-    if seed is not None:
-        options["seed"] = seed
-    options.update(kwargs)
-
-    all_args = {
-        "model": model,
-        "messages": messages,
-        "options": options,
-    }
-    if json_mode:
-        all_args["format"] = "json"
-    if tools:
-        all_args["tools"] = tools
-
-    try:
-        start_time = time.time()
-        response = client.chat(**all_args)  # type: ignore
-        end_time = time.time()
-        response_duration = end_time - start_time
-    except ResponseError as e:
-        # If the error says "model 'model' not found" use regex then raise a more specific error
-        expected_pattern = f"model '{model}' not found"
-        if re.search(expected_pattern, e.error):
-            raise ResponseError(
-                f"Model '{model}' not found. Please use not_again_ai.llm.ollama.service.pull() first."
-            ) from e
-        else:
-            raise ResponseError(e.error) from e
-
-    response_data: dict[str, Any] = {}
-
-    message = response["message"].get("content", "")
-    if message and json_mode:
-        with contextlib.suppress(json.JSONDecodeError):
-            message = json.loads(message)
-    response_data["message"] = message
-
-    if response["message"].get("tool_calls"):
-        tool_calls = response["message"]["tool_calls"]
-        tool_names = [tool_call["function"]["name"] for tool_call in tool_calls]
-        tool_args_list = [tool_call["function"]["arguments"] for tool_call in tool_calls]
-        response_data["tool_names"] = tool_names
-        response_data["tool_args_list"] = tool_args_list
-
-    tokenizer = load_tokenizer(model)
-    prompt_tokens = num_tokens_from_messages(messages, tokenizer)
-    response_data["prompt_tokens"] = prompt_tokens
-
-    response_data["completion_tokens"] = response.get("eval_count", None)
-    if response_data["completion_tokens"] is None:
-        response_data["completion_tokens"] = num_tokens_in_string(str(response_data["message"]), tokenizer)
-
-    response_data["response_duration"] = round(response_duration, 4)
-
-    return response_data

not_again_ai/local_llm/ollama/model_mapping.py

@@ -1,17 +0,0 @@
-"""Hardcoded mapping from ollama model names to their associated HuggingFace tokenizer.
-
-Given the way that Ollama models are tagged, we can against the first part of the model name,
-i.e. all phi3 models will start with "phi3".
-"""
-
-OLLAMA_MODEL_MAPPING = {
-    "phi3": "microsoft/Phi-3-mini-4k-instruct",
-    "llama3:": "nvidia/Llama3-ChatQA-1.5-8B",  # Using this version to get around needed to accept an agreement to get access to the tokenizer
-    "llama3.1": "unsloth/Meta-Llama-3.1-8B-Instruct",
-    "gemma": "google/gemma-1.1-7b-it",  # Requires HF_TOKEN set and accepting the agreement on the HF model page
-    "qwen2": "Qwen/Qwen2-7B-Instruct",
-    "granite-code": "ibm-granite/granite-34b-code-instruct",
-    "llama3-gradient": "nvidia/Llama3-ChatQA-1.5-8B",
-    "command-r": "CohereForAI/c4ai-command-r-v01",
-    "deepseek-coder-v2": "deepseek-ai/DeepSeek-Coder-V2-Lite-Base",
-}

not_again_ai/local_llm/ollama/ollama_client.py

@@ -1,24 +0,0 @@
-import os
-
-from ollama import Client
-
-
-def ollama_client(host: str | None = None, timeout: float | None = None) -> Client:
-    """Create an Ollama client instance based on the specified host or will read from the OLLAMA_HOST environment variable.
-
-    Args:
-        host (str, optional): The host URL of the Ollama server.
-        timeout (float, optional): The timeout for requests
-
-    Returns:
-        Client: An instance of the Ollama client.
-
-    Examples:
-        >>> client = client(host="http://localhost:11434")
-    """
-    if host is None:
-        host = os.getenv("OLLAMA_HOST")
-        if host is None:
-            raise ValueError("Host must be provided or OLLAMA_HOST environment variable must be set.")
-
-    return Client(host=host, timeout=timeout)

not_again_ai/local_llm/ollama/service.py

@@ -1,81 +0,0 @@
-from typing import Any
-
-from ollama import Client
-
-from not_again_ai.base.file_system import readable_size
-
-
-def list_models(client: Client) -> list[dict[str, Any]]:
-    """List models that are available locally.
-
-    Args:
-        client (Client): The Ollama client.
-
-    Returns:
-        list[dict[str, Any]]: A list of dictionaries (each corresponding to an available model) with the following keys:
-            name (str): Name of the model
-            model (str): Name of the model. This should be the same as the name.
-            modified_at (str): The date and time the model was last modified.
-            size (int): The size of the model in bytes.
-            size_readable (str): The size of the model in a human-readable format.
-            details (dict[str, Any]): Additional details about the model.
-    """
-    response = client.list().get("models", [])
-
-    response_data = []
-    for model_data in response:
-        curr_model_data = {}
-        curr_model_data["name"] = model_data["name"]
-        curr_model_data["model"] = model_data["model"]
-        curr_model_data["modified_at"] = model_data["modified_at"]
-        curr_model_data["size"] = model_data["size"]
-        curr_model_data["size_readable"] = readable_size(model_data["size"])
-        curr_model_data["details"] = model_data["details"]
-
-        response_data.append(curr_model_data)
-
-    return response_data
-
-
-def is_model_available(model_name: str, client: Client) -> bool:
-    """Check if a model is available locally.
-
-    Args:
-        model_name (str): The name of the model.
-        client (Client): The Ollama client.
-
-    Returns:
-        bool: True if the model is available locally, False otherwise.
-    """
-    # If model_name does not have a ":", append ":latest"
-    if ":" not in model_name:
-        model_name = f"{model_name}:latest"
-    models = list_models(client)
-    return any(model["name"] == model_name for model in models)
-
-
-def show(model_name: str, client: Client) -> dict[str, Any]:
-    """Show information about a model including the modelfile, available parameters, template, and additional details.
-
-    Args:
-        model_name (str): The name of the model.
-        client (Client): The Ollama client.
-    """
-    response = client.show(model_name)
-
-    response_data = {}
-    response_data["modelfile"] = response["modelfile"]
-    response_data["parameters"] = response["parameters"]
-    response_data["template"] = response["template"]
-    response_data["details"] = response["details"]
-    return response_data
-
-
-def pull(model_name: str, client: Client) -> Any:
-    """Pull a model from the Ollama server and returns the status of the pull operation."""
-    return client.pull(model_name)
-
-
-def delete(model_name: str, client: Client) -> Any:
-    """Delete a model from the local filesystem and returns the status of the delete operation."""
-    return client.delete(model_name)

not_again_ai/local_llm/ollama/tokens.py

@@ -1,104 +0,0 @@
-"""By default use the associated huggingface transformer tokenizer.
-If it does not exist in the mapping, default to tiktoken with some buffer (const + percentage)"""
-
-from loguru import logger
-import tiktoken
-from transformers import AutoTokenizer
-
-from not_again_ai.llm.openai_api.tokens import num_tokens_from_messages as openai_num_tokens_from_messages
-from not_again_ai.local_llm.ollama.model_mapping import OLLAMA_MODEL_MAPPING
-
-TIKTOKEN_NUM_TOKENS_BUFFER = 10
-TIKTOKEN_PERCENT_TOKENS_BUFFER = 1.1
-
-
-def load_tokenizer(model: str) -> AutoTokenizer | tiktoken.Encoding:
-    """Use the model mapping to load the appropriate tokenizer
-
-    Args:
-        model: The name of the language model to load the tokenizer for
-
-    Returns:
-        Either a HuggingFace tokenizer or a tiktoken encoding object
-    """
-
-    # Loop over the keys in the model mapping checking if the model starts with the key
-    for key in OLLAMA_MODEL_MAPPING:
-        if model.startswith(key):
-            return AutoTokenizer.from_pretrained(OLLAMA_MODEL_MAPPING[key], use_fast=True)
-
-    # If the model does not start with any key in the model mapping, default to tiktoken
-    logger.warning(
-        f'Model "{model}" not found in OLLAMA_MODEL_MAPPING. Using tiktoken - token counts will have an added buffer of \
-{TIKTOKEN_PERCENT_TOKENS_BUFFER * 100}% plus {TIKTOKEN_NUM_TOKENS_BUFFER} tokens.'
-    )
-    tokenizer = tiktoken.get_encoding("o200k_base")
-    return tokenizer
-
-
-def truncate_str(text: str, max_len: int, tokenizer: AutoTokenizer | tiktoken.Encoding) -> str:
-    """Truncates a string to a maximum token length.
-
-    Args:
-        text: The string to truncate.
-        max_len: The maximum number of tokens to keep.
-        tokenizer: Either a HuggingFace tokenizer or a tiktoken encoding object
-
-    Returns:
-        str: The truncated string.
-    """
-    if isinstance(tokenizer, tiktoken.Encoding):
-        tokens = tokenizer.encode(text)
-        if len(tokens) > max_len:
-            tokens = tokens[:max_len]
-            truncated_text = tokenizer.decode(tokens)
-            return truncated_text
-    else:
-        tokens = tokenizer(text, return_tensors=None)["input_ids"]
-        if len(tokens) > max_len:
-            tokens = tokens[:max_len]
-            truncated_text = tokenizer.decode(tokens)
-            return truncated_text
-
-    return text
-
-
-def num_tokens_in_string(text: str, tokenizer: AutoTokenizer | tiktoken.Encoding) -> int:
-    """Return the number of tokens in a string.
-
-    Args:
-        text: The string to count the tokens.
-        tokenizer: Either a HuggingFace tokenizer or a tiktoken encoding object
-
-    Returns:
-        int: The number of tokens in the string.
-    """
-    if isinstance(tokenizer, tiktoken.Encoding):
-        num_tokens = (len(tokenizer.encode(text)) * TIKTOKEN_PERCENT_TOKENS_BUFFER) + TIKTOKEN_NUM_TOKENS_BUFFER
-        return int(num_tokens)
-    else:
-        tokens = tokenizer(text, return_tensors=None)["input_ids"]
-        return len(tokens)
-
-
-def num_tokens_from_messages(messages: list[dict[str, str]], tokenizer: AutoTokenizer | tiktoken.Encoding) -> int:
-    """Return the number of tokens used by a list of messages.
-    For models with HuggingFace tokenizers, uses
-
-    Args:
-        messages: A list of messages to count the tokens
-            should ideally be the result after calling llm.prompts.chat_prompt.
-        tokenizer: Either a HuggingFace tokenizer or a tiktoken encoding object
-
-    Returns:
-        int: The number of tokens used by the messages.
-    """
-    if isinstance(tokenizer, tiktoken.Encoding):
-        num_tokens = (
-            openai_num_tokens_from_messages(messages, tokenizer=tokenizer, model="gpt-4o")
-            * TIKTOKEN_PERCENT_TOKENS_BUFFER
-        ) + TIKTOKEN_NUM_TOKENS_BUFFER
-        return int(num_tokens)
-    else:
-        tokens = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors=None)
-        return len(tokens)

not_again_ai/local_llm/prompts.py

@@ -1,38 +0,0 @@
-from copy import deepcopy
-
-from liquid import Template
-
-
-def chat_prompt(messages_unformatted: list[dict[str, str]], variables: dict[str, str]) -> list[dict[str, str]]:
-    """Formats a list of messages for chat completion models using Liquid templating.
-
-    Args:
-        messages_unformatted: A list of dictionaries where each dictionary
-            represents a message. Each message must have 'role' and 'content'
-            keys with string values, where content is a Liquid template.
-        variables: A dictionary where each key-value pair represents a variable
-            name and its value for template rendering.
-
-    Returns:
-        A list of dictionaries with the same structure as `messages_unformatted`,
-        but with the 'content' of each message with the provided `variables`.
-
-    Examples:
-        >>> messages = [
-        ...     {"role": "system", "content": "You are a helpful assistant."},
-        ...     {"role": "user", "content": "Help me {{task}}"}
-        ... ]
-        >>> vars = {"task": "write Python code for the fibonnaci sequence"}
-        >>> chat_prompt(messages, vars)
-        [
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": "Help me write Python code for the fibonnaci sequence"}
-        ]
-    """
-
-    messages_formatted = deepcopy(messages_unformatted)
-    for message in messages_formatted:
-        liquid_template = Template(message["content"])
-        message["content"] = liquid_template.render(**variables)
-
-    return messages_formatted

not_again_ai/local_llm/tokens.py

@@ -1,90 +0,0 @@
-import tiktoken
-from transformers import AutoTokenizer
-
-from not_again_ai.llm.openai_api.tokens import load_tokenizer as openai_load_tokenizer
-from not_again_ai.llm.openai_api.tokens import num_tokens_from_messages as openai_num_tokens_from_messages
-from not_again_ai.llm.openai_api.tokens import num_tokens_in_string as openai_num_tokens_in_string
-from not_again_ai.llm.openai_api.tokens import truncate_str as openai_truncate_str
-from not_again_ai.local_llm.ollama.tokens import load_tokenizer as ollama_load_tokenizer
-from not_again_ai.local_llm.ollama.tokens import num_tokens_from_messages as ollama_num_tokens_from_messages
-from not_again_ai.local_llm.ollama.tokens import num_tokens_in_string as ollama_num_tokens_in_string
-from not_again_ai.local_llm.ollama.tokens import truncate_str as ollama_truncate_str
-
-
-def load_tokenizer(model: str, provider: str) -> AutoTokenizer | tiktoken.Encoding:
-    """Load the tokenizer for the given model and providers
-
-    Args:
-        model (str): The name of the language model to load the tokenizer for
-        provider (str): Either "openai_api" or "ollama"
-
-    Returns:
-        Either a HuggingFace tokenizer or a tiktoken encoding object
-    """
-    if provider == "openai_api":
-        return openai_load_tokenizer(model)
-    elif provider == "ollama":
-        return ollama_load_tokenizer(model)
-    else:
-        raise ValueError(f"Unknown tokenizer provider {provider}")
-
-
-def truncate_str(text: str, max_len: int, tokenizer: AutoTokenizer | tiktoken.Encoding, provider: str) -> str:
-    """Truncates a string to a maximum token length.
-
-    Args:
-        text: The string to truncate.
-        max_len: The maximum number of tokens to keep.
-        tokenizer: Either a HuggingFace tokenizer or a tiktoken encoding object
-        provider (str): Either "openai_api" or "ollama"
-
-    Returns:
-        str: The truncated string.
-    """
-    if provider == "openai_api":
-        return openai_truncate_str(text, max_len, tokenizer)
-    elif provider == "ollama":
-        return ollama_truncate_str(text, max_len, tokenizer)
-    else:
-        raise ValueError(f'Unknown tokenizer provider "{provider}"')
-
-
-def num_tokens_in_string(text: str, tokenizer: AutoTokenizer | tiktoken.Encoding, provider: str) -> int:
-    """Return the number of tokens in a string.
-
-    Args:
-        text: The string to count the tokens.
-        tokenizer: Either a HuggingFace tokenizer or a tiktoken encoding object
-        provider (str): Either "openai_api" or "ollama"
-
-    Returns:
-        int: The number of tokens in the string.
-    """
-    if provider == "openai_api":
-        return openai_num_tokens_in_string(text, tokenizer)
-    elif provider == "ollama":
-        return ollama_num_tokens_in_string(text, tokenizer)
-    else:
-        raise ValueError(f'Unknown tokenizer provider "{provider}"')
-
-
-def num_tokens_from_messages(
-    messages: list[dict[str, str]], tokenizer: AutoTokenizer | tiktoken.Encoding, provider: str
-) -> int:
-    """Return the number of tokens used by a list of messages.
-
-    Args:
-        messages: A list of messages to count the tokens
-            should ideally be the result after calling llm.prompts.chat_prompt.
-        tokenizer: Either a HuggingFace tokenizer or a tiktoken encoding object
-        provider (str): Either "openai_api" or "ollama"
-
-    Returns:
-        int: The number of tokens used by the messages.
-    """
-    if provider == "openai_api":
-        return openai_num_tokens_from_messages(messages, tokenizer)
-    elif provider == "ollama":
-        return ollama_num_tokens_from_messages(messages, tokenizer)
-    else:
-        raise ValueError(f'Unknown tokenizer provider "{provider}"')

not_again_ai-0.14.0.dist-info/RECORD

@@ -1,44 +0,0 @@
-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/gh_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-not_again_ai/llm/gh_models/azure_ai_client.py,sha256=GkVn9ZwYbsLm3X0A3pGKKHuoqrxc-BZnZ4n9ExelRUQ,580
-not_again_ai/llm/gh_models/chat_completion.py,sha256=zI6Kfqb9AW0t_Yd1ecaXy7q70gygJ_XKcFbtYrKIbn4,3599
-not_again_ai/llm/openai_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-not_again_ai/llm/openai_api/chat_completion.py,sha256=5jO-J97zcKPJrzHn6V4NZB3nZa1RZwbIeMC3gbXlWWQ,17100
-not_again_ai/llm/openai_api/context_management.py,sha256=BJSG100_qw9MeTCZGztDV5CBXjVOxU4x7gyoRlLxWnI,3561
-not_again_ai/llm/openai_api/embeddings.py,sha256=4OBnxZicrY6q4dQhuPqMdAnifyjwrsKMTDj-kVre0yc,2500
-not_again_ai/llm/openai_api/openai_client.py,sha256=AK9SDBkpP94u5Q73-Q5i5HRPQh_D8cF8Dfl0IgPsJDQ,3816
-not_again_ai/llm/openai_api/prompts.py,sha256=lZYxgzoM2VqXWKUDToKWKR6w49KNYKu5TnqKLxG3TsM,8034
-not_again_ai/llm/openai_api/tokens.py,sha256=Q4xdCEPrmgDCNjmcB4rg6ipvo4_McwSjc-b9gAHjUJs,8024
-not_again_ai/local_llm/__init__.py,sha256=BsUn39U3QQaw6yomQHfp_HIPHRIBoMAgjcP3CDADx04,882
-not_again_ai/local_llm/chat_completion.py,sha256=PmICXrGZJXIuqY00ULBGi2bKnPG8ticqTXZHSTzZK9o,4828
-not_again_ai/local_llm/huggingface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-not_again_ai/local_llm/huggingface/chat_completion.py,sha256=Y6uMbxLG8TaMVi3hJGrMl_G9Y1N_0dld5Kv1iqYnoao,2300
-not_again_ai/local_llm/huggingface/helpers.py,sha256=YPr8KbQ8Ac_Mn_nBcrFuL3bCl-IuDCdaRvYVCocy8Gk,734
-not_again_ai/local_llm/ollama/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-not_again_ai/local_llm/ollama/chat_completion.py,sha256=WNnR-fe50wSDsoAdSZSKyjoqLCCPb00jIWSIFWo_Bbg,4890
-not_again_ai/local_llm/ollama/model_mapping.py,sha256=sJqPg97OO68O0k5MFkTjRLIn9gB7gCRAcyUEjxMfizo,891
-not_again_ai/local_llm/ollama/ollama_client.py,sha256=dktyw7aKFq4EA3dU7Le5UpfsSq3Oh_POmYSrAI4qLi8,765
-not_again_ai/local_llm/ollama/service.py,sha256=XczbxISTAp4KHnIkqRZaMsfBohH-TAHrjZ8T9x3cRAY,2900
-not_again_ai/local_llm/ollama/tokens.py,sha256=k7K7enOSuCJRHteDG0x-CbuivQ2uAtKK3e0Jr7-BUd4,3952
-not_again_ai/local_llm/prompts.py,sha256=mUpt8LMNnY9TVj-2tPE3lc81ZwWnBBrmBou0jxEPGL0,1560
-not_again_ai/local_llm/tokens.py,sha256=Tf1uH5zjyiejOPVr6eVYFj1m-jQpeDUcG7gZK-xMOAE,3679
-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.14.0.dist-info/LICENSE,sha256=btjOgNGpp-ux5xOo1Gx1MddxeWtT9sof3s3Nui29QfA,1071
-not_again_ai-0.14.0.dist-info/METADATA,sha256=kNL0KybcNVoN7fcCMNO1CohIWZAxc74gnV68zzoEDfI,16475
-not_again_ai-0.14.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-not_again_ai-0.14.0.dist-info/entry_points.txt,sha256=EMJegugnmJUd-jMUA_qIRMIPAasbei8gP6O4-ER0BxQ,61
-not_again_ai-0.14.0.dist-info/RECORD,,

not_again_ai-0.14.0.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-not-again-ai=not_again_ai.cli:entry_point
-