Whisper2Linux

https://whisper2linux.com/docs
Admin
Whisper2Linux is an AI-powered voice assistant for the Linux desktop that enables hands-free...
Tokens:13,144
Snippets:226
Trust Score:5.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Manage Docker Service

Source: https://whisper2linux.com/docs/setup-docker

Commands to start and enable the Docker daemon on system startup.

```bash
sudo systemctl start docker  
sudo systemctl enable docker  
```

--------------------------------

### Install Project Dependencies

Source: https://whisper2linux.com/docs/contributing

Install the necessary Python packages for development using pip. Ensure you have Python 3.8+ installed.

```bash
pip install -r requirements.txt  
```

--------------------------------

### Install Docker on Linux

Source: https://whisper2linux.com/docs/setup-docker

Commands to install Docker engine and related components on Debian or Arch-based distributions.

```bash
sudo apt-get update  
sudo apt-get install docker-ce docker-ce-cli containerd.io  
```

```bash
sudo pacman -Syu  
sudo pacman -S docker  
```

--------------------------------

### Whisper2Linux Configuration Variables

Source: https://whisper2linux.com/docs/setup

Example configuration variables for Whisper2Linux, including trigger word, API URLs for Whisper, TTS, and Ollama, and model/voice settings. Ensure API URLs match your setup.

```python
TRIGGER_WORD = "olga"  # Change this if you want a different trigger word  
WHISPER_API_URL = "http://192.168.1.186:9000/asr"  
TTS_API_URL = "http://192.168.1.186:8000/v1/audio/speech"  
OLLAMA_API_URL = "http://192.168.1.186:11434/api/chat"  
OLLAMA_MODEL = "mistral-nemo"  # Change this to your preferred model  
TTS_VOICE = "alloy"  # Change this to your preferred voice  
```

--------------------------------

### Implement Logging Setup

Source: https://whisper2linux.com/docs/logging-debugging

The setup_logging function initializes the logging system based on the provided log type.

```python
def setup_logging(log_type, log_file=None):  
    if log_type == 'none':  
        logging.disable(logging.CRITICAL)  
    elif log_type == 'memory':  
        log_stream = io.StringIO()  
        handler = StreamAndTerminalHandler(log_stream)  
        handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))  
        logging.getLogger().setLevel(logging.DEBUG)  
        logging.getLogger().addHandler(handler)  
        return log_stream  
    elif log_type == 'file':  
        if log_file:  
            logging.basicConfig(filename=log_file, level=logging.DEBUG,  
                                format="%(asctime)s - %(levelname)s - %(message)s")  
        else:  
            print("Error: Log file path not provided for file logging.")  
            exit(1)  
```

--------------------------------

### Implement Terminal Launch Command

Source: https://whisper2linux.com/docs/command-system

Example implementation of a custom command that launches the GNOME terminal.

```python
def cmd_open_terminal():  
    subprocess.Popen(['gnome-terminal'])  # Adjust for your desktop environment  
  
commands.update({  
    "open terminal": cmd_open_terminal  
})  

```

--------------------------------

### Start Docker Containers

Source: https://whisper2linux.com/docs/setup-docker

Command to initialize the services defined in the docker-compose.yml file in detached mode.

```bash
docker-compose up -d  
```

--------------------------------

### Start Whisper2Linux

Source: https://whisper2linux.com/docs/usage

Execute the main application script from the terminal to begin listening for voice commands.

```bash
python whisper2linux.py  

```

--------------------------------

### Install xdotool for Arch-based Systems

Source: https://whisper2linux.com/docs/setup

Installs the xdotool package, used for simulating keyboard input, on Arch-based Linux distributions.

```bash
sudo pacman -S xdotool  
```

--------------------------------

### Install Python Libraries

Source: https://whisper2linux.com/docs/setup

Installs the necessary Python libraries for Whisper2Linux, including requests, sounddevice, soundfile, numpy, Xlib, and rapidfuzz.

```bash
pip install requests sounddevice soundfile numpy Xlib rapidfuzz  
```

--------------------------------

### Install xdotool for Debian-based Systems

Source: https://whisper2linux.com/docs/setup

Installs the xdotool package, used for simulating keyboard input, on Debian-based Linux distributions.

```bash
sudo apt-get update  
sudo apt-get install xdotool  
```

--------------------------------

### Install pip for Arch-based Systems

Source: https://whisper2linux.com/docs/setup

Installs the pip package manager for Python on Arch-based systems if it's not already available.

```bash
sudo pacman -S python-pip  # For Arch-based systems  
```

--------------------------------

### Install pip for Debian-based Systems

Source: https://whisper2linux.com/docs/setup

Installs the pip package manager for Python on Debian-based systems if it's not already available.

```bash
sudo apt-get install python3-pip  # For Debian-based systems  
```

--------------------------------

### Integrate GUI with Tkinter

Source: https://whisper2linux.com/docs/customization

Install the tkinter library and run a basic status GUI in a separate thread.

```bash
sudo apt-get install python3-tk  
```

```python
import tkinter as tk  
  
def create_gui():  
    root = tk.Tk()  
    root.title("Whisper2Linux Status")  
      
    status_label = tk.Label(root, text="Whisper2Linux is running")  
    status_label.pack()  
      
    stop_button = tk.Button(root, text="Stop", command=stop_whisper2linux)  
    stop_button.pack()  
      
    root.mainloop()  
  
def stop_whisper2linux():  
    # Implement stop logic here  
    print("Stopping Whisper2Linux")  
    # You might want to set a flag to stop the main loop  
  
# Run the GUI in a separate thread  
gui_thread = threading.Thread(target=create_gui)  
gui_thread.start()  
```

--------------------------------

### Track Memory Usage

Source: https://whisper2linux.com/docs/logging-debugging

Install and use memory_profiler to monitor memory consumption of specific functions.

```bash
pip install memory_profiler  
```

```python
from memory_profiler import profile  
  
@profile  
def memory_intensive_function():  
    # Function code here  
```

--------------------------------

### Check Python Version

Source: https://whisper2linux.com/docs/setup

Checks the installed Python version. Whisper2Linux requires Python 3.8 or higher.

```bash
python --version  
```

--------------------------------

### Modify Existing Command Function

Source: https://whisper2linux.com/docs/customization

Edit an existing command function, such as 'cmd_copy', to alter its behavior. This example appends a timestamp to the copied text.

```python
def cmd_copy(transcription):
    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
    state.in_memory_clipboard = f"{transcription} (Copied at {timestamp})"
    logging.debug(f"Copied to in-memory clipboard: {state.in_memory_clipboard}")
```

--------------------------------

### Set Up a Virtual Environment

Source: https://whisper2linux.com/docs/contributing

Create and activate a virtual environment to manage project dependencies. This isolates your project's Python packages from your system's global packages.

```bash
python -m venv venv  
source venv/bin/activate  # On Windows: venv\Scripts\activate  
```

--------------------------------

### Enable File Logging

Source: https://whisper2linux.com/docs/usage

Run the application with '--log file' and specify a log file path using '--log-file' to enable file logging.

```bash
python whisper2linux.py --log file --log-file /path/to/logfile.log
```

--------------------------------

### Set Up Custom Logger

Source: https://whisper2linux.com/docs/customization

Configure a custom logger named 'WhisperLinuxCustomLogger' to write logs to a file with a specified format and level.

```python
import logging

def setup_custom_logger():
    logger = logging.getLogger("WhisperLinuxCustomLogger")
    handler = logging.FileHandler("custom_whisperlinux.log")
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)
    logger.setLevel(logging.DEBUG)
    return logger

custom_logger = setup_custom_logger()
```

--------------------------------

### Configure Logging via Command Line

Source: https://whisper2linux.com/docs/logging-debugging

Use command-line arguments to specify the logging destination and file path.

```bash
python whisper2linux.py --log memory  
python whisper2linux.py --log file --log-file /path/to/logfile.log  
```

--------------------------------

### Implement Custom Activation Logic

Source: https://whisper2linux.com/docs/customization

Modify the 'handle_recording' function to incorporate custom logic for activating Whisper2Linux, such as a specific hotkey or phrase.

```python
def handle_recording():
    # Implement your custom activation logic here
    # For example, using a specific hotkey or phrase
    if custom_activation_condition:
        state.recording_started = True
        play_beep()
        state.audio_data = []
        state.last_recording_time = time.time()
        record_audio_continuously()
```

--------------------------------

### Profile Application Performance

Source: https://whisper2linux.com/docs/logging-debugging

Use cProfile to identify performance bottlenecks in the main execution flow.

```python
import cProfile  
  
cProfile.run('main()')  
```

--------------------------------

### Enable Debug Logging

Source: https://whisper2linux.com/docs/logging-debugging

Run the application with file logging enabled to capture detailed debug information.

```bash
python whisper2linux.py --log file --log-file debug.log  
```

--------------------------------

### Clone Your Fork of Whisper2Linux

Source: https://whisper2linux.com/docs/contributing

Clone your forked repository to your local machine and navigate into the project directory. This is the first step after forking the repository.

```bash
git clone https://github.com/your-username/whisper2linux.git  
cd whisper2linux  
```

--------------------------------

### Implement Unit Tests

Source: https://whisper2linux.com/docs/logging-debugging

Use the unittest framework to isolate and verify component functionality.

```python
import unittest  
  
class TestWhisper2Linux(unittest.TestCase):  
    def test_transcribe_audio(self):  
        # Test code here  
        pass  
  
if __name__ == '__main__':  
    unittest.main()  
```

--------------------------------

### Define Custom Keyboard Shortcuts

Source: https://whisper2linux.com/docs/customization

Create shortcut functions using xdotool and register them in the commands dictionary.

```python
def custom_shortcut_1():  
    # Implement custom shortcut action  
    subprocess.run(["xdotool", "key", "ctrl+alt+1"])  
  
def custom_shortcut_2():  
    # Another custom shortcut  
    subprocess.run(["xdotool", "key", "ctrl+alt+2"])  
```

```python
commands.update({  
    "shortcut one": custom_shortcut_1,  
    "shortcut two": custom_shortcut_2  
})  
```

--------------------------------

### Run Whisper2Linux

Source: https://whisper2linux.com/docs/setup

Executes the Whisper2Linux application. Ensure all prerequisites and configurations are completed before running.

```bash
python whisper2linux.py  
```

--------------------------------

### Docker Compose Configuration

Source: https://whisper2linux.com/docs/setup-docker

A comprehensive docker-compose.yml file defining services for ASR, LLM, WebUI, and TTS with GPU support.

```yaml
services:  
  # Audio to Text (asr)  
  whisper_asr:  
    container_name: whisper_asr  
    ports:  
      - "9000:9000"  
    pull_policy: always  
    restart: unless-stopped  
    image: onerahmet/openai-whisper-asr-webservice:latest-gpu  
    environment:  
      - 'ASR_ENGINE=openai_whisper'  
      - 'ASR_MODEL=large-v3'  
    deploy:  
      resources:  
        reservations:  
          devices:  
            - driver: nvidia  
              # device_ids: ['0', '1'] # Select a gpu, or  
              count: all  
              capabilities: [gpu]  
  
  # LLM  
  ollama:  
    volumes:  
      - ollama:/root/.ollama  
    container_name: ollama  
    ports:  
      - "11434:11434"  
    pull_policy: always  
    tty: true  
    restart: unless-stopped  
    image: ollama/ollama:${{OLLAMA_DOCKER_TAG-latest}}  
    deploy:  
      resources:  
        reservations:  
          devices:  
            - driver: nvidia  
              # device_ids: ['0', '1'] # Select a gpu, or  
              count: all  
              capabilities: [gpu]  
  
  # LLM GUI  
  open-webui:  
    build:  
      context: .  
      args:  
        OLLAMA_BASE_URL: '/ollama'  
      dockerfile: Dockerfile  
    image: ghcr.io/open-webui/open-webui:${{WEBUI_DOCKER_TAG-main}}  
    container_name: open-webui  
    volumes:  
      - open-webui:/app/backend/data  
    depends_on:  
      - ollama  
    ports:  
      - ${{OPEN_WEBUI_PORT-3000}}:8080  
    environment:  
      - 'OLLAMA_BASE_URL=http://ollama:11434'  
      - 'WEBUI_SECRET_KEY='  
    extra_hosts:  
      - host.docker.internal:host-gateway  
    restart: unless-stopped  
  
  # Text to Speech (tts)  
  server:  
    image: ghcr.io/matatonic/openedai-speech:latest  
    container_name: openedai-speech  
    depends_on:  
      - ollama  
    env_file: speech.env  
    ports:  
      - "8000:8000"  
    volumes:  
      - tts-voices:/app/voices  
      - tts-config:/app/config  
    restart: unless-stopped  
    deploy:  
      resources:  
        reservations:  
          devices:  
            - driver: nvidia  
              # device_ids: ['0', '1'] # Select a gpu, or  
              count: all  
              capabilities: [gpu]  
volumes:  
  tts-voices:  
  tts-config:  
  ollama: {}  
  open-webui: {}  
```

--------------------------------

### Enable Memory Logging

Source: https://whisper2linux.com/docs/usage

Run the application with the '--log memory' flag to enable memory logging for debugging purposes.

```bash
python whisper2linux.py --log memory
```

--------------------------------

### Create Logging Decorators

Source: https://whisper2linux.com/docs/logging-debugging

Use decorators to automatically log function entry and completion.

```python
def log_function_call(func):  
    def wrapper(*args, **kwargs):  
        logging.debug(f"Calling function: {func.__name__}")  
        result = func(*args, **kwargs)  
        logging.debug(f"Function {func.__name__} completed")  
        return result  
    return wrapper  
  
@log_function_call  
def some_function():  
    # Function code here  
```

--------------------------------

### Execute Efficient Command Matching

Source: https://whisper2linux.com/docs/performance-optimization

Utilizes the rapidfuzz library for fast and flexible fuzzy string matching against command keys.

```python
from rapidfuzz import fuzz, process  
  
# In command processing:  
best_command_match = process.extractOne(command_string, commands.keys(), scorer=fuzz.ratio)  
```

--------------------------------

### Run Whisper2Linux with File Logging

Source: https://whisper2linux.com/docs/setup

Runs Whisper2Linux with file logging enabled, directing output to a specified log file. Useful for detailed debugging.

```bash
# Run with file logging  
python whisper2linux.py --log file --log-file /path/to/logfile.log  
```

--------------------------------

### Implement Continuous Audio Recording

Source: https://whisper2linux.com/docs/performance-optimization

Uses a chunk-based approach to record audio in real-time, reducing latency in command recognition.

```python
RECORDING_CHUNK_DURATION = 0.1  
  
def record_audio_continuously():  
    while state.recording_started:  
        chunk = sd.rec(int(SAMPLE_RATE * RECORDING_CHUNK_DURATION), samplerate=SAMPLE_RATE, channels=1, dtype='int16', device=MIC_DEVICE)  
        sd.wait()  
        state.audio_data.append(chunk)  
```

--------------------------------

### Respond to Commands via Ollama

Source: https://whisper2linux.com/docs/api-integration

Sends a user query to the Ollama API for AI-driven response generation.

```python
def cmd_respond(transcription):  
    # ... (preprocessing logic)  
    response = requests.post(OLLAMA_API_URL, json={  
        "model": OLLAMA_MODEL,  
        "messages": [  
            {"role": "system", "content": SYSTEM_MESSAGE},  
            {"role": "user", "content": query}  
        ],  
        "stream": False  
    })  
    # Process the response...  

```

--------------------------------

### Run Whisper2Linux with Memory Logging

Source: https://whisper2linux.com/docs/setup

Runs Whisper2Linux with memory logging enabled. Useful for diagnosing memory usage issues.

```bash
python whisper2linux.py --log memory  
```

--------------------------------

### Track Performance with Logging

Source: https://whisper2linux.com/docs/performance-optimization

Measures processing time for operations to identify bottlenecks in the application.

```python
total_local_processing_time = 0  
total_model_processing_time = 0  
  
# In various functions:  
start_time = time.perf_counter()  
# ... operation ...  
end_time = time.perf_counter()  
total_local_processing_time += end_time - start_time  
```

--------------------------------

### Whisper2Linux Akash Network SDL

Source: https://whisper2linux.com/docs/setup-akash

This SDL file defines the services, resources, and deployment configurations for Whisper2Linux on the Akash Network. It includes settings for Ollama, Open WebUI, OpenAI Speech Server, and Whisper ASR, specifying image, ports, dependencies, environment variables, and resource allocation (CPU, memory, storage, GPU).

```yaml
---
version: "2.0"
services:
  whisper2linux-ollama:
    image: ollama/ollama
    expose:
      - port: 11434
        as: 11434
        to:
          - global: true
    command:
      - /bin/sh
      - -c
      - |
        ollama serve &
        while ! ollama pull mistral-nemo:12b; do
          echo "Waiting for ollama pull to succeed..."
          sleep 5
        done
        ollama list
        pkill ollama
        ollama serve
  whisper2linux-open-webui:
    image: ghcr.io/open-webui/open-webui
    expose:
      - port: 8080
        as: 80
        to:
          - global: true
    depends_on:
      - ollama
    env:
      - OLLAMA_BASE_URL=http://ollama:11434
      - WEBUI_SECRET_KEY=
  whisper2linux-openedai-speech-server:
    image: ghcr.io/matatonic/openedai-speech:latest
    expose:
      - port: 8000
        as: 8000
        to:
          - global: true
  whisper2linux-whisper-asr:
    image: onerahmet/openai-whisper-asr-webservice:latest-gpu
    expose:
      - port: 9000
        as: 9000
        to:
          - global: true
    env:
      - ASR_ENGINE=openai_whisper
      - ASR_MODEL=large-v3
profiles:
  compute:
    whisper2linux-ollama:
      resources:
        cpu:
          units: 8
        memory:
          size: 24Gi
        storage:
          - size: 12Gi
        gpu:
          units: 1
          attributes:
            vendor:
              nvidia: 
    whisper2linux-open-webui:
      resources:
        cpu:
          units: 1
        memory:
          size: 4Gi
        storage:
          - size: 4Gi
    whisper2linux-openedai-speech-server:
      resources:
        cpu:
          units: 8
        memory:
          size: 8Gi
        storage:
          - size: 16Gi
        gpu:
          units: 1
          attributes:
            vendor:
              nvidia: 
    whisper2linux-whisper-asr:
      resources:
        cpu:
          units: 8
        memory:
          size: 8Gi
        storage:
          - size: 16Gi
        gpu:
          units: 1
          attributes:
            vendor:
              nvidia: 
  placement:
    akash:
      pricing:
        whisper2linux-ollama:
          denom: uakt
          amount: 10000
        whisper2linux-open-webui:
          denom: uakt
          amount: 10000
        whisper2linux-openedai-speech-server:
          denom: uakt
          amount: 10000
        whisper2linux-whisper-asr:
          denom: uakt
          amount: 10000
      signedBy:
        anyOf:
          - akash1365yvmc4s7awdyj3n2sav7xfx76adc6dnmlx63
          - akash18qa2a2ltfyvkyj0ggj3hkvuj6twzyumuaru9s4
deployment:
  whisper2linux-ollama:
    akash:
      profile: whisper2linux-ollama
      count: 1
  whisper2linux-open-webui:
    akash:
      profile: whisper2linux-open-webui
      count: 1
  whisper2linux-openedai-speech-server:
    akash:
      profile: whisper2linux-openedai-speech-server
      count: 1
  whisper2linux-whisper-asr:
    akash:
      profile: whisper2linux-whisper-asr
      count: 1

```

--------------------------------

### Define Command Structure

Source: https://whisper2linux.com/docs/command-system

The standard format for voice commands, consisting of a trigger word, the command, and optional arguments.

```text
[Trigger Word]: [Command] [Arguments]  

```

--------------------------------

### Handle and Log Exceptions

Source: https://whisper2linux.com/docs/logging-debugging

Wrap operations in try-except blocks to log errors with stack traces.

```python
try:  
    # Some operation  
except Exception as e:  
    logging.error(f"An error occurred: {str(e)}", exc_info=True)  
```

--------------------------------

### Implement Wake Word Detection

Source: https://whisper2linux.com/docs/customization

Define a detection function and integrate it into the main audio processing loop.

```python
def detect_wake_word(audio_chunk):  
    # Implement wake word detection logic  
    # This could use a pre-trained model or a simple energy threshold  
    return wake_word_detected  
  
# In the main audio processing loop:  
if detect_wake_word(audio_chunk):  
    handle_recording()  
```

--------------------------------

### Microphone and Sample Rate Configuration

Source: https://whisper2linux.com/docs/setup

Configuration for microphone device and sample rate in Whisper2Linux. Set MIC_DEVICE to a specific index if needed, and adjust SAMPLE_RATE if your microphone requires a different setting.

```python
MIC_DEVICE = None  # Set to a specific device index if needed  
SAMPLE_RATE = 16000  # Adjust if your microphone requires a different sample rate  
```

--------------------------------

### Configure TTS API Settings

Source: https://whisper2linux.com/docs/api-integration

Define the endpoint and default voice for text-to-speech generation.

```python
TTS_API_URL = "http://192.168.1.186:8000/v1/audio/speech"  
TTS_VOICE = "alloy"  

```

--------------------------------

### Implement Adaptive Processing

Source: https://whisper2linux.com/docs/performance-optimization

Dynamically adjusts processing intensity based on current CPU usage to maintain system stability.

```python
import psutil  
  
def adjust_processing_params():  
    cpu_usage = psutil.cpu_percent()  
    if cpu_usage > 80:  
        reduce_processing_intensity()  
    elif cpu_usage < 20:  
        increase_processing_intensity()  
```

--------------------------------

### Push Your Changes to Origin

Source: https://whisper2linux.com/docs/contributing

Push your committed changes to your forked repository on GitHub. This makes your changes available for a pull request.

```bash
git push origin feature/your-feature-name  
```

--------------------------------

### Register Custom Command

Source: https://whisper2linux.com/docs/customization

Add a new command to the 'commands' dictionary, mapping a string phrase to its corresponding function.

```python
commands.update({
    "custom action": cmd_custom_action
})
```

--------------------------------

### Define Custom Command Function

Source: https://whisper2linux.com/docs/command-system

Template for creating the logic associated with a custom command.

```python
def your_command_function():  
    # Your command logic here  
    pass  

```

--------------------------------

### Configure Ollama API Settings

Source: https://whisper2linux.com/docs/api-integration

Define the endpoint and model name for the Ollama AI service.

```python
OLLAMA_API_URL = "http://192.168.1.186:11434/api/chat"  
OLLAMA_MODEL = "mistral-nemo"  

```

--------------------------------

### Clone Whisper2Linux Repository

Source: https://whisper2linux.com/docs/setup

Clones the Whisper2Linux repository from GitHub and navigates into the project directory.

```bash
git clone https://github.com/yourusername/whisper2linux.git  
cd whisper2linux  
```

--------------------------------

### Configure Whisper2Linux API URLs

Source: https://whisper2linux.com/docs/usage

Update these variables in whisper2linux.py to point to your specific ASR, TTS, and LLM service endpoints.

```python
WHISPER_API_URL = "http://localhost:9000/asr" #Automatic Speech Recognition  
TTS_API_URL = "http://localhost:8000/v1/audio/speech" #Text-To-Speech  
OLLAMA_API_URL = "http://localhost:11434/api/chat" #Ollama LLM Model  

```

--------------------------------

### Configure Recording Chunk Duration

Source: https://whisper2linux.com/docs/customization

Adjust the RECORDING_CHUNK_DURATION variable to control the size of audio chunks processed. Shorter durations can lead to faster processing.

```python
RECORDING_CHUNK_DURATION = 0.05  # Shorter chunks for faster processing
```

--------------------------------

### Configure Whisper API Endpoint

Source: https://whisper2linux.com/docs/api-integration

Set the base URL for the speech-to-text service.

```python
WHISPER_API_URL = "http://192.168.1.186:9000/asr"  

```

--------------------------------

### Implement API Error Handling

Source: https://whisper2linux.com/docs/api-integration

Standard pattern for catching and logging request exceptions during API calls.

```python
try:  
    response = requests.post(API_URL, ...)  
    response.raise_for_status()  
    # Process successful response  
except requests.exceptions.RequestException as e:  
    logging.error(f"API call failed: {e}")  
    # Handle the error (e.g., provide a fallback response)  

```

--------------------------------

### Configure Multi-Language Support

Source: https://whisper2linux.com/docs/customization

Modify Whisper API parameters to support specific languages and implement a selection mechanism.

```python
def transcribe_audio_from_memory(audio_buffer, language='en'):  
    params = {  
        'task': 'transcribe',  
        'language': language,  
        'output': 'txt',  
        'encode': False  
    }  
    # Rest of the function remains the same  
```

```python
def detect_language(audio_chunk):  
    # Implement language detection logic  
    # This could be based on the user's settings or automatic detection  
    return detected_language  
  
# In the main processing loop:  
detected_lang = detect_language(audio_chunk)  
transcription = transcribe_audio_from_memory(audio_buffer, language=detected_lang)  
```

--------------------------------

### Enable Debugging via Environment Variables

Source: https://whisper2linux.com/docs/logging-debugging

Use the WHISPER2LINUX_DEBUG environment variable to toggle additional debug features within the application.

```python
import os  
  
if os.environ.get('WHISPER2LINUX_DEBUG'):  
    # Enable additional debug features  
```

--------------------------------

### Add Custom Command Function

Source: https://whisper2linux.com/docs/customization

Define a new Python function to implement custom command logic.

```python
def cmd_custom_action():
    # Implement your custom action here
    print("Executing custom action")
```

--------------------------------

### Record Log Messages

Source: https://whisper2linux.com/docs/logging-debugging

Standard logging calls used throughout the application to record events.

```python
logging.debug("Detailed information for debugging purposes")  
logging.info("General information about program execution")  
logging.warning("Warning messages")  
logging.error("Error messages for serious problems")  
logging.critical("Critical errors that may cause the program to terminate")  
```

--------------------------------

### Perform Non-blocking Audio Feedback

Source: https://whisper2linux.com/docs/performance-optimization

Executes audio playback in a separate thread to ensure the main application remains responsive.

```python
def play_beep():  
    beep_thread = threading.Thread(target=sd.play, args=(beep_sound, SAMPLE_RATE))  
    beep_thread.start()  
```

--------------------------------

### Transcribe Audio from Memory

Source: https://whisper2linux.com/docs/api-integration

Sends an audio buffer to the Whisper API for transcription.

```python
def transcribe_audio_from_memory(audio_buffer):  
    files = {  
        'audio_file': ('audio.flac', audio_buffer, 'audio/flac')  
    }  
    params = {  
        'task': 'transcribe',  
        'language': 'en',  
        'output': 'txt',  
        'encode': False  
    }  
    response = requests.post(WHISPER_API_URL, files=files, params=params)  
    # Process the response...  

```

--------------------------------

### Create a New Feature Branch

Source: https://whisper2linux.com/docs/contributing

Create a new branch for your feature or bug fix. This helps keep your changes organized and separate from the main development branch.

```bash
git checkout -b feature/your-feature-name  
```

--------------------------------

### Debug API Interactions

Source: https://whisper2linux.com/docs/logging-debugging

Log request and response details to troubleshoot API communication.

```python
logging.debug(f"API Request: {url}, Data: {data}")  
response = requests.post(url, json=data)  
logging.debug(f"API Response: Status {response.status_code}, Content: {response.text}")  
```

--------------------------------

### Perform Asynchronous API Calls

Source: https://whisper2linux.com/docs/performance-optimization

Uses aiohttp to prevent blocking the main thread during network requests.

```python
import aiohttp  
import asyncio  
  
async def async_api_call(url, data):  
    async with aiohttp.ClientSession() as session:  
        async with session.post(url, json=data) as response:  
            return await response.json()  
  
# Usage:  
response = await async_api_call(API_URL, request_data)  
```

--------------------------------

### Manage Audio Data Memory

Source: https://whisper2linux.com/docs/performance-optimization

Clears audio chunks that exceed the defined retention period to free up memory.

```python
def clear_old_audio_data():  
    current_time = time.time()  
    state.audio_data = [chunk for chunk in state.audio_data if current_time - chunk.timestamp < AUDIO_RETENTION_PERIOD]  
```

--------------------------------

### Use Custom Error Handler in Try-Except

Source: https://whisper2linux.com/docs/customization

Integrate the 'custom_error_handler' within try-except blocks to manage exceptions gracefully.

```python
try:
    # Some operation
except Exception as e:
    custom_error_handler("OperationError", str(e))
```

--------------------------------

### Insert Interactive Debugger Breakpoint

Source: https://whisper2linux.com/docs/logging-debugging

Use pdb to pause execution at a specific point in the code.

```python
import pdb; pdb.set_trace()  
```

--------------------------------

### Implement Custom Error Handling Function

Source: https://whisper2linux.com/docs/customization

Define a 'custom_error_handler' function to manage and log errors according to specific requirements.

```python
def custom_error_handler(error_type, error_message):
    logging.error(f"Custom error handler: {error_type} - {error_message}")
    # Implement your custom error handling logic here
```

--------------------------------

### Adjust Audio Sample Rate

Source: https://whisper2linux.com/docs/customization

Modify the SAMPLE_RATE variable to control the audio quality during recording. Higher values result in better quality but larger file sizes.

```python
SAMPLE_RATE = 44100  # CD quality audio
```

--------------------------------

### Customize AI Assistant Personality

Source: https://whisper2linux.com/docs/customization

Edit the SYSTEM_MESSAGE variable to define the AI assistant's personality, role, and instructions.

```python
SYSTEM_MESSAGE = """
You are a helpful AI assistant named {trigger_word}. Your role is to... 
[Add your custom instructions here] 
"""
```

--------------------------------

### Update Custom API Endpoints

Source: https://whisper2linux.com/docs/customization

Change the API URL variables (WHISPER_API_URL, TTS_API_URL, OLLAMA_API_URL) to point to custom API services.

```python
WHISPER_API_URL = "https://your-custom-whisper-api.com/transcribe"
TTS_API_URL = "https://your-custom-tts-api.com/synthesize"
OLLAMA_API_URL = "https://your-custom-ollama-api.com/chat"
```

--------------------------------

### Use Custom Logger for Messages

Source: https://whisper2linux.com/docs/customization

Utilize the 'custom_logger' object to log messages at different severity levels (debug, info, warning, error).

```python
custom_logger.debug("Debug message")
custom_logger.info("Info message")
custom_logger.warning("Warning message")
custom_logger.error("Error message")
```

--------------------------------

### Implement Custom Text Processing

Source: https://whisper2linux.com/docs/customization

Define a function to clean transcription text and integrate it into the processing pipeline.

```python
def custom_text_processor(text):  
    # Implement your custom text processing here  
    # For example, removing filler words or correcting common mistakes  
    processed_text = text.lower().replace("um", "").replace("uh", "")  
    return processed_text  
```

```python
def process_transcription(transcription):  
    processed_transcription = custom_text_processor(transcription)  
    # Rest of the processing logic  
```

--------------------------------

### Parallelize Tasks with Multiprocessing

Source: https://whisper2linux.com/docs/performance-optimization

Uses a process pool to distribute CPU-intensive tasks across multiple cores.

```python
from multiprocessing import Pool  
  
def cpu_intensive_task(data):  
    # Process data  
    return result  
  
with Pool(processes=4) as pool:  
    results = pool.map(cpu_intensive_task, data_chunks)  
```

--------------------------------

### Synthesize Speech from Text

Source: https://whisper2linux.com/docs/api-integration

Sends text to the TTS API to generate a spoken response.

```python
def synthesize_speech(text, voice=TTS_VOICE):  
    response = requests.post(TTS_API_URL, json={  
        "model": "tts-1-hd",  
        "input": text,  
        "voice": voice,  
        "response_format": "wav",  
        "speed": 1.0  
    })  
    # Process the response...  

```

--------------------------------

### Change Whisper2Linux Trigger Word

Source: https://whisper2linux.com/docs/customization

Modify the TRIGGER_WORD variable in whisper2linux.py to change the default activation phrase.

```python
TRIGGER_WORD = "your_preferred_trigger_word"
```
Tokens:
Raw