npcpy 1.1.28__py3-none-any.whl → 1.2.32__py3-none-any.whl

npcpy/data/audio.py

@@ -25,7 +25,7 @@ try:
     RATE = 16000
     CHUNK = 512
 
-    # State Management
+    
     is_speaking = False
     should_stop_speaking = False
     tts_sequence = 0
@@ -35,12 +35,12 @@ try:
     last_speech_time = 0
     running = True
 
-    # Queues
+    
     audio_queue = queue.Queue()
     tts_queue = queue.PriorityQueue()
     cleanup_files = []
 
-    # Initialize pygame mixer
+    
     pygame.mixer.quit()
     pygame.mixer.init(frequency=44100, size=-16, channels=2, buffer=512)
 except:
@@ -49,7 +49,7 @@ except:
 
 def convert_mp3_to_wav(mp3_file, wav_file):
     try:
-        # Ensure the output file doesn't exist before conversion
+        
         if os.path.exists(wav_file):
             os.remove(wav_file)
 
@@ -79,7 +79,7 @@ def convert_mp3_to_wav(mp3_file, wav_file):
         raise
 
 
-# Check if FFmpeg is available
+
 def check_ffmpeg():
     try:
         subprocess.run(
@@ -98,7 +98,7 @@ def get_context_string():
     return "\n".join(context)
 
 
-# Audio Management Functions
+
 def cleanup_temp_files():
     global cleanup_files
     for file in list(cleanup_files):
@@ -175,7 +175,7 @@ def run_transcription(audio_np):
         return None
 
 
-# History Management Functions
+
 def load_history():
     global history
     try:
@@ -216,7 +216,7 @@ def get_context_string():
     return "\n".join(context)
 
 
-# Audio Management Functions
+
 def cleanup_temp_files():
     global cleanup_files
     for file in list(cleanup_files):
@@ -255,7 +255,7 @@ def audio_callback(in_data, frame_count, time_info, status):
     return (in_data, pyaudio.paContinue)
 
 
-# Text-to-Speech Functions
+
 def play_audio_from_queue():
     global is_speaking, cleanup_files, should_stop_speaking
     next_sequence = 0
@@ -349,7 +349,7 @@ import uuid
 
 def create_and_queue_audio(text, state):
     """Create and queue audio with state awareness for TTS/recording coordination"""
-    # Set TTS speaking flag
+    
     state["tts_is_speaking"] = True
 
     if not text.strip():
@@ -368,12 +368,12 @@ def create_and_queue_audio(text, state):
 
             convert_mp3_to_wav(mp3_file, wav_file)
 
-            # Play audio and wait for completion
+            
             play_audio(wav_file, state)
     except Exception as e:
         print(f"Error in TTS process: {e}")
     finally:
-        # Ensure flag is reset even if there's an error
+        
         state["tts_is_speaking"] = False
         state["tts_just_finished"] = True
 
@@ -387,7 +387,7 @@ def create_and_queue_audio(text, state):
 
 def play_audio(filename, state):
     """Play audio with state awareness for TTS/recording coordination"""
-    CHUNK = 4096  # Increased chunk size
+    CHUNK = 4096  
 
     wf = wave.open(filename, "rb")
     p = pyaudio.PyAudio()
@@ -401,8 +401,8 @@ def play_audio(filename, state):
 
     data = wf.readframes(CHUNK)
 
-    # This is blocking until audio is done playing
-    while data and state["running"]:  # Check if system still running
+    
+    while data and state["running"]:  
         stream.write(data)
         data = wf.readframes(CHUNK)
 
@@ -425,32 +425,10 @@ def process_response_chunk(text_chunk):
 
 
 def process_text_for_tts(text):
-    text = re.sub(r"[*<>{}()\[\]&%#@^_=+~]", "", text)
+    text = re.sub(r"[*<>{}()\[\]&%")
     text = text.strip()
     text = re.sub(r"(\w)\.(\w)\.", r"\1 \2 ", text)
     text = re.sub(r"([.!?])(\w)", r"\1 \2", text)
     return text
 
 
-"""
-
-To use this code, you'll need to have the following dependencies installed:
-
-```bash
-pip install numpy torch torchaudio faster-whisper pygame pyaudio gtts ollama
-```
-
-And optionally FFmpeg for audio speed adjustment:
-```bash
-# On Ubuntu/Debian
-sudo apt-get install ffmpeg
-
-# On MacOS with Homebrew
-brew install ffmpeg
-
-# On Windows with Chocolatey
-choco install ffmpeg
-```
-
-
-"""

npcpy/data/image.py

@@ -11,25 +11,25 @@ from PIL import Image
 def _windows_snip_to_file(file_path: str) -> bool:
     """Helper function to trigger Windows snipping and save to file."""
     try:
-        # Import Windows-specific modules only when needed
+        
         import win32clipboard
         from PIL import ImageGrab
         from ctypes import windll
 
-        # Simulate Windows + Shift + S
-        windll.user32.keybd_event(0x5B, 0, 0, 0)  # WIN down
-        windll.user32.keybd_event(0x10, 0, 0, 0)  # SHIFT down
-        windll.user32.keybd_event(0x53, 0, 0, 0)  # S down
-        windll.user32.keybd_event(0x53, 0, 0x0002, 0)  # S up
-        windll.user32.keybd_event(0x10, 0, 0x0002, 0)  # SHIFT up
-        windll.user32.keybd_event(0x5B, 0, 0x0002, 0)  # WIN up
+        
+        windll.user32.keybd_event(0x5B, 0, 0, 0)  
+        windll.user32.keybd_event(0x10, 0, 0, 0)  
+        windll.user32.keybd_event(0x53, 0, 0, 0)  
+        windll.user32.keybd_event(0x53, 0, 0x0002, 0)  
+        windll.user32.keybd_event(0x10, 0, 0x0002, 0)  
+        windll.user32.keybd_event(0x5B, 0, 0x0002, 0)  
 
-        # Wait for user to complete the snip
+        
         print("Please select an area to capture...")
-        time.sleep(1)  # Give a moment for snipping jinx to start
+        time.sleep(1)  
 
-        # Keep checking clipboard for new image
-        max_wait = 30  # Maximum seconds to wait
+        
+        max_wait = 30  
         start_time = time.time()
 
         while time.time() - start_time < max_wait:
@@ -60,7 +60,7 @@ def capture_screenshot( full=False) -> Dict[str, str]:
     Returns:
         A dictionary containing the filename, file path, and model kwargs.
     """
-    # Ensure the directory exists
+    
 
     directory = os.path.expanduser("~/.npcsh/screenshots")
     timestamp = time.strftime("%Y%m%d_%H%M%S")
@@ -71,7 +71,7 @@ def capture_screenshot( full=False) -> Dict[str, str]:
 
 
 
-    #file_path = os.path.join(directory, filename)
+    
 
     system = platform.system()
 
@@ -79,11 +79,11 @@ def capture_screenshot( full=False) -> Dict[str, str]:
 
 
     if full:
-        #print('full')
+        
         if system.lower() == "darwin":
-            #print('mac os screencap')
+            
             subprocess.run(["screencapture", file_path], capture_output=True)
-            #print(f"Full screenshot saved to: {file_path}")
+            
         elif system == "Linux":
             if (
                 subprocess.run(
@@ -102,33 +102,33 @@ def capture_screenshot( full=False) -> Dict[str, str]:
                     time.sleep(0.5)
 
         elif system == "Windows":
-            # For full screen on Windows, we'll use a different approach
+            
             try:
                 import win32gui
                 import win32ui
                 import win32con
                 from PIL import Image
 
-                # Get screen dimensions
+                
                 width = win32api.GetSystemMetrics(win32con.SM_CXVIRTUALSCREEN)
                 height = win32api.GetSystemMetrics(win32con.SM_CYVIRTUALSCREEN)
 
-                # Create device context
+                
                 hdesktop = win32gui.GetDesktopWindow()
                 desktop_dc = win32gui.GetWindowDC(hdesktop)
                 img_dc = win32ui.CreateDCFromHandle(desktop_dc)
                 mem_dc = img_dc.CreateCompatibleDC()
 
-                # Create bitmap
+                
                 screenshot = win32ui.CreateBitmap()
                 screenshot.CreateCompatibleBitmap(img_dc, width, height)
                 mem_dc.SelectObject(screenshot)
                 mem_dc.BitBlt((0, 0), (width, height), img_dc, (0, 0), win32con.SRCCOPY)
 
-                # Save
+                
                 screenshot.SaveBitmapFile(mem_dc, file_path)
 
-                # Cleanup
+                
                 mem_dc.DeleteDC()
                 win32gui.DeleteObject(screenshot.GetHandle())
 
@@ -173,7 +173,7 @@ def capture_screenshot( full=False) -> Dict[str, str]:
             print(f"Unsupported operating system: {system}")
             return None
 
-    # Check if screenshot was successfully saved
+    
     if os.path.exists(file_path):
         print(f"Screenshot saved to: {file_path}")
         return {
@@ -186,24 +186,24 @@ def capture_screenshot( full=False) -> Dict[str, str]:
         return None
 
 def compress_image(image_bytes, max_size=(800, 600)):
-    # Create a copy of the bytes in memory
+    
     buffer = io.BytesIO(image_bytes)
     img = Image.open(buffer)
 
-    # Force loading of image data
+    
     img.load()
 
-    # Convert RGBA to RGB if necessary
+    
     if img.mode == "RGBA":
         background = Image.new("RGB", img.size, (255, 255, 255))
         background.paste(img, mask=img.split()[3])
         img = background
 
-    # Resize if needed
+    
     if img.size[0] > max_size[0] or img.size[1] > max_size[1]:
         img.thumbnail(max_size)
 
-    # Save with minimal compression
+    
     out_buffer = io.BytesIO()
     img.save(out_buffer, format="JPEG", quality=95, optimize=False)
     return out_buffer.getvalue()

npcpy/data/load.py

@@ -112,10 +112,11 @@ extension_map = {
     "GZ": "archives",
 }
 
-def load_file_contents(file_path, chunk_size=250):
+def load_file_contents(file_path, chunk_size=None):
     file_ext = os.path.splitext(file_path)[1].upper().lstrip('.')
     full_content = ""
-    
+    if not isinstance(chunk_size, int):
+        chunk_size=250
     try:
         if file_ext == 'PDF':
             full_content = load_pdf(file_path)
@@ -131,7 +132,7 @@ def load_file_contents(file_path, chunk_size=250):
         elif file_ext in ['XLS', 'XLSX']:
             df = load_excel(file_path)
             full_content = df.to_string()
-        elif file_ext in ['TXT', 'MD']:
+        elif file_ext in ['TXT', 'MD', 'PY', 'JSX', 'TSX', 'TS', 'JS', 'JSON', 'SQL', 'NPC', 'JINX', 'LINE', 'YAML', 'DART', 'JAVA']:
             full_content = load_txt(file_path)
         elif file_ext == 'JSON':
             data = load_json(file_path)

npcpy/data/text.py

@@ -37,70 +37,70 @@ def rag_search(
             )
     results = []
 
-    # Compute the embedding of the query
+    
     query_embedding = embedding_model.encode(
         query, convert_to_tensor=True, show_progress_bar=False
     )
     if isinstance(text_data, str):
-        # split at the sentence level
+        
         lines = text_data.split(".")
         if not lines:
             return results
-        # Compute embeddings for each line
+        
         if text_data_embedded is None:
             line_embeddings = embedding_model.encode(lines, convert_to_tensor=True)
         else:
             line_embeddings = text_data_embedded
-        # Compute cosine similarities
+        
         cosine_scores = util.cos_sim(query_embedding, line_embeddings)[0].cpu().numpy()
 
-        # Find indices of lines above the similarity threshold
+        
         relevant_line_indices = np.where(cosine_scores >= similarity_threshold)[0]
-        # print("relevant_line_indices", cosine_scores)
-        # print(np.mean(cosine_scores))
-        # print(np.max(cosine_scores))
+        
+        
+        
 
         for idx in relevant_line_indices:
             idx = int(idx)
-            # Get context lines (±10 lines)
+            
             start_idx = max(0, idx - 10)
-            end_idx = min(len(lines), idx + 11)  # +11 because end index is exclusive
+            end_idx = min(len(lines), idx + 11)  
             snippet = ". ".join(lines[start_idx:end_idx])
             results.append(snippet)
 
     elif isinstance(text_data, dict):
         for filename, content in text_data.items():
-            # Split content into lines
+            
             lines = content.split("\n")
             if not lines:
                 continue
-            # Compute embeddings for each line
+            
             if text_data_embedded is None:
                 line_embeddings = embedding_model.encode(lines, convert_to_tensor=True)
             else:
                 line_embeddings = text_data_embedded[filename]
-            # Compute cosine similarities
+            
             cosine_scores = (
                 util.cos_sim(query_embedding, line_embeddings)[0].cpu().numpy()
             )
 
-            # Find indices of lines above the similarity threshold
-            ##print("most similar", np.max(cosine_scores))
-            ##print("most similar doc", lines[np.argmax(cosine_scores)])
+            
+            
+            
             relevant_line_indices = np.where(cosine_scores >= similarity_threshold)[0]
-            # print("relevant_line_indices", cosine_scores)
-            # print(np.mean(cosine_scores))
-            # print(np.max(cosine_scores))
+            
+            
+            
             for idx in relevant_line_indices:
-                idx = int(idx)  # Ensure idx is an integer
-                # Get context lines (±10 lines)
+                idx = int(idx)  
+                
                 start_idx = max(0, idx - 10)
                 end_idx = min(
                     len(lines), idx + 11
-                )  # +11 because end index is exclusive
+                )  
                 snippet = "\n".join(lines[start_idx:end_idx])
                 results.append((filename, snippet))
-        # print("results", results)
+        
     return results
 
 
@@ -122,10 +122,10 @@ def load_all_files(
     """
     text_data = {}
     if depth < 1:
-        return text_data  # Reached the specified depth, stop recursion.
+        return text_data  
 
     if extensions is None:
-        # Default to common text file extensions
+        
         extensions = [
             ".txt",
             ".md",
@@ -139,11 +139,11 @@ def load_all_files(
             ".ts",
             ".tsx",
             ".npc",
-            # Add more extensions if needed
+            
         ]
 
     try:
-        # List all entries in the directory
+        
         entries = os.listdir(directory)
     except Exception as e:
         print(f"Could not list directory {directory}: {e}")
@@ -159,7 +159,7 @@ def load_all_files(
                 except Exception as e:
                     print(f"Could not read file {path}: {e}")
         elif os.path.isdir(path):
-            # Recurse into subdirectories, decreasing depth by 1
+            
             subdir_data = load_all_files(path, extensions, depth=depth - 1)
             text_data.update(subdir_data)
 

npcpy/data/video.py

@@ -1,8 +1,8 @@
-# video.py
+
 
 
 def process_video(file_path, table_name):
-    # implement with moon dream
+    
     import cv2
     import base64
 
@@ -18,11 +18,11 @@ def process_video(file_path, table_name):
             if not ret:
                 break
 
-            # Process every nth frame (adjust n as needed for performance)
-            n = 10  # Process every 10th frame
-        #video.release()
+            
+            n = 10  
+        
         return embeddings, texts
 
     except Exception as e:
         print(f"Error processing video: {e}")
-        return [], []  # Return empty lists in case of error
+        return [], []  

npcpy/data/web.py

@@ -1,4 +1,4 @@
-# search.py
+
 
 import requests
 import os
@@ -21,6 +21,25 @@ except:
     pass
 
 
+
+
+
+def search_exa(query:str, 
+               api_key:str = None, 
+               top_k = 5,
+               **kwargs):
+    from exa_py import Exa
+    if api_key is None:
+        api_key = os.environ.get('EXA_API_KEY') 
+    exa = Exa(api_key)
+
+    results = exa.search_and_contents(
+        query, 
+        text=True   
+    )
+    return results.results[0:top_k]
+
+
 def search_perplexity(
     query: str,
     api_key: str = None,
@@ -30,8 +49,11 @@ def search_perplexity(
     top_p: float = 0.9,
 ):
     if api_key is None:
-        api_key = os.environ["PERPLEXITY_API_KEY"]
-    # print("api_key", api_key)
+        api_key = os.environ.get("PERPLEXITY_API_KEY")
+        if api_key is None: 
+            raise 
+        
+    
     url = "https://api.perplexity.ai/chat/completions"
     payload = {
         "model": "sonar",
@@ -52,13 +74,17 @@ def search_perplexity(
         "response_format": None,
     }
 
-    # Headers for the request, including the Authorization bearer token
-    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    
+    headers = {"Authorization": f"Bearer {api_key}", 
+               "Content-Type": "application/json"}
+
+    
+    response = requests.post(url,
+                             json=payload,
+                             headers=headers)
+    
+    response = response.json()
 
-    # Make the POST request to the API
-    response = requests.post(url, json=payload, headers=headers)
-    response = json.loads(response.text)
-    #print(response)
     return [response["choices"][0]["message"]["content"], response["citations"]]
 
 
@@ -88,7 +114,7 @@ def search_web(
 
     if provider == "perplexity":
         search_result = search_perplexity(query, api_key=api_key, **perplexity_kwargs)
-        # print(search_result, type(search_result))
+        
         return search_result
 
     if provider == "duckduckgo":
@@ -108,30 +134,32 @@ def search_web(
             print("DuckDuckGo search failed: ", e)
             urls = []
             results = []
+    elif provider =='exa':
+        return search_exa(query, api_key=api_key, )
 
-    elif provider =='google':  # google
+    elif provider =='google':  
         urls = list(search(query, num_results=num_results))
-        # google shit doesnt seem to be working anymore, apparently a lbock they made on browsers without js?
-        #print("urls", urls)
-        #print(provider)
+        
+        
+        
         for url in urls:
             try:
-                # Fetch the webpage content
+                
                 headers = {
                     "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
                 }
                 response = requests.get(url, headers=headers, timeout=5)
                 response.raise_for_status()
 
-                # Parse with BeautifulSoup
+                
                 soup = BeautifulSoup(response.text, "html.parser")
 
-                # Get title and content
+                
                 title = soup.title.string if soup.title else url
 
-                # Extract text content and clean it up
+                
                 content = " ".join([p.get_text() for p in soup.find_all("p")])
-                content = " ".join(content.split())  # Clean up whitespace
+                content = " ".join(content.split())  
 
                 results.append(
                     {
@@ -147,8 +175,8 @@ def search_web(
                 print(f"Error fetching {url}: {str(e)}")
                 continue
 
-    # except Exception as e:
-    #    print(f"Search error: {str(e)}")
+    
+    
     content_str = "\n".join(
         [r["content"] + "\n Citation: " + r["link"] + "\n\n\n" for r in results]
     )