Skip to content

Speakr is a personal, self-hosted web application designed for transcribing audio recordings

Python
11.0 KB
Raw Blame
"""
Application configuration and initialization.
"""

import os
import sys
import httpx
from openai import OpenAI

from src.audio_chunking import AudioChunkingService
from src.config.version import get_version

# Configuration from environment
TEXT_MODEL_API_KEY = os.environ.get("TEXT_MODEL_API_KEY")
TEXT_MODEL_BASE_URL = os.environ.get("TEXT_MODEL_BASE_URL", "https://openrouter.ai/api/v1")
if TEXT_MODEL_BASE_URL:
    TEXT_MODEL_BASE_URL = TEXT_MODEL_BASE_URL.split('#')[0].strip()
TEXT_MODEL_NAME = os.environ.get("TEXT_MODEL_NAME", "openai/gpt-3.5-turbo")

transcription_api_key = os.environ.get("TRANSCRIPTION_API_KEY", "")
transcription_base_url = os.environ.get("TRANSCRIPTION_BASE_URL", "")
if transcription_base_url:
    transcription_base_url = transcription_base_url.split('#')[0].strip()

# New transcription connector configuration
# TRANSCRIPTION_CONNECTOR: explicit connector name (openai_whisper, openai_transcribe, asr_endpoint)
# TRANSCRIPTION_MODEL: model to use (e.g., gpt-4o-transcribe-diarize for diarization)
TRANSCRIPTION_CONNECTOR = os.environ.get('TRANSCRIPTION_CONNECTOR', '').lower().strip()
TRANSCRIPTION_MODEL = os.environ.get('TRANSCRIPTION_MODEL', '')
if TRANSCRIPTION_MODEL:
    TRANSCRIPTION_MODEL = TRANSCRIPTION_MODEL.split('#')[0].strip()

# Optional comma-separated list of transcription models the user can pick from
# at upload/reprocess time, or set as a default on a tag/folder. When empty,
# the model dropdown is hidden and TRANSCRIPTION_MODEL above is the only model.
# Example: TRANSCRIPTION_MODELS_AVAILABLE=whisper-1,gpt-4o-transcribe,gpt-4o-transcribe-diarize
# Optional parallel labels: TRANSCRIPTION_MODEL_LABELS=Whisper,GPT-4o,GPT-4o Diarize
def _parse_models_csv(raw):
    return [m.strip() for m in raw.split(',') if m.strip()]

TRANSCRIPTION_MODELS_AVAILABLE = _parse_models_csv(os.environ.get('TRANSCRIPTION_MODELS_AVAILABLE', ''))
_labels_raw = os.environ.get('TRANSCRIPTION_MODEL_LABELS', '')
_labels = _parse_models_csv(_labels_raw)
# Pair each model with a label, falling back to the model id if no label given.
TRANSCRIPTION_MODEL_OPTIONS = [
    {'value': m, 'label': _labels[i] if i < len(_labels) else m}
    for i, m in enumerate(TRANSCRIPTION_MODELS_AVAILABLE)
]

# Feature flag for new transcription architecture (default: enabled)
USE_NEW_TRANSCRIPTION_ARCHITECTURE = os.environ.get(
    'USE_NEW_TRANSCRIPTION_ARCHITECTURE', 'true'
).lower() == 'true'

USE_ASR_ENDPOINT = os.environ.get('USE_ASR_ENDPOINT', 'false').lower() == 'true'
ASR_BASE_URL = os.environ.get('ASR_BASE_URL')
if ASR_BASE_URL:
    ASR_BASE_URL = ASR_BASE_URL.split('#')[0].strip()

# The ASR connector is active with ASR_BASE_URL alone, or by name; the
# USE_ASR_ENDPOINT flag is deprecated. Reading these settings only behind the
# flag dropped ASR_MIN_SPEAKERS / ASR_MAX_SPEAKERS for every installation set
# up as documented (#415).
_ASR_CONNECTOR_ACTIVE = (
    USE_ASR_ENDPOINT
    or bool(ASR_BASE_URL)
    or os.environ.get('TRANSCRIPTION_CONNECTOR', '').strip().lower() == 'asr_endpoint'
)

if _ASR_CONNECTOR_ACTIVE:
    ASR_DIARIZE = os.environ.get('ASR_DIARIZE', 'true').lower() == 'true'
    ASR_MIN_SPEAKERS = os.environ.get('ASR_MIN_SPEAKERS')
    ASR_MAX_SPEAKERS = os.environ.get('ASR_MAX_SPEAKERS')
    # Speaker embeddings are only supported by WhisperX ASR service, not the basic whisper-asr-webservice
    ASR_RETURN_SPEAKER_EMBEDDINGS = os.environ.get('ASR_RETURN_SPEAKER_EMBEDDINGS', 'false').lower() == 'true'
else:
    ASR_DIARIZE = False
    ASR_MIN_SPEAKERS = None
    ASR_MAX_SPEAKERS = None
    ASR_RETURN_SPEAKER_EMBEDDINGS = False

# ASR chunking configuration - enables app-level chunking for self-hosted ASR services
# that may crash on long files due to GPU memory exhaustion
ASR_ENABLE_CHUNKING = os.environ.get('ASR_ENABLE_CHUNKING', 'false').lower() == 'true'
ASR_MAX_DURATION_SECONDS = int(os.environ.get('ASR_MAX_DURATION_SECONDS', '7200'))  # 2 hours default

ENABLE_CHUNKING = os.environ.get('ENABLE_CHUNKING', 'true').lower() == 'true'
CHUNK_SIZE_MB = int(os.environ.get('CHUNK_SIZE_MB', '20'))
CHUNK_OVERLAP_SECONDS = int(os.environ.get('CHUNK_OVERLAP_SECONDS', '3'))

# Audio compression settings - compress lossless uploads (WAV, AIFF) to save storage
AUDIO_COMPRESS_UPLOADS = os.environ.get('AUDIO_COMPRESS_UPLOADS', 'true').lower() == 'true'
AUDIO_CODEC = os.environ.get('AUDIO_CODEC', 'mp3').lower()  # mp3, flac, opus
AUDIO_BITRATE = os.environ.get('AUDIO_BITRATE', '128k')  # For lossy codecs

# Video passthrough - send original video files directly to ASR without extracting audio
# Useful for custom ASR backends that handle video/multi-track audio internally
VIDEO_PASSTHROUGH_ASR = os.environ.get('VIDEO_PASSTHROUGH_ASR', 'false').lower() == 'true'

# File storage backend configuration (dual local / S3-compatible)
UPLOAD_FOLDER = os.environ.get('UPLOAD_FOLDER', '/data/uploads')
FILE_STORAGE_BACKEND = os.environ.get('FILE_STORAGE_BACKEND', 'local').lower().strip()  # local | s3
FILE_STORAGE_KEY_PREFIX = (os.environ.get('FILE_STORAGE_KEY_PREFIX', 'recordings') or 'recordings').strip().strip('/')
FILE_STORAGE_STAGING_DIR = os.environ.get('FILE_STORAGE_STAGING_DIR', '').strip() or os.path.join(UPLOAD_FOLDER, '_staging')
S3_BUCKET_NAME = os.environ.get('S3_BUCKET_NAME', '').strip() or None
S3_REGION = os.environ.get('S3_REGION', '').strip() or None
S3_ENDPOINT_URL = os.environ.get('S3_ENDPOINT_URL', '').strip() or None
if S3_ENDPOINT_URL and not S3_ENDPOINT_URL.startswith(('http://', 'https://')):
    S3_ENDPOINT_URL = f'https://{S3_ENDPOINT_URL}'
S3_INTRANET_ENDPOINT_URL = os.environ.get('S3_INTRANET_ENDPOINT_URL', '').strip() or None
if S3_INTRANET_ENDPOINT_URL and not S3_INTRANET_ENDPOINT_URL.startswith(('http://', 'https://')):
    S3_INTRANET_ENDPOINT_URL = f'https://{S3_INTRANET_ENDPOINT_URL}'
S3_ACCESS_KEY_ID = os.environ.get('S3_ACCESS_KEY_ID', '').strip() or None
S3_SECRET_ACCESS_KEY = os.environ.get('S3_SECRET_ACCESS_KEY', '').strip() or None
S3_SESSION_TOKEN = os.environ.get('S3_SESSION_TOKEN', '').strip() or None
S3_USE_PATH_STYLE = os.environ.get('S3_USE_PATH_STYLE', 'false').lower() == 'true'
S3_VERIFY_SSL = os.environ.get('S3_VERIFY_SSL', 'true').lower() == 'true'
S3_PRESIGN_TTL_SECONDS = int(os.environ.get('S3_PRESIGN_TTL_SECONDS', '900'))
S3_PRESIGN_PUBLIC_TTL_SECONDS = int(os.environ.get('S3_PRESIGN_PUBLIC_TTL_SECONDS', '300'))

# Unsupported codecs - comma-separated list of codecs to exclude from the default supported list
# Useful when your transcription service doesn't support certain codecs (e.g., vllm doesn't support opus)
# Example: AUDIO_UNSUPPORTED_CODECS=opus,vorbis
_unsupported_codecs_str = os.environ.get('AUDIO_UNSUPPORTED_CODECS', '')
AUDIO_UNSUPPORTED_CODECS = {c.strip().lower() for c in _unsupported_codecs_str.split(',') if c.strip()}

# Email verification configuration
ENABLE_EMAIL_VERIFICATION = os.environ.get('ENABLE_EMAIL_VERIFICATION', 'false').lower() == 'true'
REQUIRE_EMAIL_VERIFICATION = os.environ.get('REQUIRE_EMAIL_VERIFICATION', 'false').lower() == 'true'
SMTP_HOST = os.environ.get('SMTP_HOST', '')
SMTP_PORT = int(os.environ.get('SMTP_PORT', '587'))
SMTP_USERNAME = os.environ.get('SMTP_USERNAME', '')
SMTP_PASSWORD = os.environ.get('SMTP_PASSWORD', '')
SMTP_USE_TLS = os.environ.get('SMTP_USE_TLS', 'true').lower() == 'true'
SMTP_USE_SSL = os.environ.get('SMTP_USE_SSL', 'false').lower() == 'true'
SMTP_FROM_ADDRESS = os.environ.get('SMTP_FROM_ADDRESS', '[email protected]')
SMTP_FROM_NAME = os.environ.get('SMTP_FROM_NAME', 'Speakr')

# Create chunking service at module level so it can be imported by processing.py
# Always initialize the service - the needs_chunking() method will check ENABLE_CHUNKING
# and return False when appropriate. This allows connectors with hard limits (e.g.,
# max_duration_seconds) to still enforce chunking even when ENABLE_CHUNKING=false.
chunking_service = AudioChunkingService(CHUNK_SIZE_MB, CHUNK_OVERLAP_SECONDS)


def initialize_config(app):
    """Initialize application configuration."""
    app_headers = {
        "HTTP-Referer": "https://github.com/murtaza-nasir/speakr",
        "X-Title": "Speakr - AI Audio Transcription",
        "User-Agent": "Speakr/1.0 (https://github.com/murtaza-nasir/speakr)"
    }

    http_client_no_proxy = httpx.Client(verify=True, headers=app_headers)

    client = None
    try:
        from src.services.llm import llm_timeout, LLM_MAX_RETRIES, TEXT_MODEL_CONFIGURED
        if not TEXT_MODEL_CONFIGURED:
            raise RuntimeError("no text model configured (set TEXT_MODEL_BASE_URL, and TEXT_MODEL_API_KEY for a hosted service)")
        api_key = TEXT_MODEL_API_KEY or "not-needed"
        client = OpenAI(api_key=api_key, base_url=TEXT_MODEL_BASE_URL, http_client=http_client_no_proxy, timeout=llm_timeout, max_retries=LLM_MAX_RETRIES)
        app.logger.info(f"LLM client initialized: {TEXT_MODEL_BASE_URL} / {TEXT_MODEL_NAME}")
    except Exception as e:
        app.logger.error(f"Failed to initialize LLM client: {e}")

    # Use module-level chunking_service (already created above)
    version = get_version()

    app.logger.info(f"=== Speakr {version} Starting Up ===")

    # Initialize transcription connector
    if USE_NEW_TRANSCRIPTION_ARCHITECTURE:
        try:
            from src.services.transcription import get_registry
            registry = get_registry()
            connector = registry.initialize_from_env()
            connector_name = registry.get_active_connector_name()
            capabilities = [c.name for c in connector.get_capabilities()]
            app.logger.info(f"Transcription connector initialized: {connector_name}")
            app.logger.info(f"Connector capabilities: {capabilities}")

            # Log diarization support prominently
            diarize_default = getattr(connector, 'default_diarize', connector.supports_diarization)
            if not connector.supports_diarization:
                app.logger.info("Speaker diarization: NOT AVAILABLE (connector does not support it)")
            elif not diarize_default:
                app.logger.info("Speaker diarization: DISABLED (ASR_DIARIZE=false)")
            else:
                app.logger.info("Speaker diarization: ENABLED")

        except Exception as e:
            app.logger.error(f"Failed to initialize transcription connector: {e}")
            app.logger.error("Falling back to legacy transcription configuration validation")
            # Fall through to legacy validation
            _validate_legacy_transcription_config(app)
    else:
        # Legacy configuration validation
        _validate_legacy_transcription_config(app)

    return client, chunking_service, version


def _validate_legacy_transcription_config(app):
    """Validate legacy transcription configuration (backwards compatibility)."""
    if USE_ASR_ENDPOINT:
        if not ASR_BASE_URL:
            app.logger.error("ERROR: ASR enabled but ASR_BASE_URL not configured!")
            sys.exit(1)
        app.logger.info(f"Using ASR endpoint: {ASR_BASE_URL}")
    else:
        if not transcription_base_url or not transcription_api_key:
            app.logger.error("ERROR: No transcription service configured!")
            sys.exit(1)
        app.logger.info(f"Using Whisper API: {transcription_base_url}")