Start a formatting chain for the given text. Usage: print(Colors.apply("Hello").red.bold)

Calculates the similarity ratio between two texts based on the configuration. Normalizes both input texts, then calculates similarit

Checks if a string ends with a specific substring, allowing for one trailing character. Useful for checking punctuation even if there's a tr

Generates text using the configured backend, yielding tokens as a stream. Handles lazy initialization (including potential `ollama p

Checks if there is a currently running generation that has not started aborting. Returns: True if `running_generation` e

Extracts the last `n_words` from a normalized text string. Splits the text by spaces and joins the last `n_words` back together.

Internal helper to get a parameter from the recorder instance, abstracting client/server differences. Args: para

Internal helper to set a parameter on the recorder instance, abstracting client/server differences. Args: param_

Requests cancellation of active generation streams. If `request_id` is provided, cancels that specific stream. If `request_i

Callback invoked when a partial text result from the assistant (LLM) is available. Updates the internal assistant answer state and s

Initializes backend clients or checks connections on first use (thread-safe). Creates the appropriate HTTP client (OpenAI SDK or req

Registers an active generation stream for cancellation tracking (thread-safe). Stores the request ID, type, stream object, and start

Public method to initiate the abortion of the current speech generation. Calls the internal `process_abort_generation` method to han

Preprocesses a text chunk before sending it to the TTS engine. Replaces specific characters (em-dashes, quotes, ellipsis) with simpl

Resets the internal state of the TurnDetection instance. Clears the text history deques, the model prediction cache, and resets the

Updates the internal silence state and triggers the silence_active_callback. Args: silence_active: The new silence state

Internal helper to handle cancellation for a single request (thread-unsafe). Removes the request data from the `_active_requests` di

Performs a quick HTTP GET request to check connectivity with an Ollama server. Uses the provided requests Session and base URL to attempt a

Creates and configures an OpenAI API client instance. Handles API key logic (using a placeholder if none provided for local models) and

Internal helper to check if the recorder is currently recording, abstracting client/server differences. Returns:

Prepares text for comparison by simplifying it. Converts the input text to lowercase, removes all characters that are not al

Iterates over an OpenAI/LMStudio stream, yielding content chunks. Handles extracting content from stream chunks and checks for cance

Signals the underlying transcriber to abort any ongoing generation process.

Determines if two texts meet the similarity threshold. Calculates the similarity between `text1` and `text2` using the configured

Checks if the current generation should be aborted based on new input text. Compares the provided text (`txt`) with the text of the

Detects potential sentence endings based on ending punctuation and timing stability. Checks if the provided text ends with sentence-

Formats a nanosecond timestamp into a human-readable HH:MM:SS.fff string. Args: timestamp_ns: The timestamp in nanoseconds since the

Determines a base pause duration based on the text's ending punctuation. Checks for specific ending patterns ('...', '.', '!', '?')

Checks if two text strings are highly similar, focusing on the ending words. Uses the internal TextSimilarity instance. Args

Measures the time taken to generate a target number of initial tokens. Uses a fixed, predefined prompt designed to elicit a somewhat

Callback method invoked by AudioProcessor when the first TTS audio chunk is ready. Sets the `quick_answer_first_chunk_ready` flag on

Attempts to "prewarm" the LLM connection and potentially load the model. Runs a simple, short generation task ("Respond with only th

Resets connection-specific state flags and variables to their initial values.

Sends the final (or best available) assistant answer to the client. Constructs the full answer from quick and final parts if availab

Removes trailing punctuation marks defined in `sentence_end_marks`. Removes trailing whitespace first, then iteratively removes any characte

Adjusts dynamic pause parameters based on a speed factor. Linearly interpolates between 'fast' (speed_factor=0.0) and 'very_slow'

Internal helper to initialize the RealtimeSTT recorder instance (either local or client) with the specified configuration and callbac

Internal helper to normalize text for comparison purposes. Converts to lowercase, removes non-alphanumeric characters (except spaces)

Resets the microphone interruption flag after a delay (async version). Waits for 1 second, then checks if the AudioInputProcessor is still m

Attempts to run the 'ollama ps' command via subprocess. This is used as a potential fallback diagnostic/recovery step if the initial HTT

Continuously runs the transcription loop in a background asyncio task. It repeatedly calls the underlying `transcribe_loop`. If `tra

Sets up internal callbacks for the TranscriptionProcessor instance.

Starts a background thread to monitor silence duration and trigger events like potential sentence end detection, TTS synthesis allowa

Iterates over an Ollama HTTP response stream, decoding JSON lines and yielding content. Handles reading bytes, decoding UTF-8, parsi

Triggers the abortion of any ongoing speech generation process. Logs the reason and calls the SpeechPipelineManager's abort method.

Adds a text segment to the processing queue for waiting time calculation. This is the entry point for feeding text into the turn det

Removes specific leading patterns (like '<think>', newlines, spaces) from text. Intended for cleaning the initial output of the LLM,

Creates a directory at the specified path if it doesn't already exist. Args: path: The directory path to create.

Ensures the Coqui XTTS Lasinya model files are present locally. Checks for required model files (config.json, vocab.json, etc.) within t

Feeds an audio chunk to the underlying recorder instance for processing. Args: chunk: A bytes object containing the raw

Finds recent consecutive entries with the same stripped text. Iterates backwards through the deque of (original_text, stripped_text) tuples.

Copies the current audio buffer from the recorder's frames. Retrieves the raw audio frames, concatenates them, converts to a float32

Processes an incoming audio chunk, upsamples it, and returns the relevant segment as Base64. Converts the raw PCM bytes (assumed 16-

Calculates the probability that the given sentence is complete using the ML model. Uses an internal LRU cache (`_completion_probabil

Finds the shortest valid context at the beginning of the input text. Scans the text `txt` from the beginning up to `max_len` charact

Returns the last successfully captured audio buffer as a float32 NumPy array. Attempts to get the current audio buffer first. If suc

Linearly interpolates a value based on probability using predefined anchor points. Maps an input probability `prob` (clamped between 0.0 and

Callback handler for when TurnDetection calculates a new waiting time. Updates the recorder's post_speech_silence_duration parameter.

Callback invoked when the system determines TTS synthesis can proceed.

Safely parses a JSON string into a dictionary. Logs a warning if the JSON is invalid and returns an empty dictionary. Args: tex

Public method to request the preparation of a new speech generation. Queues a 'prepare' action with the provided text onto the `requ

Cleans and normalizes the beginning of a text string. Applies the following steps: 1. Removes leading whitespace. 2. Removes leading

Handles the core logic of aborting the current generation. Synchronized using `abort_lock`. If a `running_generation` exists:

Converts raw audio bytes (int16) to a 16kHz 16-bit PCM numpy array. The audio is converted to float32 for accurate resampling and th

Continuously processes audio chunks received from an asyncio Queue. Retrieves audio data, processes it using `process_audio_chunk`,

Receives messages via WebSocket, processes audio and text messages. Handles binary audio chunks, extracting metadata (timestamp, flags) and

Handles the 'prepare' action: initiates a new text-to-speech generation. 1. Calls `check_abort` to potentially stop and clean up any

Continuously sends text messages from a queue to the client via WebSocket. Waits for messages on the `message_queue`, formats them as JSON,

Continuously sends TTS audio chunks from the SpeechPipelineManager to the client. Monitors the state of the current speech generation (if an

Configures the root logger for console output with a custom format and level. Sets up a `StreamHandler` for the root logger if no handlers a

Initiates shutdown procedures for the audio processor and transcriber. Signals the transcriber to shut down and cancels the backgrou

Invokes the `on_new_waiting_time` callback with the suggested pause duration. Only triggers the callback if the new suggested time i

Synthesizes audio from a complete text string and puts chunks into a queue. Feeds the entire text string to the TTS engine. As audio

Synthesizes audio from a generator yielding text chunks and puts audio into a queue. Feeds text chunks yielded by the generator to t

Enters the context, starts generation, and returns the token generator. Calls the LLM's `generate` method and registers the request.

Exits the context, ensuring the generation stream is cancelled and closed. Calls `llm.cancel_generation` to remove tracking and atte

Initializes the AudioProcessor with a specific TTS engine. Sets up the chosen engine (Coqui, Kokoro, Orpheus), downloads Coqui model

Initializes the TextSimilarity comparator. Args: similarity_threshold: The ratio threshold for `are_texts_similar`.

Initializes the LLM interface for a specific backend and model. Args: backend: The name of the LLM backend to use (e.g.,

Initializes the generation context. Args: llm: The LLM instance to use for generation. prompt: The user's in

Initializes the TextContext processor. Sets up the characters used to determine valid context boundaries. Args:

Initializes the TranscriptionProcessor. Args: source_language: Language code for transcription (e.g., "en").

Initializes the UpsampleOverlap processor. Sets up the internal state required for tracking previous audio chunks and their

Initializes the AudioInputProcessor. Args: language: Target language code for transcription (e.g., "en"). is

Initializes the TranscriptionCallbacks instance for a WebSocket connection. Args: app: The FastAPI application instance

Initializes the TurnDetection instance. Loads the sentence classification model and tokenizer, sets up internal state (deque