(self, stream_id: str)

(self)

(path_value: str | None)

(self, path_value: Path)

( hidden_states: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor, )

(self)

(self, model: nn.Module)

(self, tensor: torch.Tensor)

(self, token_ids: List[int])

( self, *, inputs_embeds: torch.Tensor, past_valid_lengths: torch.Tensor,

(snapshot: WarmupSnapshot)

(value: str | None, default: bool)

(self, tensor: torch.Tensor)

(self, text: str)

(tokenizer, text: str)

(value: Any, field_name: str)

(self)

(self, reason: str)

(self)

( self, *, state: str | None = None, progress: float | None = None, me

(snapshot: SharedTextNormalizationSnapshot | None)

( *, module: nn.Module, output_path: Path, args: tuple[torch.Tensor, ...], input_names: li

()

(output_path: Path)

(waveforms: list[np.ndarray])

(value: str)

(channel_arrays: list[np.ndarray])

(self, model)

(self, *, state: str, message: str, error: str | None = None)

(self)

(self, voice_name: Optional[str])

(self)

( self, *, voice: Optional[str] = None, prompt_audio_path: Optional[str | Path

(self, frame_rows: list[list[int]])

( self, global_hidden: np.ndarray, *, text_token_id: int, audio_token_

(model, *, global_attn: str, local_attn: str)

(text: str)

(hidden_states: np.ndarray)

(nested: list[list[list[int]]])

(past_key_values: Iterable[tuple[torch.Tensor, torch.Tensor]])

(raw_execution_provider: str | None)

(path: str, base_dir: Optional[Path])

( self, requested: Optional[str], )

(raw_sample_mode: str | None, *, do_sample: bool)

( audio_logits: np.ndarray, previous_token_ids: list[int], previous_token_set: set[int], gener

( logits: torch.Tensor, seen_mask_i32: torch.Tensor, repetition_penalty_f32: torch.Tensor, )

(self, prompt_audio_codes: list[list[int]], text_token_ids: list[int])

(self, text: str)

( self, request_rows: dict[str, list[list[int]]], on_frame: Callable[[list[list[int]],

( value: Any, field_name: str, *, allow_none: bool = False, base_dir: Optional[Path] = Non

(self, relative_path: str | Path)

(self, global_hidden: np.ndarray, text_token_id: int, frame_prefix: list[int])

(self, audio_logits: np.ndarray, channel_index: int)

(self, text: str, max_tokens: int = 75)

(waveform: torch.Tensor | np.ndarray)

( self, *, sample_mode: str | None, max_new_frames: int, do_sample: bo

(values: np.ndarray)

(self, audio_codes: torch.LongTensor, *, slot_token_id: int)

(self, input_ids_i32: torch.Tensor)

(self, prefix: str)

(attention_mask: torch.Tensor)

(self)

( self, *, input_embed: torch.Tensor, present: tuple[tuple[torch.Tensor, torch

(parent: Path, required_names: Sequence[str])

(self, reason: str)

(self)

(text: str)

(model_dir: Path)

(nested: list[list[int]])

( self, *, waveform: np.ndarray, sample_rate: int, elapsed_seconds: fl

(result: dict[str, object])

(snapshot: dict[str, object])

()

(tensor: TensorProto)

(self, *, tts_attn_implementation: str)

(self, cpu_threads: int | None)

(self, tensor: torch.Tensor)

(self, tensor: torch.Tensor)

( self, codes: torch.LongTensor, *, field_name: str, index: int, )

(target_dir: Path, required_names: Sequence[str])

(text: str)

(attn_implementation: object)

(raw_sample_mode: str | None, raw_do_sample: bool = True)

(text: str)

(selected_runtime: NanoTTSService, requested_attn: str)

(self, requested: str | None)

(self, cpu_threads: int | None)

(demo_id: str)

(model_dir: str | Path | None)

(value: str | Path)

( *, demo_id: str, prompt_audio: UploadFile | None, )

( emitted_samples_total: int, sample_rate: int, first_audio_emitted_at_seconds: float | None, )

( *, text: str, voice_clone_max_text_tokens: int, cpu_threads: int, )

(self, model)

( self, *, inputs_embeds: torch.Tensor, full_attention_mask: torch.Tensor,

( text_logits: np.ndarray, manifest: dict[str, Any], generation_defaults: dict[str, Any], rng:

( values: np.ndarray, *, do_sample: bool, temperature: float, top_k: int, top_p: float

(filename: str | None)