import soundfile as sf

 import math

 @lru_cache

 def load_audio(fname):

     a, _ = librosa.load(fname, sr=16000, dtype=np.float32)

         from whisper_timestamped import transcribe_timestamped

         self.transcribe_timestamped = transcribe_timestamped

         if model_dir is not None:

         return whisper.load_model(modelsize, download_root=cache_dir)

     def transcribe(self, audio, init_prompt=""):

         from faster_whisper import WhisperModel

         logging.getLogger("faster_whisper").setLevel(logging.WARNING)

         if model_dir is not None:

             model_size_or_path = model_dir

         elif modelsize is not None:

             model_size_or_path = modelsize

         # Process transcription/translation

         transcript = proc.create(**params)

         return transcript

                             for j in range(i):

                                 words.append(repr(self.new.pop(0)))

                             words_msg = "\t".join(words)

                             break

     def flush(self):

         """

         prompt, non_prompt = self.prompt()

         res = self.asr.transcribe(self.audio_buffer, init_prompt=prompt)

         # transform to [(beg,end,"word1"), ...]

         o = self.transcript_buffer.flush()

         self.commited.extend(o)

         completed = self.to_flush(o)

         the_rest = self.to_flush(self.transcript_buffer.complete())

         # there is a newly confirmed text

             #while k>0 and self.commited[k][1] > l:

             #    k -= 1

             #t = self.commited[k][1] 

             #self.chunk_at(t)

         return self.to_flush(o)

     def chunk_completed_sentence(self):

         if self.commited == []: return

         sents = self.words_to_sentences(self.commited)

         for s in sents:

         if len(sents) < 2:

             return

         while len(sents) > 2:

         # we will continue with audio processing at this timestamp

         chunk_at = sents[-2][1]

         self.chunk_at(chunk_at)

     def chunk_completed_segment(self, res):

                 ends.pop(-1)

                 e = ends[-2]+self.buffer_time_offset

             if e <= t:

                 self.chunk_at(e)

             else:

         else:

         """

         o = self.transcript_buffer.complete()

         f = self.to_flush(o)

         return f

     # the following languages are in Whisper, but not in wtpsplit:

     if lan in "as ba bo br bs fo haw hr ht jw lb ln lo mi nn oc sa sd sn so su sw tk tl tt".split():

         lan = None

     from wtpsplit import WtP

     """

     backend = args.backend

     if backend == "openai-api":

         asr = OpenaiApiASR(lan=args.lan)

     else:

         if backend == "faster-whisper":

         # Only for FasterWhisperASR and WhisperTimestampedASR

         size = args.model

         t = time.time()

         asr = asr_cls(modelsize=size, lan=args.lan, cache_dir=args.model_cache_dir, model_dir=args.model_dir)

         e = time.time()

     # Apply common configurations

     if getattr(args, 'vad', False):  # Checks if VAD argument is present and True

         asr.use_vad()

     language = args.lan

     logfile = sys.stderr

     if args.offline and args.comp_unaware:

         sys.exit(1)

     audio_path = args.audio_path

     SAMPLING_RATE = 16000

     duration = len(load_audio(audio_path))/SAMPLING_RATE

     asr, online = asr_factory(args, logfile=logfile)

     min_chunk = args.min_chunk_size

             try:

                 o = online.process_iter()

             except AssertionError as e:

                 pass

             else:

                 output_transcript(o, now=end)

             if end >= duration:

                 break

             try:

                 o = online.process_iter()

             except AssertionError as e:

                 pass

             else:

                 output_transcript(o)

             now = time.time() - start

             if end >= duration:

                 break

 import logging

 import numpy as np

 parser = argparse.ArgumentParser()

 # server options

 language = args.lan

 asr, online = asr_factory(args)

 min_chunk = args.min_chunk_size

 # warm up the ASR because the very first transcribe takes more time than the others. 

 # Test results in https://github.com/ufal/whisper_streaming/pull/81

             try:

                 self.send_result(o)

             except BrokenPipeError:

                 break

 #        o = online.finish()  # this should be working

     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

     s.bind((args.host, args.port))

     s.listen(1)

     while True:

         conn, addr = s.accept()

         connection = Connection(conn)

         proc = ServerProcessor(connection, online, min_chunk)

         proc.process()

         conn.close()