{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-faster-whisper","slug":"pypi-faster-whisper","name":"faster-whisper","type":"repo","url":"https://github.com/SYSTRAN/faster-whisper","page_url":"https://unfragile.ai/pypi-faster-whisper","categories":["voice-audio"],"tags":["openai","whisper","speech","ctranslate2","inference","quantization","transformer"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-faster-whisper__cap_0","uri":"capability://data.processing.analysis.ctranslate2.accelerated.speech.to.text.transcription","name":"ctranslate2-accelerated speech-to-text transcription","description":"Reimplements OpenAI's Whisper ASR model using CTranslate2, a specialized inference engine for Transformer models that applies operator-level optimizations (graph compilation, memory pooling, quantization-aware kernels) to achieve 4x faster transcription than the original implementation while maintaining identical accuracy. The WhisperModel class wraps CTranslate2's compiled model format, enabling CPU and GPU inference with automatic device selection and fallback mechanisms.","intents":["I need to transcribe audio files 4x faster than openai/whisper without sacrificing accuracy","I want to run speech recognition on resource-constrained devices with lower memory footprint","I need to process large audio archives efficiently while maintaining model quality"],"best_for":["developers building production ASR pipelines with latency constraints","teams deploying speech recognition on edge devices or cost-sensitive infrastructure","researchers benchmarking Whisper performance across hardware configurations"],"limitations":["CTranslate2 compilation step required during model loading (~5-10s on first run), adds startup latency","Model format is CTranslate2-specific; cannot directly use PyTorch checkpoints without conversion","GPU acceleration requires CUDA 11.0+ or compatible hardware; CPU fallback is slower than GPU by 8-15x","No dynamic model switching mid-transcription; must reload model class to change variants"],"requires":["Python 3.8+","CTranslate2 library (installed as dependency)","PyAV for audio decoding (bundled, no FFmpeg required)","2GB+ disk space for model caching (varies by model size: tiny=39MB, large=3.1GB)"],"input_types":["audio files (MP3, WAV, FLAC, M4A, OGG, OPUS, AIFF, etc.)","raw audio bytes via file-like objects","numpy arrays (mono or stereo, 16kHz resampled internally)"],"output_types":["structured transcription objects with word-level timestamps","JSON/SRT/VTT formatted output via format_timestamp utility","confidence scores per segment"],"categories":["data-processing-analysis","inference-optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_1","uri":"capability://automation.workflow.batched.parallel.transcription.with.dynamic.scheduling","name":"batched parallel transcription with dynamic scheduling","description":"BatchedInferencePipeline class implements a queue-based parallel processing architecture that groups multiple audio files into batches and processes them through the CTranslate2 inference engine simultaneously, achieving 3-5x additional speedup over sequential WhisperModel transcription. Uses dynamic batch sizing based on available GPU/CPU memory and implements work-stealing scheduling to balance load across processing threads.","intents":["I need to transcribe hundreds of audio files and want to maximize throughput, not latency","I want to batch-process audio without managing thread pools or async orchestration myself","I need to saturate GPU memory efficiently when processing variable-length audio clips"],"best_for":["batch processing pipelines (e.g., daily transcription jobs, content moderation workflows)","teams with large audio datasets requiring high-throughput processing","applications where latency per file is less critical than overall throughput"],"limitations":["Batching introduces 100-500ms latency overhead per batch due to queue aggregation; unsuitable for real-time streaming","Batch size must be tuned manually based on GPU memory; no automatic adaptive batching","Output order may differ from input order; requires external correlation tracking","Memory usage scales linearly with batch size; OOM errors if batch exceeds available VRAM"],"requires":["Python 3.8+","WhisperModel instance (passed as dependency)","Sufficient GPU/CPU memory for batch_size × max_audio_length","Thread-safe audio file I/O (e.g., separate file handles per worker)"],"input_types":["list of audio file paths","list of audio file-like objects (BytesIO, etc.)","list of pre-decoded numpy arrays"],"output_types":["generator yielding transcription results as they complete","list of transcription objects (if materialized)","streaming results with completion callbacks"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_10","uri":"capability://data.processing.analysis.pyav.based.audio.decoding.without.ffmpeg.dependency","name":"pyav-based audio decoding without ffmpeg dependency","description":"Implements audio decoding using PyAV (Python bindings for FFmpeg libraries) bundled as a dependency, eliminating the need for separate FFmpeg installation. The decode_audio() utility supports 100+ audio formats (MP3, WAV, FLAC, M4A, OGG, OPUS, AIFF, etc.) and automatically resamples to 16kHz mono, handling format detection, channel mixing, and sample rate conversion in a single pass.","intents":["I need to decode diverse audio formats without installing FFmpeg separately","I want automatic audio preprocessing (resampling, channel mixing) without manual steps","I need reliable audio decoding that handles edge cases (corrupted headers, unusual sample rates)"],"best_for":["applications handling user-uploaded audio of unknown format","deployment environments where FFmpeg installation is restricted or unavailable","cross-platform applications requiring consistent audio handling"],"limitations":["PyAV adds ~50-100MB to package size; larger installation footprint than pure-Python alternatives","Audio decoding adds ~100-500ms overhead per file depending on format and file size","Resampling to 16kHz mono may lose information from stereo or high-sample-rate audio (mitigated by stereo diarization feature)","Some exotic audio codecs may not be supported depending on PyAV build configuration"],"requires":["Python 3.8+","PyAV library (installed as dependency)","Sufficient RAM to load entire audio file into memory (typically <500MB for most audio)"],"input_types":["audio file path (string)","file-like object (BytesIO, file handle, etc.)","raw audio bytes"],"output_types":["numpy array (mono, 16kHz, float32)","sample rate (int, typically 16000)","duration (float, seconds)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_11","uri":"capability://automation.workflow.model.conversion.pipeline.from.pytorch.to.ctranslate2.format","name":"model conversion pipeline from pytorch to ctranslate2 format","description":"Provides model conversion utilities that transform OpenAI's PyTorch Whisper checkpoints into optimized CTranslate2 format, applying graph compilation, operator fusion, and quantization during conversion. The conversion process is one-time offline operation that generates hardware-optimized model files, enabling fast inference without requiring PyTorch at runtime.","intents":["I want to convert PyTorch Whisper models to CTranslate2 format for faster inference","I need to apply quantization and optimization during model conversion, not at runtime","I want to generate optimized models for specific hardware (CPU, GPU, quantization level)"],"best_for":["model maintainers preparing optimized model releases","teams deploying custom Whisper fine-tunes with CTranslate2 optimization","research on model optimization techniques and their impact on inference speed"],"limitations":["Conversion requires PyTorch and CTranslate2 CLI tools; adds ~5-10 minutes per model","Converted models are CTranslate2-specific; cannot be used with PyTorch inference","Conversion is one-time offline operation; no dynamic conversion at runtime","Quantization during conversion is irreversible; cannot recover float32 precision from int8 model"],"requires":["Python 3.8+","PyTorch (for loading original Whisper checkpoints)","CTranslate2 CLI tools (ct2-transformers-converter)","Original Whisper model checkpoint (PyTorch format)","Disk space for both source and converted models"],"input_types":["PyTorch Whisper checkpoint path","target quantization level (float32, float16, int8)","output directory for converted model"],"output_types":["CTranslate2 model directory with compiled graphs","model metadata (size, quantization level, optimization flags)","conversion log with performance metrics"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_12","uri":"capability://text.generation.language.output.format.generation.json.srt.vtt.with.configurable.timestamps","name":"output format generation (json, srt, vtt) with configurable timestamps","description":"Provides format_timestamp() utility and output formatting options that convert transcription results into standard subtitle formats (SRT, VTT) and JSON, with configurable timestamp precision and segment boundaries. The formatter handles edge cases like overlapping segments, missing timestamps, and language-specific formatting rules.","intents":["I need to generate SRT/VTT subtitle files from transcription for video players","I want JSON output for programmatic processing and custom formatting","I need to control timestamp precision and segment boundaries for different use cases"],"best_for":["video editing and subtitle generation workflows","accessibility applications (captions, audio descriptions)","content management systems requiring standard subtitle formats"],"limitations":["SRT/VTT format has limited metadata support; confidence scores and speaker labels may be lost","Timestamp precision is limited to milliseconds; sub-millisecond precision not supported","Segment boundaries are fixed by transcription; no dynamic re-segmentation based on subtitle length","Language-specific formatting (RTL text, diacritics) may require post-processing"],"requires":["Python 3.8+","Transcription output with timestamps"],"input_types":["transcription object with segments and timestamps","output format (json, srt, vtt)","timestamp precision (milliseconds, centiseconds)"],"output_types":["SRT format (text file with sequence numbers, timestamps, text)","VTT format (WebVTT with metadata and styling)","JSON with full transcription metadata"],"categories":["text-generation-language","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_2","uri":"capability://data.processing.analysis.silero.vad.based.voice.activity.detection.and.silence.removal","name":"silero vad-based voice activity detection and silence removal","description":"Integrates Silero VAD v6 model to detect speech segments and remove silence from audio before transcription, reducing processing time by ~50% by skipping non-speech regions. The VAD pipeline operates as a preprocessing stage that segments audio into speech/non-speech chunks, filters out silence, and passes only active speech regions to the Whisper encoder, reducing token count and inference cost.","intents":["I want to skip silent portions of audio to speed up transcription and reduce token usage","I need to extract only speech segments from noisy recordings with background silence","I want to reduce transcription cost by avoiding processing non-speech audio"],"best_for":["applications processing user-generated content with variable silence (podcasts, interviews, voicemail)","cost-sensitive deployments where reducing token count directly reduces inference cost","real-time transcription pipelines where latency savings from silence removal matter"],"limitations":["VAD model adds ~100-200ms overhead per audio file for inference; not beneficial for very short clips (<5s)","Silero VAD may miss speech in very noisy environments or with heavy accents; false negatives possible","Requires separate model download and caching (~50MB); adds to initial setup time","VAD operates at fixed sample rate (16kHz); audio resampling required if source differs"],"requires":["Python 3.8+","Silero VAD model (auto-downloaded from Hugging Face on first use)","PyTorch or ONNX runtime for VAD inference","Audio resampled to 16kHz mono (handled internally by faster-whisper)"],"input_types":["raw audio waveform (numpy array, 16kHz mono)","audio file paths (auto-decoded to waveform)"],"output_types":["list of (start_time, end_time) tuples marking speech segments","filtered audio waveform with silence removed","segmented transcription with speech/silence boundaries"],"categories":["data-processing-analysis","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_3","uri":"capability://data.processing.analysis.word.level.timestamp.alignment.via.cross.attention.mechanism","name":"word-level timestamp alignment via cross-attention mechanism","description":"Extracts word-level timestamps by analyzing cross-attention weights between the Whisper decoder and encoder outputs, mapping each decoded token to its corresponding audio time region. The mechanism leverages the Transformer's attention patterns to align subword tokens to audio frames, then aggregates token-level alignments into word-level boundaries without requiring external alignment models or post-processing.","intents":["I need precise word-level timestamps for subtitle generation or audio synchronization","I want to identify exactly when each word was spoken without running a separate alignment model","I need to generate SRT/VTT files with accurate word timing from transcription"],"best_for":["subtitle generation pipelines requiring frame-accurate timing","video editing tools needing word-level sync points","accessibility applications (captions, audio descriptions) requiring precise timing"],"limitations":["Alignment accuracy degrades in noisy audio or heavy accents; ±100-200ms error possible","Cross-attention extraction adds ~5-10% overhead to transcription latency","Subword tokenization (BPE) requires aggregation to word level; some tokens may not align cleanly","Timestamps are relative to audio start; no absolute wall-clock time without external sync"],"requires":["Python 3.8+","WhisperModel with attention weights accessible (not quantized to int8, which may lose precision)","Audio sample rate known (typically 16kHz)"],"input_types":["audio file or waveform","transcription output with attention weights"],"output_types":["list of (word, start_time, end_time) tuples","SRT/VTT subtitle format with word-level timing","JSON with word boundaries and confidence scores"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_4","uri":"capability://data.processing.analysis.multi.language.auto.detection.with.99.language.support","name":"multi-language auto-detection with 99-language support","description":"Automatically detects the language of input audio by processing the first 30 seconds through Whisper's language identification head, which outputs probability scores across 99 supported languages. The detection runs as a lightweight preprocessing step before full transcription, enabling single-pass multilingual pipelines without requiring language hints or separate language detection models.","intents":["I need to automatically detect audio language before transcribing without user input","I want to build a multilingual transcription service that handles mixed-language content","I need language probabilities to assess confidence in transcription language choice"],"best_for":["multilingual content platforms (e.g., international news, global customer support)","applications processing user-uploaded audio of unknown language","research on language identification accuracy across diverse audio conditions"],"limitations":["Detection accuracy drops below 90% for languages with <1 hour training data in Whisper's dataset","Requires 30-second audio sample minimum; very short clips (<5s) have unreliable detection","Cannot detect code-switching (multiple languages in single audio); returns dominant language only","Detection adds ~500ms-1s overhead per audio file (separate inference pass)"],"requires":["Python 3.8+","WhisperModel instance with language detection enabled (default)","Audio sample of at least 30 seconds for reliable detection"],"input_types":["audio file path","audio waveform (numpy array, 16kHz mono)","audio bytes"],"output_types":["detected language code (e.g., 'en', 'fr', 'zh')","probability scores for top-N languages","confidence threshold (0.0-1.0)"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_5","uri":"capability://data.processing.analysis.quantization.aware.model.compression.with.int8.and.float16.precision","name":"quantization-aware model compression with int8 and float16 precision","description":"Supports 8-bit integer quantization (int8) and float16 precision modes during model loading, reducing model size by 35-50% and memory footprint proportionally while maintaining >99% accuracy. Quantization is applied at the CTranslate2 model conversion stage, not runtime, enabling hardware-accelerated quantized inference on CPUs and GPUs that support int8 operations.","intents":["I need to reduce model memory footprint by 35-50% to fit on edge devices or reduce GPU VRAM requirements","I want to trade minimal accuracy loss for significant speedup on quantization-friendly hardware","I need to deploy multiple Whisper models simultaneously on resource-constrained infrastructure"],"best_for":["edge deployment (mobile, IoT, embedded systems) with <2GB RAM","multi-model serving scenarios where model size directly impacts deployment cost","latency-sensitive applications on quantization-optimized hardware (ARM, NVIDIA Jetson)"],"limitations":["int8 quantization may reduce accuracy by 0.5-1.5% on very noisy audio; not suitable for high-precision applications","Quantized models are hardware-specific; int8 models require CPU/GPU with int8 support (most modern hardware has this)","Quantization is applied during model conversion; cannot quantize on-the-fly at runtime","float16 precision requires GPU; CPU inference with float16 is slower than float32 due to lack of native support"],"requires":["Python 3.8+","CTranslate2 with quantization support (included in standard installation)","Hardware supporting target precision (int8 on most modern CPUs/GPUs, float16 on NVIDIA/AMD GPUs)"],"input_types":["model variant selection (e.g., 'base', 'small', 'medium')","precision parameter (int8, float16, float32)"],"output_types":["quantized model loaded in memory","memory usage metrics (original vs. quantized size)","accuracy benchmarks (WER on test sets)"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_6","uri":"capability://text.generation.language.hotword.and.prefix.biasing.for.domain.specific.transcription","name":"hotword and prefix biasing for domain-specific transcription","description":"Accepts a list of hotwords and optional prefix text that biases the Whisper decoder toward recognizing specific terms or continuing with expected text patterns. The biasing mechanism modifies token logits during beam search decoding, increasing probability of hotword tokens and prefix-consistent sequences, enabling domain-specific transcription without fine-tuning.","intents":["I need to improve recognition of domain-specific terms (e.g., product names, medical terminology) without retraining","I want to guide transcription toward expected content (e.g., 'this is a meeting about...' prefix)","I need to reduce hallucinations of common misrecognized words in my domain"],"best_for":["domain-specific transcription (medical, legal, technical documentation)","applications with known vocabulary (e.g., customer service with product names)","scenarios where hotword lists can be dynamically updated per session"],"limitations":["Hotword biasing may suppress correct transcription if hotwords conflict with actual speech; requires careful curation","Biasing adds ~5-10% latency overhead during beam search due to logit modification","Hotwords must be subword-tokenizable by Whisper's tokenizer; some special characters may not work","No quantitative accuracy improvement guarantee; effectiveness depends on domain and hotword relevance"],"requires":["Python 3.8+","WhisperModel instance","List of hotwords (strings, e.g., ['COVID-19', 'mRNA', 'vaccine'])","Optional prefix text (string)"],"input_types":["audio file or waveform","hotwords list (list of strings)","prefix text (string, optional)"],"output_types":["transcription with hotword-biased tokens","confidence scores reflecting bias influence"],"categories":["text-generation-language","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_7","uri":"capability://planning.reasoning.configurable.beam.search.decoding.with.temperature.fallback","name":"configurable beam search decoding with temperature fallback","description":"Implements beam search decoding with configurable beam width (default 5) and temperature-based fallback mechanism. If beam search fails to produce valid output (e.g., due to numerical instability), the decoder automatically falls back to temperature-sampled decoding with adjustable temperature parameter, ensuring robustness across diverse audio conditions without requiring user intervention.","intents":["I need to balance transcription quality (beam search) with robustness (temperature fallback) automatically","I want to tune decoding behavior for different audio quality levels without manual intervention","I need to ensure transcription completes even on edge-case audio that breaks standard beam search"],"best_for":["production systems handling diverse, uncontrolled audio sources","applications requiring high reliability with graceful degradation","research on decoding strategy robustness across audio conditions"],"limitations":["Beam search adds ~10-20% latency overhead vs. greedy decoding; larger beam widths increase latency quadratically","Temperature fallback may produce lower-quality transcriptions; no guarantee of accuracy preservation","Beam width tuning is manual; no automatic adaptive beam sizing based on audio quality","Temperature parameter requires domain-specific tuning; default may not suit all use cases"],"requires":["Python 3.8+","WhisperModel instance","Beam width parameter (int, default 5, range 1-10)","Temperature parameter (float, default 0.0, range 0.0-1.0)"],"input_types":["audio file or waveform","beam_width parameter","temperature parameter"],"output_types":["transcription text","decoding method used (beam_search or temperature_sampling)","confidence scores"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_8","uri":"capability://data.processing.analysis.stereo.diarization.with.left.right.channel.separation","name":"stereo diarization with left/right channel separation","description":"Processes stereo audio by separating left and right channels and transcribing each independently, then merging results with channel labels to enable speaker diarization without external speaker separation models. The mechanism treats each channel as a separate audio stream, assigns speaker labels based on channel identity, and reconstructs timeline with speaker boundaries.","intents":["I need to transcribe stereo recordings where speakers are on separate channels (e.g., phone calls, interviews)","I want basic speaker diarization without running separate speaker identification models","I need to generate transcripts with speaker labels from stereo audio"],"best_for":["phone call transcription (caller on left, recipient on right)","interview/podcast recordings with pre-separated channels","applications where channel-based speaker separation is sufficient (vs. full speaker diarization)"],"limitations":["Only works for stereo audio with speakers on separate channels; fails if speakers are mixed in both channels","No speaker identification; labels are channel-based ('Speaker 1', 'Speaker 2'), not speaker names","Requires manual channel assignment; no automatic detection of which channel contains which speaker","Stereo processing doubles inference time vs. mono (two separate transcription passes)"],"requires":["Python 3.8+","Stereo audio file or waveform (2 channels)","WhisperModel instance"],"input_types":["stereo audio file (MP3, WAV, FLAC, etc.)","stereo waveform (numpy array, shape [2, samples])"],"output_types":["transcription with speaker labels per segment","JSON with speaker boundaries and channel assignment","SRT/VTT with speaker labels"],"categories":["data-processing-analysis","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-faster-whisper__cap_9","uri":"capability://automation.workflow.automatic.model.downloading.and.caching.from.hugging.face.hub","name":"automatic model downloading and caching from hugging face hub","description":"Provides download_model() utility that automatically fetches pre-converted CTranslate2 models from Hugging Face Hub, caches them locally with integrity verification, and manages model versioning. The caching mechanism uses content-addressable storage (hash-based paths) to prevent corruption and enable atomic updates, with configurable cache directory and automatic cleanup of unused models.","intents":["I want to automatically download and cache Whisper models without manual conversion or setup","I need reliable model caching with corruption detection and atomic updates","I want to manage multiple model versions without disk space conflicts"],"best_for":["developers building applications that auto-download models on first run","CI/CD pipelines requiring reproducible model caching","multi-user systems where model cache must be shared safely"],"limitations":["Initial download can be slow (100MB-3GB depending on model size); no resume capability for interrupted downloads","Cache directory must have sufficient disk space; no automatic cleanup of old versions","Requires internet connectivity for first-time model download; no offline mode","Hugging Face Hub rate limiting may apply for high-volume downloads"],"requires":["Python 3.8+","Internet connectivity for initial download","Disk space: 100MB (tiny) to 3.1GB (large-v3)","Hugging Face Hub access (public models, no authentication required)"],"input_types":["model name (string, e.g., 'base', 'small', 'medium', 'large-v3')","cache directory path (optional, defaults to ~/.cache/faster-whisper)"],"output_types":["local path to cached model directory","model metadata (size, hash, version)"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":28,"verified":false,"data_access_risk":"low","permissions":["Python 3.8+","CTranslate2 library (installed as dependency)","PyAV for audio decoding (bundled, no FFmpeg required)","2GB+ disk space for model caching (varies by model size: tiny=39MB, large=3.1GB)","WhisperModel instance (passed as dependency)","Sufficient GPU/CPU memory for batch_size × max_audio_length","Thread-safe audio file I/O (e.g., separate file handles per worker)","PyAV library (installed as dependency)","Sufficient RAM to load entire audio file into memory (typically <500MB for most audio)","PyTorch (for loading original Whisper checkpoints)"],"failure_modes":["CTranslate2 compilation step required during model loading (~5-10s on first run), adds startup latency","Model format is CTranslate2-specific; cannot directly use PyTorch checkpoints without conversion","GPU acceleration requires CUDA 11.0+ or compatible hardware; CPU fallback is slower than GPU by 8-15x","No dynamic model switching mid-transcription; must reload model class to change variants","Batching introduces 100-500ms latency overhead per batch due to queue aggregation; unsuitable for real-time streaming","Batch size must be tuned manually based on GPU memory; no automatic adaptive batching","Output order may differ from input order; requires external correlation tracking","Memory usage scales linearly with batch size; OOM errors if batch exceeds available VRAM","PyAV adds ~50-100MB to package size; larger installation footprint than pure-Python alternatives","Audio decoding adds ~100-500ms overhead per file depending on format and file size","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:05.295Z","last_scraped_at":"2026-05-03T15:20:20.420Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=pypi-faster-whisper","compare_url":"https://unfragile.ai/compare?artifact=pypi-faster-whisper"}},"signature":"PIop4txiy5M+VAgunbj0yX7dWMniX3pH63mh1QNQnAcNacUCqUiqiqRMFExICafxYFNpOGuosgA5r8QWzXLyBw==","signedAt":"2026-06-20T21:45:43.833Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-faster-whisper","artifact":"https://unfragile.ai/pypi-faster-whisper","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-faster-whisper","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}