npcsh 0.3.30__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,8 +33,9 @@ from .llm_funcs import (
     get_stream,
     get_conversation,
 )
-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
@@ -54,10 +55,12 @@ def main():
         "assemble",
         "build",
         "compile",
+        "chat",
         "init",
         "new",
         "plonk",
         "sample",
+        "search",
         "select",
         "serve",
         "spool",
@@ -165,6 +168,10 @@ def main():
         "directory", nargs="?", default=".", help="Directory to build project in"
     )
 
+    # chat
+    chat_parser = subparsers.add_parser("chat", help="chat with an NPC")
+    chat_parser.add_argument("-n", "--npc_name", help="name of npc")
+
     # Compile command
     compile_parser = subparsers.add_parser("compile", help="Compile an NPC")
     compile_parser.add_argument("path", help="Path to NPC file")
@@ -300,7 +307,7 @@ def main():
 
     # Web search
     search_parser = subparsers.add_parser("search", help="search the web")
-    search_parser.add_argument("query", help="search query")
+    search_parser.add_argument("--query", "-q", help="search query")
     search_parser.add_argument(
         "--search_provider",
         "-sp",
@@ -317,7 +324,7 @@ def main():
 
     # Voice chat
     whisper_parser = subparsers.add_parser("whisper", help="start voice chat")
-    whisper_parser.add_argument("npc_name", help="name of the NPC to chat with")
+    whisper_parser.add_argument("-n", "--npc_name", help="name of the NPC to chat with")
 
     args = parser.parse_args()
 
@@ -367,6 +374,13 @@ def main():
             port=args.port if args.port else 5337,
             cors_origins=cors_origins,
         )
+    elif args.command == "chat":
+        npc_name = args.npc_name
+        npc_path = get_npc_path(npc_name, NPCSH_DB_PATH)
+        current_npc = load_npc_from_file(npc_path, sqlite3.connect(NPCSH_DB_PATH))
+        return enter_spool_mode(
+            model=args.model, provider=args.provider, npc=current_npc
+        )
 
     elif args.command == "init":
         if args.templates:
@@ -395,16 +409,18 @@ def main():
         )
 
     elif args.command == "compile":
-        compile_npc(args.path)
+        npc_compiler = NPCCompiler(npc_directory, NPCSH_DB_PATH)
+        compiled = npc_compiler.compile(args.path)
+        print("NPC compiled to:", compiled)
 
     elif args.command == "plonk":
         task = args.task or args.spell
         npc_name = args.name
-        run_plonk_task(
-            task=task,
-            npc_name=npc_name,
-            model=args.model or NPCSH_REASONING_MODEL,
-            provider=args.provider or NPCSH_REASONING_PROVIDER,
+        plonk(
+            task,
+            action_space,
+            model=args.model or NPCSH_CHAT_MODEL,
+            provider=args.provider or NPCSH_CHAT_PROVIDER,
         )
 
     elif args.command == "sample":
@@ -443,10 +459,14 @@ def main():
             model=args.model,
             provider=args.provider,
         )
-        print(result)
+        print(result["output"])
 
     elif args.command == "whisper":
-        start_whisper_chat(args.npc_name)
+        npc_name = args.npc_name
+        npc_path = get_npc_path(npc_name, NPCSH_DB_PATH)
+        current_npc = load_npc_from_file(npc_path, sqlite3.connect(NPCSH_DB_PATH))
+
+        enter_whisper_mode(npc=current_npc)
 
     elif args.command == "tool":
         result = invoke_tool(
@@ -483,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,
@@ -494,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,
@@ -502,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
 
 
@@ -283,8 +283,6 @@ def analyze_image(
                         api_key=api_key,
                     )
 
-                    print(response)
-                    # Add to command history *inside* the try block
                     return response
 
             except Exception as e:

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]