Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,36 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/PIL/.dylibs/libfreetype.6.dylib filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/PIL/.dylibs/libharfbuzz.0.dylib filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/PIL/.dylibs/libtiff.6.dylib filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/PIL/_imaging.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/altair/vegalite/v5/schema/__pycache__/core.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/functorch/.dylibs/libiomp5.dylib filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/gradio/frpc_darwin_amd64_v0.2 filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/gradio/templates/cdn/assets/index-106fe5c7.js.map filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/gradio/templates/frontend/assets/index-d3860fd7.js.map filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/grpc/_cython/cygrpc.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/llvmlite/binding/libllvmlite.dylib filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/numpy/.dylibs/libgfortran.5.dylib filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/numpy/.dylibs/libopenblas64_.0.dylib filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/numpy/core/_multiarray_umath.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/numpy/core/_simd.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/objc/_objc.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/pandas/_libs/algos.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/pandas/_libs/groupby.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/pandas/_libs/hashtable.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/pandas/_libs/interval.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/pandas/_libs/join.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/pydantic_core/_pydantic_core.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/speech_recognition/flac-linux-x86 filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/speech_recognition/flac-linux-x86_64 filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/speech_recognition/pocketsphinx-data/en-US/acoustic-model/mdef filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/speech_recognition/pocketsphinx-data/en-US/acoustic-model/sendump filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/sympy/polys/benchmarks/__pycache__/bench_solvers.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/tiktoken/_tiktoken.cpython-311-darwin.so filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/torch/bin/protoc filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/torch/bin/protoc-3.13.0.0 filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/torch/lib/libiomp5.dylib filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/torch/lib/libtorch_cpu.dylib filter=lfs diff=lfs merge=lfs -text
+transcriber/lib/python3.11/site-packages/torch/lib/libtorch_python.dylib filter=lfs diff=lfs merge=lfs -text

GUI/GUI.py

@@ -0,0 +1,63 @@
+import tkinter as tk 
+import pyaudio
+import wave
+
+# Voice recording params
+CHUNK = 1024 
+FORMAT = pyaudio.paInt16 
+CHANNELS = 1
+RATE = 44100  
+RECORD_SECONDS = 5
+WAVE_OUTPUT_FILENAME = "output.wav"
+
+root = tk.Tk()
+root.geometry("400x300")
+
+# Audio funcs
+def start_record():
+  
+  print('Recording')
+  global recorder  
+  recorder = pyaudio.PyAudio()
+
+  global stream 
+  stream = recorder.open(format=FORMAT, 
+                         channels=CHANNELS,
+                         rate=RATE, 
+                         input=True,
+                         frames_per_buffer=CHUNK)
+
+  global frames
+  frames = []
+
+  # from stream get audio data
+  audio_generator = stream.read(CHUNK)
+
+
+  stream.start_stream()
+
+button = tk.Button(root, text="Record", font=("Arial", 32), padx=50, pady=20, command=start_record) 
+button.pack()
+
+def stop_record():
+
+  print('Stopping')
+  stream.stop_stream()
+  stream.close()
+  recorder.terminate()
+
+  waveFile = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
+  waveFile.setnchannels(CHANNELS)
+  waveFile.setsampwidth(recorder.get_sample_size(FORMAT))
+  waveFile.setframerate(RATE)
+  waveFile.writeframes(b''.join(frames))
+  waveFile.close()
+
+def callback(in_data, frame_count, time_info, status):
+  frames.append(in_data)
+  return in_data, pyaudio.paContinue
+
+button = tk.Button(root, text="Stop", font=("Arial", 32), padx=50, pady=20, command=stop_record)
+button.pack()
+
+root.mainloop()

GUI/basicGUI.py

@@ -0,0 +1,14 @@
+import tkinter as tk
+
+root = tk.Tk()
+root.title("My GUI App") 
+
+button = tk.Button(root, text="Click Me!")
+button.pack()
+
+def on_button_click():
+    print("Button was clicked!")
+
+button.config(command=on_button_click)
+
+root.mainloop()

GUI/initial-test.py

@@ -0,0 +1,67 @@
+import pyaudio
+import wave
+import tkinter as tk
+from tkinter import Button, Label
+
+CHUNK = 1024 
+FORMAT = pyaudio.paInt16 #paInt8
+CHANNELS = 1 
+RATE = 44100 #sample rate
+RECORD_SECONDS = 5
+WAVE_OUTPUT_FILENAME = "output.wav"
+
+p = pyaudio.PyAudio()
+
+stream = p.open(format=FORMAT,
+                channels=CHANNELS,
+                rate=RATE,
+                input=True,
+                frames_per_buffer=CHUNK) #buffer
+
+frames = []
+
+root = tk.Tk()
+root.title("Voice Recorder")
+
+label = Label(root, text="Press button to start recording")
+label.pack()
+
+def start_record():
+    global frames
+    frames = []
+    label.config(text="Recording...")
+    stream.start_stream()
+
+def stop_record():
+    label.config(text="Recording stopped")
+    stream.stop_stream()
+    wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
+    wf.setnchannels(CHANNELS)
+    wf.setsampwidth(p.get_sample_size(FORMAT))
+    wf.setframerate(RATE)
+    wf.writeframes(b''.join(frames))
+    wf.close()
+
+record_button = Button(root, text="Record", command=start_record)
+record_button.pack()
+
+stop_button = Button(root, text="Stop", command=stop_record)  
+stop_button.pack()
+
+def callback(in_data, frame_count, time_info, status):
+    frames.append(in_data)
+    return (in_data, pyaudio.paContinue)
+
+stream.start_stream()
+
+try:
+    while stream.is_active():
+        stream.write(callback(in_data, frame_count, time_info, status))
+except KeyboardInterrupt:
+    pass
+
+stream.stop_stream()
+stream.close()
+p.terminate()
+
+root.mainloop()

GUI/real-time.py

@@ -0,0 +1,40 @@
+import whisper
+import pyaudio
+import tkinter as tk
+
+# PyAudio config 
+CHUNK = 1024
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 44100
+
+# Create GUI
+root = tk.Tk()
+text_box = tk.Text(root)
+text_box.pack()
+
+# Load Whisper 
+model = whisper.load_model("base")
+
+# Start audio stream
+p = pyaudio.PyAudio()
+stream = p.open(format=FORMAT, 
+                channels=CHANNELS, 
+                rate=RATE, 
+                input=True,
+                frames_per_buffer=CHUNK)
+
+# Listen to mic in a loop
+while True:
+    data = stream.read(CHUNK)
+    text = model.transcribe(data)['text']
+    
+    # Insert into GUI
+    text_box.insert('end', text)
+    text_box.see('end')
+    
+    root.update()
+
+stream.stop_stream()
+stream.close()
+p.terminate()

README

@@ -0,0 +1,12 @@
+gcloud auth application-default login
+gcloud auth login
+gcloud components update
+gcloud config set project intense-base-386112
+
+export GOOGLE_APPLICATION_CREDENTIALS="/Users/harshpatel/Downloads/intense-base-386112-44f12a13694e.json"
+
+MAKE SURE TO SPECIFY RECORD_SECONDS, remove comment and print statements, and add api key
+
+Remaining - actually configure recording time with keystroke, and try whisper model
+
+Keep laptop open for clear mic

README.md

@@ -1,12 +1,12 @@
 ---
-title: Transcriber Prompt
-emoji: 🐠
-colorFrom: red
-colorTo: purple
+title: transcriber-prompt
+app_file: app_gradio.py
 sdk: gradio
 sdk_version: 3.40.1
-app_file: app.py
-pinned: false
 ---
+- Run final_runner.py : Specify RECORD_SECONDS. And uncomment out openai chat code 
+- During the actual run, remove the printed text of the transcription
+- Use bardapi code as another option
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+TODO:
+- But in a --help option, and also programmatically be able to use whisper, googlespeech, bard, and chatgpt

ai.py

@@ -0,0 +1,57 @@
+import pyaudio
+import wave
+from pynput import keyboard
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 44100
+CHUNK = 1024
+#RECORD_SECONDS = 5
+WAVE_OUTPUT_FILENAME = "test.wav"
+
+frames = []
+
+def on_press(key):
+    global frames
+
+    if key == keyboard.Key.esc:
+        # Stop recording
+        audio = pyaudio.PyAudio()
+        stream = audio.open(format=FORMAT, channels=CHANNELS,
+                            rate=RATE, input=True,
+                            frames_per_buffer=CHUNK)
+        stream.stop_stream()
+        stream.close()
+        audio.terminate()
+        print("Finished recording audio.")
+        # Save recorded audio data to a .wav file
+        wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
+        wf.setnchannels(CHANNELS)
+        wf.setsampwidth(audio.get_sample_size(FORMAT))
+        wf.setframerate(RATE)
+        wf.writeframes(b''.join(frames))
+        wf.close()
+        # Stop the listener
+        return False
+
+    elif key.char == 'a':
+        # Start recording
+        audio = pyaudio.PyAudio()
+        stream = audio.open(format=FORMAT, channels=CHANNELS,
+                            rate=RATE, input=True,
+                            frames_per_buffer=CHUNK)
+        print("Recording audio...")
+        while True:
+            data = stream.read(CHUNK)
+            frames.append(data)
+            if keyboard.Controller().pressed(keyboard.Key.esc):
+                print("esc key press here")
+                break
+        stream.stop_stream()
+        stream.close()
+        audio.terminate()
+
+# Start the listener
+with keyboard.Listener(on_press=on_press) as listener:
+    listener.join()
+

answerPalm.py

@@ -0,0 +1,39 @@
+import pprint
+import google.generativeai as palm
+
+palm.configure(api_key='AIzaSyCLy2IgNwMBDbhYH_zvUDo0AMWQdRLQI0E')
+
+prompt = input("Ask: ")
+#prompt = """
+#You are an expert at solving coding interview problems in Python.
+#Describe how you arrived at the most optimal solution.
+#Break the question down into manageable segments.
+#Think about it step by step, and show your work.
+#Say yes and ask for problem when ready.
+#"""
+#Here is the problem:
+
+completion = palm.generate_text(
+    model='models/text-bison-001',
+    prompt=prompt,
+    temperature=0,
+    # The maximum length of the response
+    max_output_tokens=800,
+).result
+
+print(completion)
+breakpoint()
+prompt += ' ' + completion
+
+while True:
+    ask = input("Ask: ")
+    prompt += ' ' + ask
+    answer = palm.generate_text(
+        model='models/text-bison-001',
+        prompt=prompt,
+        temperature=0,
+        # The maximum length of the response
+        max_output_tokens=800,
+    ).result
+    print(answer)
+    prompt += ' ' + answer

app_gradio.py

@@ -0,0 +1,47 @@
+import whisper
+import gradio as gr
+import time
+import google.generativeai as palm
+palm.configure(api_key='AIzaSyCLy2IgNwMBDbhYH_zvUDo0AMWQdRLQI0E')
+model = whisper.load_model("base")
+print(model.device)
+
+def transcribe(audio):
+    #time.sleep(3)
+    # load audio and pad/trim it to fit 30 seconds
+    audio = whisper.load_audio(audio)
+    audio = whisper.pad_or_trim(audio)
+
+    # make log-Mel spectrogram and move to the same device as the model
+    mel = whisper.log_mel_spectrogram(audio).to(model.device)
+
+    # # detect the spoken language
+    # _, probs = model.detect_language(mel)
+    # print(f"Detected language: {max(probs, key=probs.get)}")
+
+    # decode the audio
+    # options = whisper.DecodingOptions()
+    # for cpu
+    options = whisper.DecodingOptions(fp16=False)
+    result = whisper.decode(model, mel, options)
+
+    print(result.text)
+    completion = palm.generate_text(
+        model='models/text-bison-001',
+        prompt=result.text,
+        temperature=0,
+        # The maximum length of the response
+        max_output_tokens=500,
+    ).result
+    return completion
+
+gr.Interface(
+    title = 'Real-time AI-based Audio Transcription, Recognition, Answerer Web App',
+    fn=transcribe,
+    inputs=[
+        gr.inputs.Audio(source="microphone", type="filepath")
+    ],
+    outputs=[
+        "textbox"
+    ],
+    live=True).launch(share=True)

bardrun.py

@@ -0,0 +1,19 @@
+from bardapi import Bard
+
+#initialize via F12 → Application → Cookies → Copy the value of __Secure-1PSID cookie.
+token = 'YAjsmzQTZ54vCho1kl9GG5MbJgVVCsUoF0cnVfuSHVqb1BMnrIzVEyV9YYZvxNbzhrJNDQ.'
+bard = Bard(token=token)
+
+# Setup state
+context = "You are a super helpful tutor and excellent interviewee. In general you explain your thought process and concepts very well. You first explain simple brute force solutions to interview problem (no need to code) but still go over the time and space complexity, then you explain the steps leading you to the most optimized solution.  You finally explain the concepts and procedures of this optimized solution step by step and then you MUST provide the final code in python with its time and space complexity."
+bard.get_answer(context)
+prompt = input('You: ')
+print()
+
+# Continue chat 
+while len(prompt) != 0:
+    print(f"Bard: {bard.get_answer(prompt)['content']}\n")
+    prompt = input('You: ')
+    print()
+
+

chat.py

@@ -0,0 +1,49 @@
+import openai
+openai.api_key = "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"
+
+# def generate_text(prompt, model, temperature=0.5, max_tokens=1024):
+#     """
+#     Generates text using the OpenAI API.
+#     :param prompt: The prompt for the text generation.
+#     :param model: The ID of the OpenAI model to use.
+#     :param temperature: The temperature of the text generation. (default: 0.5)
+#     :param max_tokens: The maximum number of tokens to generate. (default: 1024)
+#     :return: The generated text.
+#     """
+#     response = openai.Completion.create(
+#         engine=model,
+#         prompt=prompt,
+#         temperature=temperature,
+#         max_tokens=max_tokens
+#     )
+#     return response.choices[0].text.strip()
+
+
+# print(generate_text("hello, there", "gpt-3.5-turbo"))
+
+def update_chat(messages, content):
+    messages.append({"role": "user", "content": content})
+    return messages
+
+
+# Clarifying questions - feel free to ask them but also 
+messages = [
+    {"role": "system", "content": "You are a super helpful tutor and excellent interviewee. In general you explain your thought process and concepts very well. You first explain simple brute force solutions to interview problem (no need to code) but still go over the time and space complexity, then you explain the steps leading you to the most optimized solution.  You explain the concepts and procedures of this optimized solution and then you MUST provide the final code in python with its time and space complexity. "}
+]
+text = "Find the median of two sorted arrays"
+print('here')
+response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=update_chat(messages, text))
+print(response['choices'][0]['message']['content'])
+
+
+#gpt-3.5-turbo
+
+#pre_prompt = "I am writing a letter to my friend. Here is what I want to say:"
+              
+# update_chat messages.append({role, content}) return messages
+
+#
+
+
+# Interview prompt
+# You are a super helpful tutor and excellent interviewee. You explain brute force solutions to interview problems first (no need to code) but still go over the time and space complexity, then the steps leading you to the most optimized version.  You explain the concepts and procedures of this optimized version and then provide the final code in python with its time and space complexity. Say yes if you are ready

explainSoln.py

@@ -0,0 +1,35 @@
+import pprint
+import google.generativeai as palm
+palm.configure(api_key='AIzaSyCLy2IgNwMBDbhYH_zvUDo0AMWQdRLQI0E')
+
+
+prompt = """
+You are an expert at explaining coding interview solutions in Python.
+
+Explain the following solution:
+
+```
+def coinChange(self, coins: List[int], amount: int) -> int:
+    dp = [amount + 1] * (amount + 1)
+    dp[0] = 0
+
+    for a in range(1, amount + 1):
+        for c in coins:
+            if a - c >= 0:
+                dp[a] = min(dp[a], 1 + dp[a - c])
+    return dp[amount] if dp[amount] != amount + 1 else -1
+```
+
+Think about it step by step, and show your work.
+Afterwards, run through an example input.
+"""
+
+completion = palm.generate_text(
+    model='models/text-bison-001',
+    prompt=prompt,
+    temperature=0,
+    # The maximum length of the response
+    max_output_tokens=1200,
+)
+
+print(completion.result)

final_runner.py

@@ -0,0 +1,152 @@
+# USAGE keep using , (to prompt the bot via voice and keep adding on layers to message content for chat completion), 
+# after successful run through backtick is the exit, early stop after instructions have been fulfilled
+
+#TODO: Automatically stop when to recording using keystroke, Whisper? model
+# MAKE SURE TO SPECIFY RECORD_SECONDS, remove comment and print statements, and add api key
+
+import os
+import pyaudio
+import wave
+from pynput import keyboard
+import speech_recognition as sr
+import time
+import openai 
+from bardapi import Bard
+import google.generativeai as palm
+openai.api_key = "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"
+#bard = Bard(token='XAjsm7r2qks6TRYvnuR7nbMlAHeJRSd4DHZIhvQ5NdHjgcTOYngb2GN2juVCNZSLwkeDuQ.')
+palm.configure(api_key='AIzaSyCLy2IgNwMBDbhYH_zvUDo0AMWQdRLQI0E')
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 2
+RATE = 44100
+CHUNK = 1024
+RECORD_SECONDS = 4                ##HERE##
+#WAVE_OUTPUT_FILENAME = "2.wav"
+
+frames = []
+
+def update_chat(messages, content):
+    messages.append({"role": "user", "content": content})
+    return messages
+
+# messages = [
+    # # include in step - by - step more (0-shot)
+    # {"role": "system", "content": "You are a super helpful tutor and excellent interviewee. In general you explain your thought process and concepts very well. You first explain simple brute force solutions to interview problem (no need to code) but still go over the time and space complexity, then you explain the steps leading you to the most optimized solution.  You explain the concepts and procedures of this optimized solution step by step and then you MUST provide the final code in python with its time and space complexity."}
+# ]
+messages = [
+    # include in step - by - step more (0-shot)
+    {"role": "system", "content": "You are a super helpful tutor and excellent interviewee. In general you explain your thought process and concepts very well. You first explain simple brute force solutions to system design interview problem, then make appropriate assumptions and explain the steps leading you to the most optimized solution. Provide functional and non-functional requirements, back of the envelope calculation, apis needed, data/databases if needed, and a high level scalable design.  You MUST explain the concepts and procedures of this optimized solution step by step while providing the system design architecture"}
+]
+global bard_context
+bard_context = [messages[0]['content']]
+
+def update_bard(messages, content):
+    msg = ': '.join(messages) + content
+    ans = bard.get_answer(msg)['content']
+    messages.append(ans)
+    return messages, ans
+
+global palm_context
+palm_context = [messages[0]['content']]
+
+def update_palm(messages, content):
+    msg = ': '.join(messages) + ': ' + content
+    ans = palm.generate_text(
+        model='models/text-bison-001',
+        prompt=msg,
+        temperature=0,
+        # The maximum length of the response
+        max_output_tokens=2000,
+    ).result
+    messages.append(ans)
+    return messages, ans
+
+    #Line to add: [Let's think step by step.]
+
+def on_press(key):
+    
+    if key == keyboard.KeyCode.from_char('$'):
+        # Start recording
+        print("Ready...", end=" ")
+        global stream, audio
+        audio = pyaudio.PyAudio()
+        print("Recording audio...")
+        stream = audio.open(format=FORMAT, channels=CHANNELS,
+                            rate=RATE, input=True,
+                            frames_per_buffer=CHUNK,
+                            input_device_index=2) # when brio is connected use mac
+        for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
+            data = stream.read(CHUNK)
+            frames.append(data)
+
+        # Stop recording
+        stream.stop_stream()
+        stream.close()
+        audio.terminate()
+        print("Finished recording audio.")
+        r = sr.Recognizer()
+        audio_data = sr.AudioData(b''.join(frames), RATE, 2)
+        #print(audio_data) 
+        text = r.recognize_google(audio_data)
+        #text = r.recognize_google(audio_data, language = 'en-US', show_all = True)
+        print(text) # REMOVE THIS DURING ACTUAL
+        print("Finished transcription")
+        # TODO: Once audio is fully done then send to gpt to answer via another keystroke.
+        # app currently keeps appending to transcription with each comma...
+        
+        #response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=update_chat(messages, text))
+        #os.system('clear')
+        #print(response['choices'][0]['message']['content'])
+        #global bard_context
+        #bard_context, response = update_bard(bard_context, text)
+        global palm_context
+        palm_context, response = update_palm(palm_context, text)
+        os.system('clear')
+        print(response)
+
+    elif key == keyboard.KeyCode.from_char('`'):
+        print("Exiting")
+        return False
+        
+    elif key == keyboard.KeyCode.from_char('|'):
+        text = input()
+        print("Completing")
+        #response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=update_chat(messages, text))
+        #print(response['choices'][0]['message']['content'])
+        #bard_context, response = update_bard(bard_context, text)
+        palm_context, response = update_palm(palm_context, text)
+        print(response)
+
+
+    
+def on_release(key):
+    if key == keyboard.KeyCode.from_char('`'): # UNTESTED CODE
+        return False
+
+# Start the listener
+with keyboard.Listener(on_press=on_press) as listener:
+    listener.join()
+
+
+
+
+# from bardapi import Bard
+# 
+# #initialize via F12 Application → Cookies → Copy the value of __Secure-1PSID cookie.
+# token = 'XAjsm7r2qks6TRYvnuR7nbMlAHeJRSd4DHZIhvQ5NdHjgcTOYngb2GN2juVCNZSLwkeDuQ.'
+# bard = Bard(token=token)
+# 
+# # Setup state
+# context = "You are a super helpful tutor and excellent interviewee. In general you explain your thought process and concepts very well. You first explain simple brute force solutions to interview problem (no need to code) but still go over the time and space complexity, then you explain the steps leading you to the most optimized solution.  You finally explain the concepts and procedures of this optimized solution step by step and then you MUST provide the final code in python with its time and space complexity."
+# bard.get_answer(context)
+# prompt = input('You: ')
+# print()
+# 
+# # Continue chat 
+# while len(prompt) != 0:
+#     print(f"Bard: {bard.get_answer(prompt)['content']}\n")
+#     prompt = input('You: ')
+#     print()
+# 
+# 

gtest.py

@@ -0,0 +1,29 @@
+import io
+import os
+
+# Imports the Google Cloud client library
+from google.cloud import speech
+
+# Instantiates a client
+client = speech.SpeechClient()
+
+# The name of the audio file to transcribe
+file_name = os.path.join(os.path.dirname(__file__), '2.wav')
+
+# Loads the audio into memory
+with io.open(file_name, 'rb') as audio_file:
+    content = audio_file.read()
+    audio = speech.RecognitionAudio(content=content)
+
+# Specifies the audio encoding and language
+config = speech.RecognitionConfig(
+    encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
+    language_code='en-US')
+
+# Detects speech in the audio file
+response = client.recognize(config=config, audio=audio)
+
+# Prints the transcription of the audio
+for result in response.results:
+    print('Transcript: {}'.format(result.alternatives[0].transcript))
+

gtrans.py

@@ -0,0 +1,36 @@
+def transcribe_file(speech_file):
+    """Transcribe the given audio file asynchronously."""
+    from google.cloud import speech
+
+    client = speech.SpeechClient()
+
+    with open(speech_file, "rb") as audio_file:
+        content = audio_file.read()
+
+    """
+     Note that transcription is limited to a 60 seconds audio file.
+     Use a GCS file for audio longer than 1 minute.
+    """
+    audio = speech.RecognitionAudio(content=content)
+
+    config = speech.RecognitionConfig(
+        encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
+        sample_rate_hertz=16000,
+        language_code="en-US",
+    )
+
+
+    operation = client.long_running_recognize(config=config, audio=audio)
+
+    print("Waiting for operation to complete...")
+    response = operation.result(timeout=90)
+
+    # Each result is for a consecutive portion of the audio. Iterate through
+    # them to get the transcripts for the entire audio file.
+    for result in response.results:
+        # The first alternative is the most likely one for this portion.
+        print("Transcript: {}".format(result.alternatives[0].transcript))
+        print("Confidence: {}".format(result.alternatives[0].confidence))
+
+
+transcribe_file('2.wav')

keypress.py

@@ -0,0 +1,47 @@
+import pyaudio
+from pynput import keyboard
+import wave
+
+# Define constants for PyAudio
+CHUNK = 1024
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 44100
+
+# Define the on_press function
+def on_press(key):
+    print("Key pressed: ", key)
+    if key == keyboard.Key.esc:
+        return False
+    print(type(key))
+    print(str(key))
+    if str(key) == 'a':
+        print('here')
+        audio = pyaudio.PyAudio()
+        stream = audio.open(format=FORMAT, channels=CHANNELS,
+                            rate=RATE, input=True,
+                            frames_per_buffer=CHUNK)
+        print("Recording audio...")
+        frames = []
+        while True:
+            data = stream.read(CHUNK)
+            frames.append(data)
+            if not keyboard.is_pressed('a'):
+                break
+            if not listener.running:
+                break
+        stream.stop_stream()
+        stream.close()
+        audio.terminate()
+        print("Finished recording audio.")
+        # Save recorded audio data to a .wav file
+        wf = wave.open("recorded_audio.wav", 'wb')
+        wf.setnchannels(CHANNELS)
+        wf.setsampwidth(audio.get_sample_size(FORMAT))
+        wf.setframerate(RATE)
+        wf.writeframes(b''.join(frames))
+        wf.close()
+
+# Start the listener
+with keyboard.Listener(on_press=on_press) as listener:
+    listener.join()

keypress.py-2

@@ -0,0 +1,60 @@
+import pyaudio
+import numpy as np
+from pynput import keyboard
+import wave
+
+def record_on_keypress(keycode, chunk=1024, rate=44100):
+    """
+    Records audio from the default microphone when a key is pressed and stops when the key is released.
+    :param keycode: The keycode of the key that triggers the recording.
+    :param chunk: The number of audio frames per buffer. (default: 1024)
+    :param rate: The sampling rate of the audio. (default: 44100)
+    :return: A PyAudio stream object and a NumPy array of the recorded audio.
+    """
+
+    def on_press(key):
+        if key == keycode:
+            # start recording
+            print("start recording")
+            frames = []
+            while True:
+                data = stream.read(chunk)
+                frames.append(data)
+                if listener.current_key != keycode:
+                    break
+
+            # convert frames to NumPy array
+            audio = np.frombuffer(b''.join(frames), dtype=np.int16)
+
+            # stop listener and 'return audio
+            listener.stop()
+            print(audio)
+            return stream, audio
+
+    p = pyaudio.PyAudio()
+    stream = p.open(format=pyaudio.paInt16,
+                    channels=1,
+                    rate=rate,
+                    input=True,
+                    frames_per_buffer=chunk)
+
+    print("listener starting recording")
+    breakpoint()
+    stream.start_stream()
+    with keyboard.Listener(on_press=on_press) as listener:
+        listener.join()
+    print("end recording")
+
+    # stop recording and close stream
+    stream.stop_stream()
+    stream.close()
+    p.terminate()
+
+    wf = wave.open("output.wav", 'wb')
+    wf.setnchannels(2)
+    wf.setsampwidth(p.get_sample_size(pyaudio.paInt16))
+    wf.setframerate(44100)
+    wf.writeframes(b''.join(frames))
+    wf.close()
+
+print(record_on_keypress('+'))

monitor.py

@@ -0,0 +1,28 @@
+from pynput import keyboard
+
+def on_press(key):
+    try:
+        print('alphanumeric key {0} pressed'.format(
+            key.char))
+    except AttributeError:
+        print('special key {0} pressed'.format(
+            key))
+
+def on_release(key):
+    print('{0} released'.format(
+        key))
+    if key == keyboard.Key.esc:
+        # Stop listener
+        return False
+
+# Collect events until released
+with keyboard.Listener(
+        on_press=on_press,
+        on_release=on_release) as listener:
+    listener.join()
+
+#key.__str__# ...or, in a non-blocking fashion:
+#listener = keyboard.Listener(
+#    on_press=on_press,
+#    on_release=on_release)
+#listener.start()

palmapikey

@@ -0,0 +1 @@
+AIzaSyCLy2IgNwMBDbhYH_zvUDo0AMWQdRLQI0E

play.py

@@ -0,0 +1,35 @@
+import pyaudio
+import wave
+import sys
+
+CHUNK = 1024
+
+if len(sys.argv) < 2:
+    print("Plays a wave file.\n\nUsage: %s filename.wav" % sys.argv[0])
+    sys.exit(-1)
+
+wf = wave.open(sys.argv[1], 'rb')
+
+# instantiate PyAudio (1)
+p = pyaudio.PyAudio()
+
+# open stream (2)
+stream = p.open(format=p.get_format_from_width(wf.getsampwidth()),
+                channels=wf.getnchannels(),
+                rate=wf.getframerate(),
+                output=True)
+
+# read data
+data = wf.readframes(CHUNK)
+
+# play stream (3)
+while len(data) > 0:
+    stream.write(data)
+    data = wf.readframes(CHUNK)
+
+# stop stream (4)
+stream.stop_stream()
+stream.close()
+
+# close PyAudio (5)
+p.terminate()

recorder.py

@@ -0,0 +1,39 @@
+import pyaudio
+import wave
+
+CHUNK = 1024
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 44100
+RECORD_SECONDS = 5
+WAVE_OUTPUT_FILENAME = "output.wav"
+
+p = pyaudio.PyAudio()
+
+stream = p.open(format=FORMAT,
+                channels=CHANNELS,
+                rate=RATE,
+                input=True,
+                frames_per_buffer=CHUNK)
+
+print("* recording")
+
+frames = []
+
+for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
+    data = stream.read(CHUNK)
+    frames.append(data)
+
+print("* done recording")
+
+stream.stop_stream()
+stream.close()
+p.terminate()
+
+wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
+wf.setnchannels(CHANNELS)
+wf.setsampwidth(p.get_sample_size(FORMAT))
+wf.setframerate(RATE)
+wf.writeframes(b''.join(frames))
+wf.close()
+

testType.py

@@ -0,0 +1,129 @@
+def dfs(graph, start, visited=None):
+    if visited is None:
+        visited = set()
+    visited.add(start)
+    print(start)
+    for neighbor in graph[start]:
+        if neighbor not in visited:
+            dfs(graph, neighbor, visited)
+
+def bfs(graph, start):
+    visited = set()
+    from collections import deque
+    queue = deque[(start)]
+    visited.add(start)
+    while queue:
+        node = queue.popleft()
+        print(node)
+        for neighbor in graph[node]:
+            if neighbor not in visited:
+                queue.append(neighbor)
+                visited.add(neighbor)
+
+import heapq
+heap = []
+heapq.heappush(heap, 3)
+smallest = heapq.heappop(heap)
+
+memo = {}
+def fibonacci(n):
+    if n <= 1:
+        return n
+    if n not in memo:
+        memo[n] = fibonacci(n-1) + fibonacci(n-2)
+
+    return memo[n]
+
+def knapsack(weights, values, capacity):
+    n = len(weights)
+    dp = [[0] * (capacity + 1) for _ in range(n+1)]
+
+    for i in range(1, n+1):
+        for j in range(1, capacity + 1):
+            if weights[i-1] <= j:
+                dp[i][j] = max(values[i-1] + dp[i-1][j-weights[i-1]], dp[i-1][j])
+            else:
+                dp[i][j] = dp[i-1][j]
+    return dp[n][capacity]
+
+
+def backtrack(nums, path, result):
+    if len(path) == len(nums):
+        result.append(path[:])
+        return
+    
+    for num in nums:
+        if num not in path:
+            path.append(num)
+            backtrack(nums, path, result)
+            path.pop()
+
+
+
+def top_k_elemnts(nums, k):
+    heap = []
+    for num in nums:
+        heapq.heappush(heap, num)
+        if len(heap) > k:
+            heapq.heappop(heap)
+    return heap
+
+
+from collections import defaultdict
+def group_anagrams(strs):
+    grouped_anagrams = defauldict(list)
+    for word in strs:
+        sorted_word = ''.join(sorted(word))
+        grouped_anagrams[sorted_word].append(word)
+    return list(grouped_anagrams.values())
+
+
+from collections import OrderedDict
+class LRUCache:
+    def __init__(self, capacity):
+        self.capacity = capacity
+        self.cache = OrderedDict()
+
+    def get(self, key):
+        if key in self.cache:
+            value = self.cache[key]
+            del self.cache[key]
+            self.cache[key] = value
+            return value
+        else:
+            return -1
+
+    def put(self, key, value):
+        if key in self.cahce:
+            del self.cache[key]
+        elif len(self.cache) == self.capacity:
+            self.cache.popitem(last=False)
+        self.cache[key] = value
+
+
+#random api things
+arr.sort(key=lambda x: len(x))
+for n1,n2 in zip(nums1, nums2):
+    print(n1,n2)
+''.join(strings)
+
+mySet.add(1)
+for k, v in map.items():
+    print(k, v)
+
+#for max heap use min heap by default and multiply -1 when push and pop
+arr = [2,1,8,4,5]
+heapq.heapify(arr)
+while arr:
+    print(heapq.heappop(arr))
+
+
+
+
+def lengthofLIS(self, nums:List[int]) -> int:
+    LIS = [1] * len(nums)
+    for i in range(len(nums)-1, -1, -1):
+        for j in range(i+1, len(nums)):
+            if nums[i] < nums[j]:
+                LIS[i] = max(LIS[i], 1+LIS[j])
+    return max(LIS)

tester.py

@@ -0,0 +1,57 @@
+import pyaudio
+import wave
+from pynput import keyboard
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 2
+RATE = 44100
+CHUNK = 1024
+RECORD_SECONDS = 5
+WAVE_OUTPUT_FILENAME = "output.wav"
+
+frames = []
+
+def on_press(key):
+    global frames
+    if key.char == 'a':
+        print("Inside...")
+        # Start recording
+        audio = pyaudio.PyAudio()
+        stream = audio.open(format=FORMAT, channels=CHANNELS,
+                            rate=RATE, input=True,
+                            frames_per_buffer=CHUNK)
+        print("Recording audio...")
+        while True:
+            data = stream.read(CHUNK)
+            frames.append(data)
+            if keyboard.is_pressed('esc'):
+                break
+        stream.stop_stream()
+        stream.close()
+        audio.terminate()
+
+def on_release(key):
+   if key == keyboard.Key.esc:
+       # Stop recording
+       audio = pyaudio.PyAudio()
+       stream = audio.open(format=FORMAT, channels=CHANNELS,
+                           rate=RATE, input=True,
+                           frames_per_buffer=CHUNK)
+       stream.stop_stream()
+       stream.close()
+       audio.terminate()
+       print("Finished recording audio.")
+       # Save recorded audio data to a .wav file
+       wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
+       wf.setnchannels(CHANNELS)
+       wf.setsampwidth(audio.get_sample_size(FORMAT))
+       wf.setframerate(RATE)
+       wf.writeframes(b''.join(frames))
+       wf.close()
+       # Stop the listener
+       return False
+
+# Start the listener
+with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
+    listener.join()
+

testpalm.py

@@ -0,0 +1,31 @@
+import pprint
+import google.generativeai as palm
+
+palm.configure(api_key='AIzaSyCLy2IgNwMBDbhYH_zvUDo0AMWQdRLQI0E')
+#models = [m for m in palm.list_models() if 'generateText' in m.supported_generation_methods]
+#model = models[0].name
+#print(model)
+
+
+prompt = """
+You are an expert at solving word problems.
+
+Solve the following problem:
+
+I have three houses, each with three cats.
+each cat owns 4 mittens, and a hat. Each mitten was
+knit from 7m of yarn, each hat from 4m.
+How much yarn was needed to make all the items?
+
+Think about it step by step, and show your work.
+"""
+
+completion = palm.generate_text(
+    model='models/text-bison-001',
+    prompt=prompt,
+    temperature=0,
+    # The maximum length of the response
+    max_output_tokens=800,
+)
+
+print(completion.result)

testwhisper.py

@@ -0,0 +1,28 @@
+import whisper
+import time
+import timeit
+
+model_tiny = whisper.load_model("tiny.en")
+model_base = whisper.load_model("base.en")
+model_small = whisper.load_model("small.en")
+
+codes_to_time = ["print(model_tiny.transcribe('2.wav')['text'])",
+                 "print(model_base.transcribe('2.wav')['text'])",
+                 "print(model_small.transcribe('2.wav')['text'])"]
+
+avg_times = []
+for code_to_time in codes_to_time:
+    execution_time = timeit.timeit(code_to_time, globals=globals(), number=5)
+    avg_time = execution_time / 5.0
+    avg_times.append(avg_time)
+    print(f"Execution time: {avg_time} seconds")
+
+
+print(avg_times)
+# [1.2609960311994655, 1.8864748299994971, 6.38237024199916]
+# From both a speed, and accuracy perspective base is best
+
+# result = model.transcribe("2.wav")
+# print(result["text"])
+
+#TODO: Figure out whisper with python chunks to implement into runner

toApi.py

@@ -0,0 +1,69 @@
+# USAGE keep using , (to prompt the bot via voice and keep adding on layers to message content for chat completion), 
+# after successful run through backtick is the exit, early stop after instructions have been fulfilled
+
+import os
+import pyaudio
+import wave
+from pynput import keyboard
+import speech_recognition as sr
+import openai
+openai.api_key = "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"
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 44100
+CHUNK = 1024
+RECORD_SECONDS = 5
+#WAVE_OUTPUT_FILENAME = "2.wav"
+
+frames = []
+
+def update_chat(messages, content):
+    messages.append({"role": "user", "content": content})
+    return messages
+
+messages = [
+    {"role": "system", "content": "You are a super helpful tutor and excellent interviewee. In general you explain your thought process and concepts very well. You first explain simple brute force solutions to interview problem (no need to code) but still go over the time and space complexity, then you explain the steps leading you to the most optimized solution.  You explain the concepts and procedures of this optimized solution and then you MUST provide the final code in python with its time and space complexity."}
+]
+
+def on_press(key):
+    #if key == keyboard.Key.esc:
+    #    recording = False
+    #    return False
+    if key == keyboard.KeyCode.from_char(','):
+        print("Recording audio...")
+        # Start recording
+        global stream, audio
+        audio = pyaudio.PyAudio()
+        stream = audio.open(format=FORMAT, channels=CHANNELS,
+                            rate=RATE, input=True,
+                            frames_per_buffer=CHUNK)
+        for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
+            data = stream.read(CHUNK)
+            frames.append(data)
+
+        # Stop recording
+        stream.stop_stream()
+        stream.close()
+        audio.terminate()
+        print("Finished recording audio.")
+        audio_data = sr.AudioData(b''.join(frames), RATE, 2)
+        print(audio_data)
+        #r = sr.Recognizer()
+        #text = r.recognize_google(audio_data)
+        #print("Finished transcription")
+        #response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=update_chat(messages, text))
+        os.system('clear')
+        #print(response['choices'][0]['message']['content'])
+    elif key == keyboard.KeyCode.from_char('`'):
+        print("Exiting")
+        return False
+        
+def on_release(key):
+    if key == keyboard.Key.esc:
+        return False
+
+# Start the listener
+with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
+    listener.join()
+

toAudio.py

@@ -0,0 +1,50 @@
+import pyaudio
+import wave
+from pynput import keyboard
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 44100
+CHUNK = 1024
+RECORD_SECONDS = 10
+WAVE_OUTPUT_FILENAME = "2.wav"
+
+frames = []
+
+def on_press(key):
+    #if key == keyboard.Key.esc:
+    #    recording = False
+    #    return False
+    if key == keyboard.KeyCode.from_char('a'):
+        print("Recording audio...")
+        # Start recording
+        global stream, audio
+        audio = pyaudio.PyAudio()
+        stream = audio.open(format=FORMAT, channels=CHANNELS,
+                            rate=RATE, input=True,
+                            frames_per_buffer=CHUNK)
+        for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
+            data = stream.read(CHUNK)
+            frames.append(data)
+
+        # Stop recording
+        stream.stop_stream()
+        stream.close()
+        audio.terminate()
+        print("Finished recording audio.")
+        # Save recorded audio data to a .wav file
+        wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
+        wf.setnchannels(CHANNELS)
+        wf.setsampwidth(audio.get_sample_size(FORMAT))
+        wf.setframerate(RATE)
+        wf.writeframes(b''.join(frames))
+        wf.close()
+
+def on_release(key):
+    if key == keyboard.Key.esc:
+        return False
+
+# Start the listener
+with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
+    listener.join()
+

toTranscribe.py

@@ -0,0 +1,53 @@
+import pyaudio
+import wave
+from pynput import keyboard
+import speech_recognition as sr
+
+FORMAT = pyaudio.paInt16
+CHANNELS = 1
+RATE = 44100
+CHUNK = 1024
+RECORD_SECONDS = 10
+WAVE_OUTPUT_FILENAME = "2.wav"
+
+frames = []
+
+#def transcribe(wav):
+    
+
+def on_press(key):
+    #if key == keyboard.Key.esc:
+    #    recording = False
+    #    return False
+    if key == keyboard.KeyCode.from_char('a'):
+        print("Recording audio...")
+        # Start recording
+        global stream, audio
+        audio = pyaudio.PyAudio()
+        stream = audio.open(format=FORMAT, channels=CHANNELS,
+                            rate=RATE, input=True,
+                            frames_per_buffer=CHUNK)
+        for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
+            data = stream.read(CHUNK)
+            frames.append(data)
+
+        # Stop recording
+        stream.stop_stream()
+        stream.close()
+        audio.terminate()
+        print("Finished recording audio.")
+        audio_data = sr.AudioData(b''.join(frames), RATE, 2)
+        print(audio_data)
+        #r = sr.Recognizer()
+        #text = r.recognize_google(audio_data)
+        #print(text)
+        
+def on_release(key):
+    if key == keyboard.Key.esc:
+        return False
+
+# Start the listener
+with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
+    listener.join()
+
+

transcriber/bin/Activate.ps1

@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

transcriber/bin/activate

@@ -0,0 +1,69 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+        hash -r 2> /dev/null
+    fi
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="(transcriber) ${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT="(transcriber) "
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+    hash -r 2> /dev/null
+fi

transcriber/bin/activate.csh

@@ -0,0 +1,26 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV "/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber"
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/bin:$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = "(transcriber) $prompt"
+    setenv VIRTUAL_ENV_PROMPT "(transcriber) "
+endif
+
+alias pydoc python -m pydoc
+
+rehash

transcriber/bin/activate.fish

@@ -0,0 +1,69 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/); you cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV "/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber"
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/bin" $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) "(transcriber) " (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+    set -gx VIRTUAL_ENV_PROMPT "(transcriber) "
+end

transcriber/bin/bard_api

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from bard_api.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

transcriber/bin/convert-caffe2-to-onnx

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from caffe2.python.onnx.bin.conversion import caffe2_to_onnx
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(caffe2_to_onnx())

transcriber/bin/convert-onnx-to-caffe2

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from caffe2.python.onnx.bin.conversion import onnx_to_caffe2
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(onnx_to_caffe2())

transcriber/bin/f2py

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

transcriber/bin/f2py3

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

transcriber/bin/f2py3.11

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

transcriber/bin/fonttools

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from fontTools.__main__ import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

transcriber/bin/futurize

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from libfuturize.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

transcriber/bin/gradio

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from gradio.cli import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli())

transcriber/bin/httpx

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from httpx import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

transcriber/bin/huggingface-cli

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from huggingface_hub.commands.huggingface_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

transcriber/bin/isympy

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from isympy import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

transcriber/bin/jsonschema

@@ -0,0 +1,8 @@
+#!/Users/harshpatel/DemoProjects/transcriber-prompt/transcriber/bin/python3.11
+# -*- coding: utf-8 -*-
+import re
+import sys
+from jsonschema.cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())