"""WebSocket ASR server for Nemotron-Speech with true incremental streaming and timestamps.""" import asyncio import argparse import hashlib import json import os from dataclasses import dataclass, field from typing import Any, Optional, Tuple import numpy as np import torch from aiohttp import web, WSMsgType from loguru import logger from nemo.collections.asr.parts.utils.transcribe_utils import normalize_timestamp_output from nemo.collections.asr.parts.utils.timestamp_utils import process_timestamp_outputs # Enable debug logging with DEBUG_ASR=1 DEBUG_ASR = os.environ.get("DEBUG_ASR", "0") == "1" def _hash_audio(audio: np.ndarray) -> str: """Get short hash of audio array for debugging.""" if audio is None or len(audio) == 0: return "empty" return hashlib.md5(audio.tobytes()).hexdigest()[:8] # DEFAULT_MODEL = "./nemotron-speech-streaming-en-0.6b/nemotron-speech-streaming-en-0.6b.nemo" # DEFAULT_MODEL = "results/NeMo_Ja_FastConformer_Streaming/checkpoints/NeMo_Ja_FastConformer_Streaming.nemo" DEFAULT_MODEL = "results/NeMo_Ja_FastConformer_Transducer_RNNT_EOU/checkpoints/NeMo_Ja_FastConformer_Transducer_RNNT_EOU.nemo" # Right context options for att_context_size=[70, X] RIGHT_CONTEXT_OPTIONS = { 0: "~80ms ultra-low latency", 1: "~160ms low latency (recommended)", 6: "~560ms balanced", 13: "~1.12s highest accuracy", } @dataclass class ASRSession: """Per-connection session state with caches for true incremental streaming.""" id: str websocket: Any # Accumulated audio buffer (all audio received so far) accumulated_audio: Optional[np.ndarray] = None # Number of mel frames already emitted to encoder emitted_frames: int = 0 # Encoder cache state cache_last_channel: Optional[torch.Tensor] = None cache_last_time: Optional[torch.Tensor] = None cache_last_channel_len: Optional[torch.Tensor] = None # Decoder state previous_hypotheses: Any = None pred_out_stream: Any = None # Current transcription (model's cumulative output) current_text: str = "" # Current timestamps current_timestamps: Optional[dict] = None # Last text emitted to client on hard reset (for server-side deduplication) # We only send the delta (new portion) to avoid downstream duplication last_emitted_text: str = "" # Audio overlap buffer for mid-utterance reset continuity # This preserves the last N ms of audio to provide encoder left-context # when a new segment starts after a reset overlap_buffer: Optional[np.ndarray] = None class ASRServer: """WebSocket server for streaming ASR with true incremental processing.""" def __init__( self, model: str, host: str = "0.0.0.0", port: int = 8080, right_context: int = 1, ): self.model_name_or_path = model self.host = host self.port = port self.right_context = right_context self.model = None self.sample_rate = 16000 # Inference lock self.inference_lock = asyncio.Lock() # Active sessions self.sessions: dict[str, ASRSession] = {} # Model loaded flag for health check self.model_loaded = False # Streaming parameters (calculated from model config) self.shift_frames = None self.pre_encode_cache_size = None self.hop_samples = None # Audio overlap for mid-utterance reset continuity (calculated in load_model) self.overlap_samples = None def load_model(self): """Load the NeMo ASR model with streaming configuration.""" import nemo.collections.asr as nemo_asr from omegaconf import OmegaConf # Detect if model is a local .nemo file or HuggingFace model name is_local_file = ( self.model_name_or_path.endswith('.nemo') or os.path.exists(self.model_name_or_path) ) if is_local_file: logger.info(f"Loading model from local file: {self.model_name_or_path}") self.model = nemo_asr.models.ASRModel.restore_from( self.model_name_or_path, map_location='cpu' ) else: logger.info(f"Loading model from HuggingFace: {self.model_name_or_path}") self.model = nemo_asr.models.ASRModel.from_pretrained( self.model_name_or_path, map_location='cpu' ) self.model = self.model.cuda() # Configure attention context for streaming logger.info(f"Setting att_context_size=[70, {self.right_context}] ({RIGHT_CONTEXT_OPTIONS.get(self.right_context, 'custom')})") if hasattr(self.model.encoder, "set_default_att_context_size"): self.model.encoder.set_default_att_context_size([70, self.right_context]) # Configure greedy decoding (required for Blackwell GPU) logger.info("Configuring greedy decoding for Blackwell compatibility and enabling timestamps...") # Check model type to set preserve_alignments preserve_alignments = False if hasattr(self.model, 'joint'): # RNNT model preserve_alignments = True decoding_cfg_dict = { 'strategy': 'greedy', 'greedy': { 'max_symbols': 10, 'loop_labels': False, 'use_cuda_graph_decoder': False, }, 'compute_timestamps': True } if preserve_alignments: decoding_cfg_dict['preserve_alignments'] = True self.model.change_decoding_strategy( decoding_cfg=OmegaConf.create(decoding_cfg_dict) ) # Force enable timestamps if hasattr(self.model, 'decoding'): if hasattr(self.model.decoding, 'compute_timestamps'): self.model.decoding.compute_timestamps = True if hasattr(self.model.decoding, 'preserve_alignments'): self.model.decoding.preserve_alignments = preserve_alignments if hasattr(self.model.decoding, 'ctc_decoder') and hasattr(self.model.decoding.ctc_decoder, 'compute_timestamps'): self.model.decoding.ctc_decoder.compute_timestamps = True self.model.decoding.ctc_decoder.return_hypotheses = True # Force RNNT decoder settings if present if hasattr(self.model, 'joint'): if hasattr(self.model.decoding, 'rnnt_decoder_predictions_tensor'): if hasattr(self.model.decoding, 'compute_timestamps'): # We MUST set this to False during the stream step, # otherwise the internal `rnnt_decoder_predictions_tensor` will try to compute # timestamps on partial chunks and fail with length mismatch ValueError. # We will manually compute the timestamps later in `_process_chunk` / `_process_final_chunk` self.model.decoding.compute_timestamps = False if hasattr(self.model.decoding, 'preserve_alignments'): self.model.decoding.preserve_alignments = True if hasattr(self.model.decoding, 'return_hypotheses'): self.model.decoding.return_hypotheses = True self.model.eval() # Disable dither for deterministic preprocessing self.model.preprocessor.featurizer.dither = 0.0 # Get streaming config scfg = self.model.encoder.streaming_cfg logger.info(f"Streaming config: chunk_size={scfg.chunk_size}, shift_size={scfg.shift_size}") # Calculate parameters preprocessor_cfg = self.model.cfg.preprocessor hop_length_sec = preprocessor_cfg.get('window_stride', 0.01) self.hop_samples = int(hop_length_sec * self.sample_rate) # shift_size[1] = 16 frames for 160ms chunks self.shift_frames = scfg.shift_size[1] if isinstance(scfg.shift_size, list) else scfg.shift_size # pre_encode_cache_size[1] = 9 frames pre_cache = scfg.pre_encode_cache_size self.pre_encode_cache_size = pre_cache[1] if isinstance(pre_cache, list) else pre_cache # drop_extra_pre_encoded for non-first chunks self.drop_extra = scfg.drop_extra_pre_encoded # Calculate silence padding for final chunk: # - right_context chunks for encoder lookahead # - 1 additional chunk for decoder finalization # With right_context=1, this is (1+1)*160ms = 320ms self.final_padding_frames = (self.right_context + 1) * self.shift_frames padding_ms = self.final_padding_frames * hop_length_sec * 1000 # Calculate audio overlap for mid-utterance reset continuity # Use pre_encode_cache_size frames = 90ms of left-context # This allows the encoder to have proper context when starting a new segment self.overlap_samples = self.pre_encode_cache_size * self.hop_samples overlap_ms = self.overlap_samples * 1000 / self.sample_rate shift_ms = self.shift_frames * hop_length_sec * 1000 logger.info(f"Model loaded: {type(self.model).__name__}") logger.info(f"Shift size: {shift_ms:.0f}ms ({self.shift_frames} frames)") logger.info(f"Pre-encode cache: {self.pre_encode_cache_size} frames") logger.info(f"Final chunk padding: {padding_ms:.0f}ms ({self.final_padding_frames} frames)") logger.info(f"Audio overlap for resets: {overlap_ms:.0f}ms ({self.overlap_samples} samples)") # Warmup inference to ensure model is fully loaded on GPU # This prevents GPU memory issues when LLM starts later self._warmup() def _warmup(self): """Run warmup inference using streaming API to claim GPU memory.""" import time logger.info("Running warmup inference (streaming API) to claim GPU memory...") start = time.perf_counter() # Generate 1 second of silence plus padding for warmup warmup_samples = self.sample_rate + (self.final_padding_frames * self.hop_samples) warmup_audio = np.zeros(warmup_samples, dtype=np.float32) # Run streaming inference to force all CUDA kernels to compile with torch.inference_mode(): audio_tensor = torch.from_numpy(warmup_audio).unsqueeze(0).cuda() audio_len = torch.tensor([len(warmup_audio)], device='cuda') # Preprocess mel, mel_len = self.model.preprocessor(input_signal=audio_tensor, length=audio_len) # Get initial cache cache = self.model.encoder.get_initial_cache_state(batch_size=1) # Run streaming step (processes entire mel as one chunk) _ = self.model.conformer_stream_step( processed_signal=mel, processed_signal_length=mel_len, cache_last_channel=cache[0], cache_last_time=cache[1], cache_last_channel_len=cache[2], keep_all_outputs=True, previous_hypotheses=None, previous_pred_out=None, drop_extra_pre_encoded=0, return_transcription=True, ) elapsed = (time.perf_counter() - start) * 1000 logger.info(f"Warmup complete in {elapsed:.0f}ms - GPU memory claimed") def _init_session(self, session: ASRSession): """Initialize a fresh session.""" # Initialize encoder cache cache = self.model.encoder.get_initial_cache_state(batch_size=1) session.cache_last_channel = cache[0] session.cache_last_time = cache[1] session.cache_last_channel_len = cache[2] # Reset audio buffer and frame counter if session.overlap_buffer is not None and len(session.overlap_buffer) > 0: session.accumulated_audio = session.overlap_buffer.copy() overlap_ms = len(session.overlap_buffer) * 1000 / self.sample_rate logger.debug( f"Session {session.id}: prepending {len(session.overlap_buffer)} samples " f"({overlap_ms:.0f}ms) of overlap audio" ) session.overlap_buffer = None # Clear after use else: session.accumulated_audio = np.array([], dtype=np.float32) session.emitted_frames = 0 # Reset decoder state session.previous_hypotheses = None session.pred_out_stream = None session.current_text = "" session.current_timestamps = None async def websocket_handler(self, request: web.Request) -> web.WebSocketResponse: """Handle a WebSocket client connection.""" import uuid ws = web.WebSocketResponse(max_msg_size=10 * 1024 * 1024) await ws.prepare(request) session_id = str(uuid.uuid4())[:8] session = ASRSession(id=session_id, websocket=ws) self.sessions[session_id] = session logger.info(f"Client {session_id} connected") try: async with self.inference_lock: await asyncio.get_event_loop().run_in_executor( None, self._init_session, session ) await ws.send_str(json.dumps({"type": "ready"})) logger.debug(f"Client {session_id}: sent ready") async for msg in ws: if msg.type == WSMsgType.BINARY: await self._handle_audio(session, msg.data) elif msg.type == WSMsgType.TEXT: try: data = json.loads(msg.data) msg_type = data.get("type") if msg_type == "reset" or msg_type == "end": finalize = data.get("finalize", True) await self._reset_session(session, finalize=finalize) else: logger.warning(f"Client {session_id}: unknown message type: {msg_type}") except json.JSONDecodeError: logger.warning(f"Client {session_id}: invalid JSON") elif msg.type == WSMsgType.ERROR: logger.error(f"Client {session_id} WebSocket error: {ws.exception()}") break logger.info(f"Client {session_id} disconnected") except Exception as e: logger.error(f"Client {session_id} error: {e}") import traceback logger.error(traceback.format_exc()) try: await ws.send_str(json.dumps({ "type": "error", "message": str(e) })) except: pass finally: if session_id in self.sessions: del self.sessions[session_id] return ws async def _handle_audio(self, session: ASRSession, audio_bytes: bytes): """Accumulate audio and process when enough frames available.""" audio_np = np.frombuffer(audio_bytes, dtype=np.int16).astype(np.float32) / 32768.0 if DEBUG_ASR: chunk_hash = hashlib.md5(audio_bytes).hexdigest()[:8] logger.debug(f"Session {session.id}: recv chunk {len(audio_bytes)}B hash={chunk_hash}") session.accumulated_audio = np.concatenate([session.accumulated_audio, audio_np]) # Process if we have enough audio for new frames min_audio_for_chunk = (session.emitted_frames + self.shift_frames + 1) * self.hop_samples while len(session.accumulated_audio) >= min_audio_for_chunk: async with self.inference_lock: result = await asyncio.get_event_loop().run_in_executor( None, self._process_chunk, session ) if result is not None: text, timestamps = result if text is not None and text != session.current_text: session.current_text = text session.current_timestamps = timestamps logger.debug(f"Session {session.id} interim: {text[-50:] if len(text) > 50 else text}") formatted_timestamps = [] if timestamps: if isinstance(timestamps, dict): for key, val in timestamps.items(): if key != 'timestep': formatted_timestamps.append({key: normalize_timestamp_output(val)}) elif isinstance(timestamps, list): # It might be a list of dictionaries if returned directly from Hypothesis formatted_timestamps = timestamps await session.websocket.send_str(json.dumps({ "type": "transcript", "text": text, "timestamps": formatted_timestamps if formatted_timestamps else None, "is_final": False })) # Update minimum for next iteration min_audio_for_chunk = (session.emitted_frames + self.shift_frames + 1) * self.hop_samples def _decode_stream_output(self, session, pred_out_stream): """Manually decode model outputs to retrieve timestamps.""" # For RNNT models if hasattr(self.model, 'joint'): decoding = self.model.decoding transcribed_texts = [] for preds_idx, preds_concat in enumerate(pred_out_stream): # We need to reshape for RNNT decoder which expects [B, D] or [B, T, D] # preds_concat is usually [T, D] from streaming step if preds_concat.dim() == 2: preds_tensor = preds_concat.unsqueeze(0) # [1, T, D] else: preds_tensor = preds_concat encoded_len = torch.tensor([preds_tensor.size(1)], device=preds_tensor.device) # We must use decoding() directly instead of rnnt_decoder_predictions_tensor # so that hypothesis is correctly initialized with alignments before calling compute_rnnt_timestamps hypotheses_list = decoding( encoder_output=preds_tensor, encoded_lengths=encoded_len, partial_hypotheses=session.previous_hypotheses ) # decoding() returns a tuple where [0] is a list of hypotheses hypotheses_list = hypotheses_list[0] if isinstance(hypotheses_list[0], list): transcribed_texts.append(hypotheses_list[0][0]) else: transcribed_texts.append(hypotheses_list[0]) # For CTC models else: if hasattr(self.model, 'ctc_decoder'): decoding = self.model.ctc_decoding else: decoding = self.model.decoding transcribed_texts = [] for preds_idx, preds_concat in enumerate(pred_out_stream): encoded_len = torch.tensor([len(preds_concat)], device=preds_concat.device) decoded_out = decoding.ctc_decoder_predictions_tensor( decoder_outputs=preds_concat.unsqueeze(0), decoder_lengths=encoded_len, return_hypotheses=True, ) if isinstance(decoded_out[0], list): transcribed_texts.append(decoded_out[0][0]) else: transcribed_texts.append(decoded_out[0]) # process timestamps if hasattr(self.model.cfg, 'preprocessor'): window_stride = self.model.cfg.preprocessor.get('window_stride', 0.01) else: window_stride = 0.01 subsampling_factor = 1 if hasattr(self.model, 'encoder') and hasattr(self.model.encoder, 'subsampling_factor'): subsampling_factor = self.model.encoder.subsampling_factor elif hasattr(self.model, 'encoder') and hasattr(self.model.encoder, 'conv_subsampling_factor'): subsampling_factor = self.model.encoder.conv_subsampling_factor # RNNT model returns a tuple of lists containing hypotheses when using decoding() directly # We need to process the timestamps if they haven't been computed inside decoding() if hasattr(self.model, 'joint'): import copy timestamp_type = 'all' if hasattr(decoding, 'cfg'): timestamp_type = decoding.cfg.get('rnnt_timestamp_type', 'all') for i in range(len(transcribed_texts)): if hasattr(transcribed_texts[i], 'timestamp') and not transcribed_texts[i].timestamp: # Before computing timestamps, ensure the Hypothesis text contains the temporary storage # format required by `compute_rnnt_timestamps` if hasattr(transcribed_texts[i], 'y_sequence'): prediction = transcribed_texts[i].y_sequence if type(prediction) != list: prediction = prediction.tolist() # Remove any blank and possibly big blank tokens from prediction if decoding.big_blank_durations is not None and decoding.big_blank_durations != []: # multi-blank RNNT num_extra_outputs = len(decoding.big_blank_durations) prediction = [p for p in prediction if p < decoding.blank_id - num_extra_outputs] elif hasattr(decoding, '_is_tdt') and decoding._is_tdt: # TDT model. prediction = [p for p in prediction if p < decoding.blank_id] else: # standard RNN-T prediction = [p for p in prediction if p != decoding.blank_id] alignments = copy.deepcopy(transcribed_texts[i].alignments) token_repetitions = [1] * len(alignments) # Update hypothesis text to hold the tuple (prediction, alignments, token_repetitions) transcribed_texts[i].text = (prediction, alignments, token_repetitions) # Now compute the timestamps transcribed_texts[i] = decoding.compute_rnnt_timestamps(transcribed_texts[i], timestamp_type) process_timestamp_outputs(transcribed_texts, subsampling_factor=subsampling_factor, window_stride=window_stride) return transcribed_texts def _process_chunk(self, session: ASRSession) -> Optional[Tuple[str, Optional[dict]]]: """Process accumulated audio, extract new mel frames, run streaming inference.""" try: # Preprocess ALL accumulated audio audio_tensor = torch.from_numpy(session.accumulated_audio).unsqueeze(0).cuda() audio_len = torch.tensor([len(session.accumulated_audio)], device='cuda') with torch.inference_mode(): mel, mel_len = self.model.preprocessor( input_signal=audio_tensor, length=audio_len ) # Available frames (excluding last edge frame) available_frames = mel.shape[-1] - 1 new_frame_count = available_frames - session.emitted_frames if new_frame_count < self.shift_frames: return session.current_text, session.current_timestamps # Not enough new frames # Extract chunk with pre-encode cache if session.emitted_frames == 0: chunk_start = 0 chunk_end = self.shift_frames drop_extra = 0 else: chunk_start = session.emitted_frames - self.pre_encode_cache_size chunk_end = session.emitted_frames + self.shift_frames drop_extra = self.drop_extra chunk_mel = mel[:, :, chunk_start:chunk_end] chunk_len = torch.tensor([chunk_mel.shape[-1]], device='cuda') # Run streaming inference ( session.pred_out_stream, transcribed_texts, session.cache_last_channel, session.cache_last_time, session.cache_last_channel_len, session.previous_hypotheses, ) = self.model.conformer_stream_step( processed_signal=chunk_mel, processed_signal_length=chunk_len, cache_last_channel=session.cache_last_channel, cache_last_time=session.cache_last_time, cache_last_channel_len=session.cache_last_channel_len, keep_all_outputs=False, previous_hypotheses=session.previous_hypotheses, previous_pred_out=session.pred_out_stream, drop_extra_pre_encoded=drop_extra, return_transcription=True, ) # Update emitted frame count session.emitted_frames += self.shift_frames # For RNNT models, conformer_stream_step already returns the decoded hypotheses in `transcribed_texts` # (which is assigned to `best_hyp` inside the method). So we do not need to call _decode_stream_output manually. # For CTC models, if we want full hypotheses with timestamps, we still need to decode manually. if hasattr(self.model, 'joint'): # The hypotheses are directly returned in `transcribed_texts` pass else: transcribed_texts = self._decode_stream_output(session, session.pred_out_stream) if transcribed_texts and transcribed_texts[0]: hyp = transcribed_texts[0] text = hyp.text if hasattr(hyp, 'text') else str(hyp) timestamps = hyp.timestamp if hasattr(hyp, 'timestamp') else None return text, timestamps return session.current_text, session.current_timestamps except Exception as e: logger.error(f"Session {session.id} chunk processing error: {e}") import traceback logger.error(traceback.format_exc()) return None async def _reset_session(self, session: ASRSession, finalize: bool = True): """Handle reset with soft or hard finalization.""" import time # Log audio state at reset for diagnostics audio_samples = len(session.accumulated_audio) if session.accumulated_audio is not None else 0 audio_duration_ms = (audio_samples * 1000) // self.sample_rate logger.debug( f"Session {session.id} {'hard' if finalize else 'soft'} reset: " f"accumulated={audio_samples} samples ({audio_duration_ms}ms), " f"emitted={session.emitted_frames} frames" ) if not finalize: text = session.current_text timestamps = session.current_timestamps formatted_timestamps = [] if timestamps: if isinstance(timestamps, dict): for key, val in timestamps.items(): if key != 'timestep': formatted_timestamps.append({key: normalize_timestamp_output(val)}) elif isinstance(timestamps, list): formatted_timestamps = timestamps await session.websocket.send_str(json.dumps({ "type": "transcript", "text": text, "timestamps": formatted_timestamps if formatted_timestamps else None, "is_final": True, "finalize": False })) logger.debug(f"Session {session.id} soft reset: '{text[-50:] if len(text) > 50 else text}'") return # HARD RESET: Full finalization with padding original_audio_length = len(session.accumulated_audio) if session.accumulated_audio is not None else 0 if original_audio_length > 0: padding_samples = self.final_padding_frames * self.hop_samples silence_padding = np.zeros(padding_samples, dtype=np.float32) session.accumulated_audio = np.concatenate([session.accumulated_audio, silence_padding]) # Process all remaining audio with keep_all_outputs=True final_text = session.current_text final_timestamps = session.current_timestamps if session.accumulated_audio is not None and len(session.accumulated_audio) > 0: start_time = time.perf_counter() async with self.inference_lock: result = await asyncio.get_event_loop().run_in_executor( None, self._process_final_chunk, session ) if result is not None: final_text, final_timestamps = result session.current_text = final_text session.current_timestamps = final_timestamps elapsed_ms = (time.perf_counter() - start_time) * 1000 logger.debug(f"Session {session.id} final chunk processed in {elapsed_ms:.1f}ms: '{final_text[-50:] if len(final_text) > 50 else final_text}'") # Server-side deduplication: only send the delta (new portion) if final_text.startswith(session.last_emitted_text): delta_text = final_text[len(session.last_emitted_text):].lstrip() else: delta_text = final_text session.last_emitted_text = final_text formatted_timestamps = [] if final_timestamps: if isinstance(final_timestamps, dict): for key, val in final_timestamps.items(): if key != 'timestep': formatted_timestamps.append({key: normalize_timestamp_output(val)}) elif isinstance(final_timestamps, list): formatted_timestamps = final_timestamps # Send only the delta to client await session.websocket.send_str(json.dumps({ "type": "transcript", "text": delta_text, "timestamps": formatted_timestamps if formatted_timestamps else None, "is_final": True, "finalize": True })) session.last_emitted_text = "" session.overlap_buffer = None self._init_session(session) def _process_final_chunk(self, session: ASRSession) -> Optional[Tuple[str, Optional[dict]]]: """Process all remaining audio with keep_all_outputs=True.""" try: if len(session.accumulated_audio) == 0: return session.current_text, session.current_timestamps # Preprocess ALL accumulated audio audio_tensor = torch.from_numpy(session.accumulated_audio).unsqueeze(0).cuda() audio_len = torch.tensor([len(session.accumulated_audio)], device='cuda') with torch.inference_mode(): mel, mel_len = self.model.preprocessor( input_signal=audio_tensor, length=audio_len ) # For final chunk, use ALL remaining frames (including edge) total_mel_frames = mel.shape[-1] remaining_frames = total_mel_frames - session.emitted_frames if remaining_frames <= 0: return session.current_text, session.current_timestamps # Extract final chunk with pre-encode cache if session.emitted_frames == 0: chunk_start = 0 drop_extra = 0 else: chunk_start = session.emitted_frames - self.pre_encode_cache_size drop_extra = self.drop_extra chunk_mel = mel[:, :, chunk_start:] chunk_len = torch.tensor([chunk_mel.shape[-1]], device='cuda') ( session.pred_out_stream, transcribed_texts, session.cache_last_channel, session.cache_last_time, session.cache_last_channel_len, session.previous_hypotheses, ) = self.model.conformer_stream_step( processed_signal=chunk_mel, processed_signal_length=chunk_len, cache_last_channel=session.cache_last_channel, cache_last_time=session.cache_last_time, cache_last_channel_len=session.cache_last_channel_len, keep_all_outputs=True, # Final chunk - output all remaining previous_hypotheses=session.previous_hypotheses, previous_pred_out=session.pred_out_stream, drop_extra_pre_encoded=drop_extra, return_transcription=True, ) if hasattr(self.model, 'joint'): pass else: transcribed_texts = self._decode_stream_output(session, session.pred_out_stream) if transcribed_texts and transcribed_texts[0]: hyp = transcribed_texts[0] text = hyp.text if hasattr(hyp, 'text') else str(hyp) timestamps = hyp.timestamp if hasattr(hyp, 'timestamp') else None return text, timestamps return session.current_text, session.current_timestamps except Exception as e: logger.error(f"Session {session.id} final chunk error: {e}") import traceback logger.error(traceback.format_exc()) return None async def health_handler(self, request: web.Request) -> web.Response: """Health check endpoint.""" return web.json_response({ "status": "healthy" if self.model_loaded else "loading", "model_loaded": self.model_loaded, }) async def start(self): """Start the HTTP + WebSocket server.""" self.load_model() self.model_loaded = True logger.info(f"Starting streaming ASR server on ws://{self.host}:{self.port}") app = web.Application() app.router.add_get("/health", self.health_handler) app.router.add_get("/", self.websocket_handler) runner = web.AppRunner(app) await runner.setup() site = web.TCPSite(runner, self.host, self.port) await site.start() logger.info(f"ASR server listening on ws://{self.host}:{self.port}") logger.info(f"Health check available at http://{self.host}:{self.port}/health") await asyncio.Future() # Run forever def main(): parser = argparse.ArgumentParser(description="Nemotron Streaming ASR WebSocket Server") parser.add_argument("--host", default="0.0.0.0", help="Host to bind to") parser.add_argument("--port", type=int, default=8080, help="Port to bind to") parser.add_argument( "--model", default=DEFAULT_MODEL, help="HuggingFace model name or path to local .nemo file" ) parser.add_argument( "--right-context", type=int, default=1, choices=[0, 1, 6, 13], help="Right context frames: 0=80ms, 1=160ms, 6=560ms, 13=1.12s latency" ) args = parser.parse_args() server = ASRServer( model=args.model, host=args.host, port=args.port, right_context=args.right_context, ) asyncio.run(server.start()) if __name__ == "__main__": main()