Update app.py

app.py

@@ -1,144 +1,82 @@
-import torch
-import spaces
-import re
-from transformers import AutoTokenizer, AutoModelForCausalLM
+import sounddevice as sd
+import scipy.io.wavfile as wavfile
+import numpy as np
 import gradio as gr
+from groq import Groq
+import tempfile
 import os
-import logging
-from unsloth import FastLanguageModel
-import subprocess
-loler=gr.SimpleCSVLogger()
-# Set up logging to file
-log_file_path = "app.log"  # Name of your log file
-logging.basicConfig(
-    filename=log_file_path, 
-    level=logging.DEBUG,  
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-)
-logger = logging.getLogger(__name__)
 
-# Get environment variable for Hugging Face access
-READ_HF = os.environ.get("read_hf")
-# Alpaca prompt template
-alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
-
-### Instruction:
-{}
-
-### Input:
-{}
-
-### Response:
-{}"""
-
-# Inventory management instructions
-string = '''
-You are an AI assistant tasked with managing inventory based on user instructions. You must meticulously analyze each user request to determine the appropriate action and execute it with the correct parameters.
-
-**Here's your step-by-step thought process:**
-
-1. **Identify the Function:** Carefully examine the user's input to determine the primary function they want to perform.  The available functions are:
-    - `transaction`: Record a new item transaction.
-    - `last n days transactions`: Retrieve transaction records within a specific timeframe.
-    - `view inventory`: View inventory details for a specific category and risk level.
-    - `generate report`: Generate an inventory report.
-
-2. **Extract Parameters:** Once you've identified the function, carefully extract the necessary parameters from the user's input. Each function requires specific parameters:
-
-    **`transaction`:**
-        - `ItemName`: (string) **Must be an exact match from the provided Item List.**
-        - `ItemQt`: (integer) The quantity of the item.
-        - `Type`: (string) "sale", "purchase", or "return".
-
-    **`last n days transactions`:**
-        - `ItemCategory`: (string) **Must be from the provided Item Category List.**
-        - `Duration`: (integer) Number of days (convert weeks, months, years to days).
-
-    **`view inventory`:**
-        - `ItemCategory`: (string) **Must be from the provided Item Category List.**
-        - `RiskType`: (string) "overstock", "understock", or "Null" (if risk inventory is not asked), or "All" for both overstock and understock.
-
-    **`generate report`:**
-        - `ItemCategory`: (string) **Must be from the provided Item Category List.**
-        - `Duration`: (integer) Number of days (convert weeks, months, years to days).
-        - `ReportType`: (string):  "profit", "revenue", "inventory", or "Null" (for all reports).
-
-3. **Validate Inputs:** Before proceeding, validate the extracted parameters:
-
-    - **ItemName:**  Ensure the `ItemName` is an exact match from the provided Item List.
-    - **ItemCategory:** Ensure the `ItemCategory` is from the provided Category List.
-    - **Data Types:** Verify that all parameters are of the correct data type (string or integer).
-
-4. **Output in JSON:** Always format your response as a JSON object.
-
-**Additional Notes:**
-- Pay close attention to the case and spelling of function names and parameters.
-
-Category List : ["Dairy & Eggs", "Beverages & Snacks", "Cleaning & Hygiene", "Grains & Staples", "Personal Care", "Other"]
-'''
-from unsloth import FastLanguageModel
-@spaces.GPU()
-def chunk_it(inventory_list, user_input_text):
-    # Check for CUDA and NVIDIA-related errors
-    try:
-        # Check for GPU devices
-        device_count = torch.cuda.device_count()
-        logger.info(f"Number of GPU devices: {device_count}")
-        if device_count == 0:
-            raise RuntimeError("No GPU devices found.") 
-
-        # Check CUDA version using subprocess
-        process = subprocess.run(['nvcc', '--version'], capture_output=True, text=True)
-        cuda_version = process.stdout.strip()
-        logger.info(f"CUDA version: {cuda_version}")
-        if 'not found' in cuda_version.lower():
-            raise RuntimeError("CUDA not found.")  
-
-        # Load model and tokenizer 
-        model, tokenizer = FastLanguageModel.from_pretrained(
-            model_name = "VanguardAI/CoT_multi_llama_LoRA_4bit",
-            max_seq_length = 2048,
-            dtype = torch.bfloat16,
-            load_in_4bit = True,
-            token = READ_HF    
-        )
-        logger.info("Model and tokenizer loaded.")
-
-        # Format the prompt
-        formatted_prompt = alpaca_prompt.format(
-            string + inventory_list,  
-            user_input_text,  
-            "",  
-        )
-        logger.debug(f"Formatted prompt: {formatted_prompt}")
-
-        # Tokenize the input
-        inputs = tokenizer([formatted_prompt], return_tensors="pt").to("cuda")
-        logger.debug(f"Tokenized inputs: {inputs}")
-
-        # Generate output
-        outputs = model.generate(**inputs, max_new_tokens=216, use_cache=True)
-        logger.info("Output generated.")
-
-        # Decode output
-        reply = tokenizer.batch_decode(outputs, skip_special_tokens=True)
-        logger.debug(f"Decoded output: {reply}")
-
-        logger.debug(f"Final reply: {reply}")
-        return reply
-
-    except Exception as e:
-        logger.error(f"Error loading model or CUDA issues: {e}")
-        return "There seems to be an issue with CUDA or the model. Please check the Hugging Face Spaces environment."
-
-# Interface for inputs
-iface = gr.Interface(
-    fn=chunk_it,
-    inputs=[
-        gr.Textbox(label="user_input_text", lines=3),
-        gr.Textbox(label="inventory_list", lines=5)
-    ],
-    outputs=gr.Textbox(label="output", lines=23),
-    title="Testing",
-    flagging_callback=SimpleCSVLogger()
-)
+class Recorder:
+    def __init__(self, sample_rate=44100):
+        self.recording = False
+        self.frames = []
+        self.sample_rate = sample_rate
+        self.stream = None
+
+    def toggle_recording(self):
+        if not self.recording:
+            self.frames = []
+            self.stream = sd.InputStream(callback=self.callback, channels=2, samplerate=self.sample_rate)
+            self.stream.start()
+            self.recording = True
+            return "Recording... Press to Stop"
+        else:
+            self.stream.stop()
+            self.stream.close()
+            self.recording = False
+            return "Recording stopped. Press to Record"
+
+    def callback(self, indata, frames, time, status):
+        if self.recording:
+            self.frames.append(indata.copy())
+
+    def save_audio(self):
+        if self.frames:
+            audio_data = np.concatenate(self.frames, axis=0)
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_wav_file:
+                wavfile.write(temp_wav_file.name, self.sample_rate, audio_data)
+                return temp_wav_file.name
+        else:
+            return None
+
+recorder = Recorder()
+
+def record():
+    return recorder.toggle_recording()
+
+def transcribe():
+    audio_file = recorder.save_audio()
+    if audio_file:
+        client = Groq(api_key="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")
+        with open(audio_file, "rb") as file:
+            transcription = client.audio.transcriptions.create(
+                file=(audio_file, file.read()),
+                model="whisper-large-v3",
+                prompt="Specify context or spelling",  # Optional
+                response_format="json",  # Optional
+                language="en",  # Optional
+                temperature=0.0  # Optional
+            )
+        os.remove(audio_file)  # Clean up the temporary file
+
+        # Inspect the transcription object to find the text
+        print(transcription)
+        
+        # Access the text attribute directly if available
+        if hasattr(transcription, 'text'):
+            return transcription.text
+        else:
+            return "Transcription text not found."
+
+    else:
+        return "No audio recorded."
+
+with gr.Blocks() as gradio_interface:
+    with gr.Column():
+        record_button = gr.Button("Press to Record")
+        record_button.click(fn=record, outputs=record_button)
+        transcription_output = gr.Textbox(label="Transcription")
+        record_button.click(fn=transcribe, outputs=transcription_output)
+
+if __name__ == "__main__":
+    gradio_interface.launch()