npcsh 0.3.31__py3-none-any.whl → 0.3.32__py3-none-any.whl

npcsh/audio_gen.py

@@ -0,0 +1 @@
+# audio_gen.py

npcsh/cli.py

@@ -1,5 +1,5 @@
 import argparse
-from .npc_sysenv import (
+from npcsh.npc_sysenv import (
     NPCSH_CHAT_MODEL,
     NPCSH_CHAT_PROVIDER,
     NPCSH_IMAGE_GEN_MODEL,
@@ -14,15 +14,15 @@ from .npc_sysenv import (
     NPCSH_STREAM_OUTPUT,
     NPCSH_SEARCH_PROVIDER,
 )
-from .serve import start_flask_server
-from .npc_compiler import (
+from npcsh.serve import start_flask_server
+from npcsh.npc_compiler import (
     initialize_npc_project,
     conjure_team,
     NPCCompiler,
     NPC,
     load_npc_from_file,
 )
-from .llm_funcs import (
+from npcsh.llm_funcs import (
     check_llm_command,
     execute_llm_command,
     execute_llm_question,
@@ -33,9 +33,9 @@ from .llm_funcs import (
     get_stream,
     get_conversation,
 )
-from .plonk import plonk, action_space
-from .search import search_web
-from .shell_helpers import *
+from npcsh.plonk import plonk, action_space
+from npcsh.search import search_web
+from npcsh.shell_helpers import *
 import os
 
 # check if ./npc_team exists
@@ -503,7 +503,7 @@ def main():
     elif args.command == "new":
         # create a new npc, tool, or assembly line
         if args.type == "npc":
-            from .npc_creator import create_new_npc
+            from npcsh.npc_creator import create_new_npc
 
             create_new_npc(
                 name=args.name,
@@ -514,7 +514,6 @@ def main():
                 autogen=args.autogen,
             )
         elif args.type == "tool":
-            from .tool_creator import create_new_tool
 
             create_new_tool(
                 name=args.name,
@@ -522,7 +521,6 @@ def main():
                 autogen=args.autogen,
             )
         elif args.type == "assembly_line":
-            from .assembly_creator import create_new_assembly_line
 
             create_new_assembly_line(
                 name=args.name,

npcsh/conversation.py

@@ -6,49 +6,15 @@
 ########
 from typing import Any, Dict, Generator, List
 import os
-import anthropic
 
-from openai import OpenAI
-from google.generativeai import types
-import google.generativeai as genai
-from .npc_sysenv import get_system_message
+from litellm import completion
+from npcsh.npc_sysenv import get_system_message
 
 
-def get_ollama_conversation(
-    messages: List[Dict[str, str]],
-    model: str,
-    npc: Any = None,
-    tools: list = None,
-    images=None,
-    **kwargs,
-) -> List[Dict[str, str]]:
-    """
-    Function Description:
-        This function generates a conversation using the Ollama API.
-    Args:
-        messages (List[Dict[str, str]]): The list of messages in the conversation.
-        model (str): The model to use for the conversation.
-    Keyword Args:
-        npc (Any): The NPC object.
-    Returns:
-        List[Dict[str, str]]: The list of messages in the conversation.
-    """
-    import ollama
-
-    messages_copy = messages.copy()
-    if messages_copy[0]["role"] != "system":
-        if npc is not None:
-            system_message = get_system_message(npc)
-            messages_copy.insert(0, {"role": "system", "content": system_message})
-
-    response = ollama.chat(model=model, messages=messages_copy)
-    messages_copy.append(response["message"])
-    return messages_copy
-
-
-def get_openai_conversation(
+def get_litellm_conversation(
     messages: List[Dict[str, str]],
     model: str,
+    provider: str,
     npc: Any = None,
     tools: list = None,
     api_key: str = None,
@@ -66,226 +32,23 @@ def get_openai_conversation(
         api_key (str): The API key for accessing the OpenAI API.
     Returns:
         List[Dict[str, str]]: The list of messages in the conversation.
-    """
-
-    try:
-        if api_key is None:
-            api_key = os.environ["OPENAI_API_KEY"]
-        client = OpenAI(api_key=api_key)
-
-        system_message = (
-            get_system_message(npc) if npc else "You are a helpful assistant."
-        )
-
-        if messages is None:
-            messages = []
-
-        # Ensure the system message is at the beginning
-        if not any(msg["role"] == "system" for msg in messages):
-            messages.insert(0, {"role": "system", "content": system_message})
-
-        # messages should already include the user's latest message
-
-        # Make the API call with the messages including the latest user input
-        completion = client.chat.completions.create(
-            model=model, messages=messages, **kwargs
-        )
-
-        response_message = completion.choices[0].message
-        messages.append({"role": "assistant", "content": response_message.content})
-
-        return messages
-
-    except Exception as e:
-        return f"Error interacting with OpenAI: {e}"
-
-
-def get_openai_like_conversation(
-    messages: List[Dict[str, str]],
-    model: str,
-    api_url: str,
-    npc: Any = None,
-    images=None,
-    tools: list = None,
-    api_key: str = None,
-    **kwargs,
-) -> List[Dict[str, str]]:
-    """
-    Function Description:
-        This function generates a conversation using an OpenAI-like API.
-    Args:
-        messages (List[Dict[str, str]]): The list of messages in the conversation.
-        model (str): The model to use for the conversation.
-    Keyword Args:
-        npc (Any): The NPC object.
-        api_url (str): The URL of the API endpoint.
-        api_key (str): The API key for accessing the API.
-    Returns:
-        List[Dict[str, str]]: The list of messages in the conversation.
-    """
-
-    if api_url is None:
-        raise ValueError("api_url is required for openai-like provider")
-    if api_key is None:
-        api_key = "dummy_api_key"
-    try:
-        client = OpenAI(api_key=api_key, base_url=api_url)
-
-        system_message = (
-            get_system_message(npc) if npc else "You are a helpful assistant."
-        )
-
-        if messages is None:
-            messages = []
-
-        # Ensure the system message is at the beginning
-        if not any(msg["role"] == "system" for msg in messages):
-            messages.insert(0, {"role": "system", "content": system_message})
-
-        # messages should already include the user's latest message
-
-        # Make the API call with the messages including the latest user input
-
-        completion = client.chat.completions.create(
-            model=model, messages=messages, **kwargs
-        )
-        response_message = completion.choices[0].message
-        messages.append({"role": "assistant", "content": response_message.content})
-
-        return messages
-
-    except Exception as e:
-        return f"Error interacting with OpenAI: {e}"
-
-    return messages
-
-
-def get_anthropic_conversation(
-    messages: List[Dict[str, str]],
-    model: str,
-    npc: Any = None,
-    tools: list = None,
-    images=None,
-    api_key: str = None,
-    **kwargs,
-) -> List[Dict[str, str]]:
-    """
-    Function Description:
-        This function generates a conversation using the Anthropic API.
-    Args:
-        messages (List[Dict[str, str]]): The list of messages in the conversation.
-        model (str): The model to use for the conversation.
-    Keyword Args:
-        npc (Any): The NPC object.
-        api_key (str): The API key for accessing the Anthropic API.
-    Returns:
-        List[Dict[str, str]]: The list of messages in the conversation.
-    """
-
-    try:
-        if api_key is None:
-            api_key = os.getenv("ANTHROPIC_API_KEY", None)
-        system_message = get_system_message(npc) if npc else ""
-        client = anthropic.Anthropic(api_key=api_key)
-        last_user_message = None
-        for msg in reversed(messages):
-            if msg["role"] == "user":
-                last_user_message = msg["content"]
-                break
-
-        if last_user_message is None:
-            raise ValueError("No user message found in the conversation history.")
-
-        # if a sys message is in messages, remove it
-        if messages[0]["role"] == "system":
-            messages.pop(0)
-
-        message = client.messages.create(
-            model=model,
-            system=system_message,  # Include system message in each turn for Anthropic
-            messages=messages,  # Send only the last user message
-            max_tokens=8192,
-            **kwargs,
-        )
-
-        messages.append({"role": "assistant", "content": message.content[0].text})
-
-        return messages
-
-    except Exception as e:
-        return f"Error interacting with Anthropic conversations: {e}"
-
-
-def get_gemini_conversation(
-    messages: List[Dict[str, str]],
-    model: str,
-    npc: Any = None,
-    tools: list = None,
-    api_key: str = None,
-) -> List[Dict[str, str]]:
-    """
-    Function Description:
-        This function generates a conversation using the Gemini API.
-    Args:
-        messages (List[Dict[str, str]]): The list of messages in the conversation.
-        model (str): The model to use for the conversation.
-    Keyword Args:
-        npc (Any): The NPC object.
-    Returns:
-        List[Dict[str, str]]: The list of messages in the conversation.
-    """
-    # Make the API call to Gemini
 
-    # print(messages)
-    response = get_gemini_response(
-        messages[-1]["content"], model, messages=messages[1:], npc=npc
-    )
-    # print(response)
-    return response.get("messages", [])
 
-
-def get_deepseek_conversation(
-    messages: List[Dict[str, str]],
-    model: str,
-    npc: Any = None,
-    tools: list = None,
-    api_key: str = None,
-) -> List[Dict[str, str]]:
+    Examples:
+        >>> messages = [    {"role": "user", "content": "Hello, how are you?"}]
+        >>> model = 'openai/gpt-4o-mini'
+        >>> response = get_litellm_conversation(messages, model)
     """
-    Function Description:
-        This function generates a conversation using the DeepSeek API.
-    Args:
-        messages (List[Dict[str, str]]): The list of messages in the conversation.
-        model (str): The model to use for the conversation.
-    Keyword Args:
-        npc (Any): The NPC object.
-    Returns:
-        List[Dict[str, str]]: The list of messages in the conversation.
-    """
-
     system_message = get_system_message(npc) if npc else "You are a helpful assistant."
+    if messages is None:
+        messages = []
 
-    # Prepare the messages list
-    if messages is None or len(messages) == 0:
-        messages = [{"role": "system", "content": system_message}]
-    elif not any(msg["role"] == "system" for msg in messages):
+    if not any(msg["role"] == "system" for msg in messages):
         messages.insert(0, {"role": "system", "content": system_message})
 
-    # Make the API call to DeepSeek
-    try:
-        response = get_deepseek_response(
-            messages[-1]["content"], model, messages=messages, npc=npc
-        )
-        messages.append(
-            {"role": "assistant", "content": response.get("response", "No response")}
-        )
+    resp = completion(model=f"{provider}/{model}", messages=messages)
 
-    except Exception as e:
-        messages.append(
-            {
-                "role": "assistant",
-                "content": f"Error interacting with DeepSeek: {str(e)}",
-            }
-        )
+    response_message = resp.choices[0].message
+    messages.append({"role": "assistant", "content": response_message.content})
 
     return messages

npcsh/dataframes.py

@@ -8,11 +8,19 @@ import io
 from PIL import Image
 from typing import Optional
 
-from .llm_funcs import get_llm_response
-from .audio import process_audio
-from .video import process_video
-
-from .load_data import load_pdf, load_csv, load_json, load_excel, load_txt, load_image
+from npcsh.llm_funcs import get_llm_response
+
+# from npcsh.audio import process_audio
+# from npcsh.video import process_video
+
+from npcsh.load_data import (
+    load_pdf,
+    load_csv,
+    load_json,
+    load_excel,
+    load_txt,
+    load_image,
+)
 
 
 def load_data_into_table(

npcsh/helpers.py

@@ -106,6 +106,11 @@ def ensure_npcshrc_exists() -> str:
             )
 
             npcshrc.write("export NPCSH_IMAGE_GEN_PROVIDER='diffusers'\n")
+            npcshrc.write(
+                "export NPCSH_VIDEO_GEN_MODEL='runwayml/stable-diffusion-v1-5'\n"
+            )
+
+            npcshrc.write("export NPCSH_VIDEO_GEN_PROVIDER='diffusers'\n")
 
             npcshrc.write("export NPCSH_API_URL=''\n")
             npcshrc.write("export NPCSH_DB_PATH='~/npcsh_history.db'\n")

npcsh/image.py

@@ -6,8 +6,8 @@ import subprocess
 from typing import Dict, Any
 from PIL import ImageGrab  # Import ImageGrab from Pillow
 
-from .npc_sysenv import NPCSH_VISION_MODEL, NPCSH_VISION_PROVIDER, NPCSH_API_URL
-from .llm_funcs import get_llm_response, get_stream
+from npcsh.npc_sysenv import NPCSH_VISION_MODEL, NPCSH_VISION_PROVIDER, NPCSH_API_URL
+from npcsh.llm_funcs import get_llm_response, get_stream
 import os
 
 

npcsh/image_gen.py

@@ -9,47 +9,15 @@
 
 import os
 
-from openai import OpenAI
 
+from litellm import image_generation
+from npcsh.npc_sysenv import (
+    NPCSH_IMAGE_GEN_MODEL,
+    NPCSH_IMAGE_GEN_PROVIDER,
+)
 
-def generate_image_openai(
-    prompt: str,
-    model: str,
-    api_key: str = None,
-    size: str = None,
-    npc=None,
-) -> str:
-    """
-    Function Description:
-        This function generates an image using the OpenAI API.
-    Args:
-        prompt (str): The prompt for generating the image.
-        model (str): The model to use for generating the image.
-        api_key (str): The API key for accessing the OpenAI API.
-    Keyword Args:
-        None
-    Returns:
-        str: The URL of the generated image.
-    """
-    if api_key is None:
-        api_key = os.environ.get("OPENAI_API_KEY")
-    if model is None:
-        model = "dall-e-2"
-    client = OpenAI(api_key=api_key)
-    if size is None:
-        size = "1024x1024"
-    if model not in ["dall-e-3", "dall-e-2"]:
-        # raise ValueError(f"Invalid model: {model}")
-        print(f"Invalid model: {model}")
-        print("Switching to dall-e-3")
-        model = "dall-e-3"
-    image = client.images.generate(model=model, prompt=prompt, n=1, size=size)
-    if image is not None:
-        # print(image)
-        return image
 
-
-def generate_image_hf_diffusion(
+def generate_image_diffusers(
     prompt: str,
     model: str = "runwayml/stable-diffusion-v1-5",
     device: str = "cpu",
@@ -77,3 +45,35 @@ def generate_image_hf_diffusion(
     image.show()
 
     return image
+
+
+def generate_image_litellm(
+    prompt: str,
+    model: str = NPCSH_IMAGE_GEN_MODEL,
+    provider: str = NPCSH_IMAGE_GEN_PROVIDER,
+    api_key: str = None,
+    size: str = None,
+    npc=None,
+) -> str:
+    """
+    Function Description:
+        This function generates an image using the OpenAI API.
+    Args:
+        prompt (str): The prompt for generating the image.
+        model (str): The model to use for generating the image.
+        api_key (str): The API key for accessing the OpenAI API.
+    Keyword Args:
+        None
+    Returns:
+        str: The URL of the generated image.
+    """
+    if model is None:
+        model = "runwayml/stable-diffusion-v1-5"
+    if size is None:
+        size = "1024x1024"
+    if provider == "diffusers":
+        return generate_image_diffusers(prompt, model)
+    else:
+        return image_generation(
+            prompt=prompt, model=f"{provider}/{model}", n=2, size="240x240"
+        )

npcsh/knowledge_graph.py

@@ -11,8 +11,8 @@ except ModuleNotFoundError:
 from typing import Optional, Dict, List, Union, Tuple
 
 
-from .llm_funcs import get_llm_response, get_embeddings
-from .npc_compiler import NPC
+from npcsh.llm_funcs import get_llm_response, get_embeddings
+from npcsh.npc_compiler import NPC
 import sqlite3
 
 
@@ -738,7 +738,7 @@ def process_text_with_chroma(
         print(f"\nProcessing batch {i//batch_size + 1} ({len(batch)} facts)")
 
         # Generate embeddings for the batch using npcsh.llm_funcs.get_embeddings
-        from .llm_funcs import get_embeddings
+        from npcsh.llm_funcs import get_embeddings
 
         batch_embeddings = get_embeddings(
             batch,
@@ -812,7 +812,7 @@ def hybrid_search_with_chroma(
         List of dictionaries with combined results
     """
     # Get embedding for query using npcsh.llm_funcs.get_embeddings
-    from .llm_funcs import get_embeddings
+    from npcsh.llm_funcs import get_embeddings
 
     query_embedding = get_embeddings([query])[0]