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

npcsh/stream.py

@@ -1,233 +0,0 @@
-########
-########
-########
-########
-######## STREAM
-########
-########
-
-from typing import Any, Dict, Generator, List
-import os
-import base64
-import json
-import requests
-from PIL import Image
-from typing import Any, Dict, Generator, List, Union
-
-from pydantic import BaseModel
-from npcsh.npc_sysenv import (
-    get_system_message,
-    compress_image,
-    available_chat_models,
-    available_reasoning_models,
-)
-
-from litellm import completion
-
-# import litellm
-# litellm._turn_on_debug()
-
-
-def get_litellm_stream(
-    messages: List[Dict[str, str]],
-    model: str,
-    provider: str = None,
-    npc: Any = None,
-    tools: list = None,
-    images: List[Dict[str, str]] = None,
-    api_key: str = None,
-    api_url: str = None,
-    tool_choice: Dict = None,
-    **kwargs,
-) -> Generator:
-    """Streams responses from OpenAI, supporting images, tools and yielding raw text chunks."""
-    system_message = get_system_message(npc) if npc else "You are a helpful assistant."
-
-    if not messages:
-        messages = [{"role": "system", "content": system_message}]
-
-    # Add images if provided
-    if images:
-        last_user_message = (
-            messages[-1]
-            if messages and messages[-1]["role"] == "user"
-            else {"role": "user", "content": []}
-        )
-
-        if isinstance(last_user_message["content"], str):
-            last_user_message["content"] = [
-                {"type": "text", "text": last_user_message["content"]}
-            ]
-
-        for image in images:
-            with open(image["file_path"], "rb") as image_file:
-                image_data = base64.b64encode(image_file.read()).decode("utf-8")
-                last_user_message["content"].append(
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
-                    }
-                )
-
-        if last_user_message not in messages:
-            messages.append(last_user_message)
-
-    # Prepare API call parameters
-    # print("provider", provider)
-    # print("model", model)
-    if provider is not None:
-        model_str = f"{provider}/{model}"
-    else:
-        model_str = model
-
-    api_params = {
-        "model": model_str,
-        "messages": messages,
-        "stream": True,
-    }
-    # print(api_params["model"])
-
-    if api_key is not None and provider == "openai-like":
-        print(api_key)
-        api_params["api_key"] = api_key
-
-    if api_url is not None and provider == "openai-like":
-        api_params["api_url"] = api_url
-
-    # Add tools if provided
-    if tools:
-        api_params["tools"] = tools
-
-    # Add tool choice if specified
-    if tool_choice:
-        api_params["tool_choice"] = tool_choice
-    if kwargs:
-        for key, value in kwargs.items():
-            if key in [
-                "stream",
-                "stop",
-                "temperature",
-                "top_p",
-                "max_tokens",
-                "max_completion_tokens",
-                "tools",
-                "tool_choice",
-                "extra_headers",
-                "parallel_tool_calls",
-                "response_format",
-                "user",
-            ]:
-                api_params[key] = value
-    # print(api_params)
-    stream = completion(**api_params)
-
-    for chunk in stream:
-        yield chunk
-
-
-def process_litellm_tool_stream(stream, tool_map: Dict[str, callable]) -> List[Dict]:
-    """
-    Process the litellm tool use stream
-    """
-    final_tool_calls = {}
-    tool_results = []
-
-    for chunk in stream:
-        delta = chunk.choices[0].delta
-
-        # Process tool calls if present
-        if delta.tool_calls:
-            for tool_call in delta.tool_calls:
-                index = tool_call.index
-
-                # Initialize tool call if new
-                if index not in final_tool_calls:
-                    final_tool_calls[index] = {
-                        "id": tool_call.id,
-                        "name": tool_call.function.name if tool_call.function else None,
-                        "arguments": (
-                            tool_call.function.arguments if tool_call.function else ""
-                        ),
-                    }
-                # Append arguments if continuing
-                elif tool_call.function and tool_call.function.arguments:
-                    final_tool_calls[index]["arguments"] += tool_call.function.arguments
-
-    # Process all complete tool calls
-    for tool_call in final_tool_calls.values():
-        try:
-            # Parse the arguments
-            tool_input = (
-                json.loads(tool_call["arguments"])
-                if tool_call["arguments"].strip()
-                else {}
-            )
-
-            # Execute the tool
-            tool_func = tool_map.get(tool_call["name"])
-            if tool_func:
-                result = tool_func(tool_input)
-                tool_results.append(
-                    {
-                        "tool_name": tool_call["name"],
-                        "tool_input": tool_input,
-                        "tool_result": result,
-                    }
-                )
-            else:
-                tool_results.append(
-                    {
-                        "tool_name": tool_call["name"],
-                        "tool_input": tool_input,
-                        "error": f"Tool {tool_call['name']} not found",
-                    }
-                )
-
-        except Exception as e:
-            tool_results.append(
-                {
-                    "tool_name": tool_call["name"],
-                    "tool_input": tool_call["arguments"],
-                    "error": str(e),
-                }
-            )
-
-    return tool_results
-
-
-from typing import List, Dict, Any, Literal
-
-
-def generate_tool_schema(
-    name: str,
-    description: str,
-    parameters: Dict[str, Any],
-    required: List[str] = None,
-) -> Dict[str, Any]:
-    """
-    Generate provider-specific function/tool schema from common parameters
-
-    Args:
-        name: Name of the function
-        description: Description of what the function does
-        parameters: Dict of parameter names and their properties
-        provider: Which provider to generate schema for
-        required: List of required parameter names
-    """
-    if required is None:
-        required = []
-
-    return {
-        "type": "function",
-        "function": {
-            "name": name,
-            "description": description,
-            "parameters": {
-                "type": "object",
-                "properties": parameters,
-                "required": required,
-                "additionalProperties": False,
-            },
-            "strict": True,
-        },
-    }

npcsh/video.py

@@ -1,52 +0,0 @@
-# video.py
-
-
-def process_video(file_path, table_name):
-    # implement with moon dream
-
-    embeddings = []
-    texts = []
-    try:
-        video = cv2.VideoCapture(file_path)
-        fps = video.get(cv2.CAP_PROP_FPS)
-        frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
-
-        for i in range(frame_count):
-            ret, frame = video.read()
-            if not ret:
-                break
-
-            # Process every nth frame (adjust n as needed for performance)
-            n = 10  # Process every 10th frame
-            if i % n == 0:
-                # Image Embeddings
-                _, buffer = cv2.imencode(".jpg", frame)  # Encode frame as JPG
-                base64_image = base64.b64encode(buffer).decode("utf-8")
-                image_info = {
-                    "filename": f"frame_{i}.jpg",
-                    "file_path": f"data:image/jpeg;base64,{base64_image}",
-                }  # Use data URL for OpenAI
-                image_embedding_response = get_llm_response(
-                    "Describe this image.",
-                    image=image_info,
-                    model="gpt-4",
-                    provider="openai",
-                )  # Replace with your image embedding model
-                if (
-                    isinstance(image_embedding_response, dict)
-                    and "error" in image_embedding_response
-                ):
-                    print(
-                        f"Error generating image embedding: {image_embedding_response['error']}"
-                    )
-                else:
-                    # Assuming your image embedding model returns a textual description
-                    embeddings.append(image_embedding_response)
-                    texts.append(f"Frame {i}: {image_embedding_response}")
-
-        video.release()
-        return embeddings, texts
-
-    except Exception as e:
-        print(f"Error processing video: {e}")
-        return [], []  # Return empty lists in case of error

npcsh/video_gen.py

@@ -1,69 +0,0 @@
-def generate_video_diffusers(
-    prompt,
-    model,
-    npc=None,
-    device="cpu",
-    output_path="",
-    num_inference_steps=10,
-    num_frames=125,
-    height=256,
-    width=256,
-):
-
-    import torch
-    from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler
-    import numpy as np
-    import cv2
-
-    # Load pipeline
-    pipe = DiffusionPipeline.from_pretrained(
-        "damo-vilab/text-to-video-ms-1.7b", torch_dtype=torch.float32
-    ).to(device)
-    pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
-
-    output = pipe(
-        prompt,
-        num_inference_steps=num_inference_steps,
-        num_frames=num_frames,
-        height=height,
-        width=width,
-    )
-
-    def save_frames_to_video(frames, output_path, fps=8):
-        """Handle the specific 5D array format (1, num_frames, H, W, 3) with proper type conversion"""
-        # Verify input format
-        if not (
-            isinstance(frames, np.ndarray)
-            and frames.ndim == 5
-            and frames.shape[-1] == 3
-        ):
-            raise ValueError(
-                f"Unexpected frame format. Expected 5D RGB array, got {frames.shape}"
-            )
-
-        # Remove batch dimension and convert to 0-255 uint8
-        frames = (frames[0] * 255).astype(np.uint8)  # Shape: (num_frames, H, W, 3)
-
-        # Get video dimensions
-        height, width = frames.shape[1:3]
-
-        # Create video writer
-        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-        video_writer = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-
-        if not video_writer.isOpened():
-            raise IOError(f"Could not open video writer for {output_path}")
-
-        # Write frames (convert RGB to BGR for OpenCV)
-        for frame in frames:
-            video_writer.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
-
-        video_writer.release()
-        print(f"Successfully saved {frames.shape[0]} frames to {output_path}")
-
-    os.makedirs("~/.npcsh/videos/")
-    if output_path == "":
-
-        output_path = "~/.npcsh/videos/" + prompt[0:8] + ".mp4"
-    save_frames_to_video(output.frames, output_path)
-    return output_path

npcsh-0.3.32.data/data/npcsh/npc_team/bash_executer.tool

@@ -1,32 +0,0 @@
-tool_name: bash_executor
-description: Execute bash queries.
-inputs:
-  - bash_command
-  - user_request
-steps:
-  - engine: python
-    code: |
-      import subprocess
-      import os
-      cmd = '{{bash_command}}'  # Properly quote the command input
-      def run_command(cmd):
-        process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        stdout, stderr = process.communicate()
-        if stderr:
-          print(f"Error: {stderr.decode('utf-8')}")
-          return stderr
-        return stdout
-      result = run_command(cmd)
-      output = result.decode('utf-8')
-
-  - engine: natural
-    code: |
-
-      Here is the result of the bash command:
-      ```
-      {{ output }}
-      ```
-      This was the original user request: {{ user_request }}
-
-      Please provide a response accordingly.
-

npcsh-0.3.32.data/data/npcsh/npc_team/calculator.tool

@@ -1,8 +0,0 @@
-tool_name: "calculator"
-description: "A tool to simplify and evaluate mathematical expressions"
-inputs:
-  - expression
-steps:
-  - engine: python
-    code: |
-      output = eval('{{ expression }}')

npcsh-0.3.32.data/data/npcsh/npc_team/code_executor.tool

@@ -1,16 +0,0 @@
-tool_name: code_executor
-description: Execute scripts with a specified language. choose from python, bash, R, or javascript. Set the ultimate result as the "output" variable. It must be a string. Do not add unnecessary print statements.
-inputs:
-  - code
-  - language
-steps:
-  - engine: '{{ language }}'
-    code: |
-      {{code}}
-  - engine: natural
-    code: |
-      Here is the result of the code execution that an agent ran.
-      ```
-      {{ output }}
-      ```
-      please provide a response accordingly.

npcsh-0.3.32.data/data/npcsh/npc_team/corca.npc

@@ -1,13 +0,0 @@
-name: corca
-primary_directive: |
-    You are corca, a distinguished member of the NPC team.
-    Your expertise is in the area of software development and
-    you have a kanck for thinking through problems carefully.
-    You favor solutions that prioritize simplicity and clarity and
-    ought to always consider how some suggestion may increase rather than reduce tech debt
-    unnecessarily. Now, the key is in this last term, "unnecessarily".
-    You must distinguish carefully and when in doubt, opt to ask for further
-    information or clarification with concrete clear options that make it
-    easy for a user to choose.
-model: gpt-4o-mini
-provider: openai

npcsh-0.3.32.data/data/npcsh/npc_team/eriane.npc

@@ -1,4 +0,0 @@
-name: eriane
-primary_directive: you are an expert in the humanities and you must draw from your vast knowledge of history, literature, art, and philosophy to aid users in their requests, pulling real useful examples that can make users better understand results.
-model: gpt-4o-mini
-provider: openai

npcsh-0.3.32.data/data/npcsh/npc_team/foreman.npc

@@ -1,7 +0,0 @@
-name: foreman
-primary_directive: You are the foreman of an NPC team. It is your duty
-    to delegate tasks to your team members or to other specialized teams
-    in order to complete the project. You are responsible for the
-    completion of the project and the safety of your team members.
-model: gpt-4o-mini
-provider: openai

npcsh-0.3.32.data/data/npcsh/npc_team/generic_search.tool

@@ -1,27 +0,0 @@
-tool_name: "internet_search"
-description: Searches the web for information based on a query in order to verify timiely details (e.g. current events) or to corroborate information in uncertain situations. Should be mainly only used when users specifically request a search, otherwise an LLMs basic knowledge should be sufficient.
-inputs:
-  - query
-  - provider: ''
-steps:
-  - engine: "python"
-    code: |
-      from npcsh.search import search_web
-      from npcsh.npc_sysenv import NPCSH_SEARCH_PROVIDER
-      query = "{{ query }}"
-      provider = '{{ provider }}'
-      if provider.strip() != '':
-          results = search_web(query, num_results=5, provider = provider)
-      else:
-          results = search_web(query, num_results=5, provider = NPCSH_SEARCH_PROVIDER)
-
-      print('QUERY in tool', query)
-      results = search_web(query, num_results=5, provider = NPCSH_SEARCH_PROVIDER)
-      print('RESULTS in tool', results)
-  - engine: "natural"
-    code: |
-      Using the following information extracted from the web:
-
-      {{ results }}
-
-      Answer the users question: {{ query }}

npcsh-0.3.32.data/data/npcsh/npc_team/image_generation.tool

@@ -1,25 +0,0 @@
-tool_name: "image_generation_tool"
-description: |
-  Generates images based on a text prompt.
-inputs:
-  - prompt
-  - model: 'runwayml/stable-diffusion-v1-5'
-  - provider: 'diffusers'
-
-steps:
-  - engine: "python"
-    code: |
-      image_prompt = '{{prompt}}'.strip()
-
-      # Generate the image
-      filename = generate_image(
-          image_prompt,
-          npc=npc,
-          model='{{model}}',  # You can adjust the model as needed
-          provider='{{provider}}'
-      )
-      if filename:
-          image_generated = True
-      else:
-          image_generated = False
-

npcsh-0.3.32.data/data/npcsh/npc_team/local_search.tool

@@ -1,149 +0,0 @@
-tool_name: local_search
-description: |
-    Searches files in current and downstream directories to find items related to the user's query using fuzzy matching.
-    Returns only relevant snippets (10 lines around matches) to avoid including too much irrelevant content.
-    Intended for fuzzy searches, not for understanding file sizes.
-inputs:
-  - query
-  - summarize: false  # Optional - set to true to summarize the results
-  - file_filter: 'none'  # Optional - can be filename patterns or folder names
-  - depth: 2  # Optional - search depth for nested directories
-  - fuzzy_threshold: 70  # Optional - minimum fuzzy match score (0-100)
-steps:
-  - engine: python
-    code: |
-        # Search parameters are directly available
-        query = "{{ query }}"
-        file_filter = "{{ file_filter | default('None') }}"
-        if isinstance(file_filter, str) and file_filter.lower() == 'none':
-            file_filter = None
-        max_depth = {{ depth | default(2) }}
-        fuzzy_threshold = {{ fuzzy_threshold | default(70) }}
-
-        import os
-        import fnmatch
-        from pathlib import Path
-        from thefuzz import fuzz  # Fuzzy string matching library
-
-        def find_files(file_filter=None, max_depth=2):
-            default_extensions = ['.py', '.txt', '.md',
-                                '.json', '.yml', '.yaml',
-                                '.log', '.csv', '.html',
-                                '.js', '.css']
-            matches = []
-            root_path = Path('.').resolve()  # Resolve to absolute path
-
-            # First, check files in the current directory
-            for path in root_path.iterdir():
-                if path.is_file():
-                    # Skip hidden files
-                    if path.name.startswith('.'):
-                        continue
-
-                    # If no filter specified, include files with default extensions
-                    if file_filter is None:
-                        if path.suffix in default_extensions:
-                            matches.append(str(path))
-                    else:
-                        # If filter specified, check if file matches the filter
-                        filters = [file_filter] if isinstance(file_filter, str) else file_filter
-                        for f in filters:
-                            if (fnmatch.fnmatch(path.name, f) or
-                                fnmatch.fnmatch(str(path), f'*{f}*')):
-                                matches.append(str(path))
-                                break
-
-            # Then, check subdirectories with depth control
-            for path in root_path.rglob('*'):
-                # Skip hidden folders and common directories to ignore
-                if '/.' in str(path) or '__pycache__' in str(path) or '.git' in str(path) or 'node_modules' in str(path) or 'venv' in str(path):
-                    continue
-
-                # Skip if we've gone too deep
-                relative_depth = len(path.relative_to(root_path).parts)
-                if relative_depth > max_depth:
-                    continue
-
-                if path.is_file():
-                    # If no filter specified, include files with default extensions
-                    if file_filter is None:
-                        if path.suffix in default_extensions:
-                            matches.append(str(path))
-                    else:
-                        # If filter specified, check if file matches the filter
-                        filters = [file_filter] if isinstance(file_filter, str) else file_filter
-                        for f in filters:
-                            if (fnmatch.fnmatch(path.name, f) or
-                                fnmatch.fnmatch(str(path), f'*{f}*')):
-                                matches.append(str(path))
-                                break
-
-            return matches
-
-        # Find and load files
-        files = find_files(file_filter, max_depth)
-
-        # Process documents
-        relevant_chunks = []
-        for file_path in files:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                lines = f.readlines()  # Read file as lines
-            if lines:
-                # Join lines into a single string for fuzzy matching
-                content = ''.join(lines)
-                match_score = fuzz.partial_ratio(query.lower(), content.lower())
-                if match_score >= fuzzy_threshold:
-                    # Find the best matching line
-                    best_line_index = -1
-                    best_line_score = 0
-                    for i, line in enumerate(lines):
-                        line_score = fuzz.partial_ratio(query.lower(), line.lower())
-                        if line_score > best_line_score:
-                            best_line_score = line_score
-                            best_line_index = i
-
-                    # Extract 10 lines around the best matching line
-                    if best_line_index != -1:
-                        start = max(0, best_line_index - 5)  # 5 lines before
-                        end = min(len(lines), best_line_index + 6)  # 5 lines after
-                        snippet = ''.join(lines[start:end])
-                        relevant_chunks.append({
-                            'path': file_path,
-                            'snippet': snippet,
-                            'ext': Path(file_path).suffix.lower(),
-                            'score': match_score
-                        })
-
-        # Sort results by match score (highest first)
-        relevant_chunks.sort(key=lambda x: x['score'], reverse=True)
-
-        # Format results
-        if relevant_chunks:
-            context_text = "Here are the most relevant code sections:\n\n"
-            for chunk in relevant_chunks:
-                file_path = chunk['path'].replace('./', '')
-                context_text += f"File: {file_path} (match score: {chunk['score']})\n"
-                context_text += f"```{chunk['ext'][1:] if chunk['ext'] else ''}\n"
-                context_text += f"{chunk['snippet'].strip()}\n"
-                context_text += "```\n\n"
-        else:
-            context_text = "No relevant code sections found.\n"
-
-        output = context_text
-
-  - engine: natural
-    code: |
-        {% if summarize %}
-        You are a helpful coding assistant.
-        Please help with this query:
-
-        `{{ query }}`
-
-        The user is attempting to carry out a local search. This search returned the following results:
-
-        `{{ results }}`
-
-        Please analyze the code sections above and provide a clear, helpful response that directly addresses the query.
-        If you reference specific files or code sections in your response, indicate which file they came from.
-        Make sure to explain your reasoning and how the provided code relates to the query.
-        {% endif %}

npcsh-0.3.32.data/data/npcsh/npc_team/npcsh.ctx

@@ -1,11 +0,0 @@
-context: |
-    The npcsh NPC team is devoted to providing a safe and helpful
-    environment for users where they can work and be as successful as possible.
-    npcsh is a command-line tool that makes it easy for users to harness
-    the power of LLMs from a command line shell.
-databases:
-    - ~/npcsh_history.db
-mcp_servers:
-    - /path/to/mcp/server.py
-    - @npm for server
-

npcsh-0.3.32.data/data/npcsh/npc_team/npcsh_executor.tool

@@ -1,9 +0,0 @@
-tool_name: npcsh_executor
-description: Execute npcsh commands. Use the macro commands.
-inputs:
-  - code
-  - language
-steps:
-  - engine: "{{language}}"
-    code: |
-      {{code}}