code: def get_voice_streaming(
      prompt,
      language,
      latent,
      suffix="0",
      model=None,
      sr=24000,
      tts_speed=1.0,
  ):
      if model is None:
          model, supported_languages = get_xtt()
  
      gpt_cond_latent, speaker_embedding = latent
  
      try:
          t0 = time.time()
          chunks = model.inference_stream(
              prompt,
              language,
              gpt_cond_latent,
              speaker_embedding,
              repetition_penalty=7.0,
              temperature=0.85,
          )
  
          first_chunk = True
          for i, chunk in enumerate(chunks):
              if first_chunk:
                  first_chunk_time = time.time() - t0
                  first_chunk = False
              chunk = chunk.detach().cpu().numpy().squeeze()
              chunk = (chunk * 32767).astype(np.int16)
  
              chunk = chunk_speed_change(chunk, sr, tts_speed=tts_speed)
  
              yield chunk.tobytes()
  
      except RuntimeError as e:
          if "device-side assert" in str(e):
              print(
                  f"Restarted required due to exception: %s" % str(e),
                  flush=True,
              )
          else:
              print("Failed to generate wave: %s" % str(e))
      except Exception as e:
          print("Failed to generate wave: %s" % str(e))
  
imports: from __future__ import annotations
  import functools
  import io
  import os
  import tempfile
  import numpy
  import uuid
  import subprocess
  import time
  from src.tts_sentence_parsing import init_sentence_state, get_sentence, clean_sentence, detect_language
  from src.tts_utils import prepare_speech, get_no_audio, chunk_speed_change
  from src.utils import cuda_vis_check
  import torch
label_desc: Use image node_id 4 for calling a global function with example usage: get_voice_streaming(prompt, language, latent, suffix, model, sr, tts_speed) without return types