COPY ./faster_whisper_server ./faster_whisper_server

 ENTRYPOINT ["poetry", "run"]

 CMD ["uvicorn", "faster_whisper_server.main:app"]

 ENV WHISPER_INFERENCE_DEVICE=cpu

 ENV WHISPER_COMPUTE_TYPE=int8

 ENV UVICORN_HOST=0.0.0.0

 COPY ./faster_whisper_server ./faster_whisper_server

 ENTRYPOINT ["poetry", "run"]

 CMD ["uvicorn", "faster_whisper_server.main:app"]

 ENV WHISPER_INFERENCE_DEVICE=cuda

 ENV UVICORN_HOST=0.0.0.0

 ENV UVICORN_PORT=8000

 export OPENAI_BASE_URL=http://localhost:8000/v1/

 ```

 ```bash

 ```

 ### OpenAI API Python SDK

 ```python

 audio_file = open("audio.wav", "rb")

 transcript = client.audio.transcriptions.create(

 )

 print(transcript.text)

 ```

 curl http://localhost:8000/v1/audio/transcriptions -F "file=@audio.wav"

 curl http://localhost:8000/v1/audio/transcriptions -F "file=@audio.mp3"

 curl http://localhost:8000/v1/audio/transcriptions -F "file=@audio.wav" -F "stream=true"

 # It's recommended that you always specify the language as that will reduce the transcription time

 curl http://localhost:8000/v1/audio/translations -F "file=@audio.wav"

 ```

 # ffmpeg -y -hide_banner -loglevel quiet -i audio.mp3 -ac 1 -ar 16000 -f s16le -acodec pcm_s16le audio.pcm

 # rm -f audio.mp3

 # Ensure you have `faster-whisper-server` running. If this is your first time running it expect to wait up-to a minute for the model to be downloaded and loaded into memory. You can run `curl localhost:8000/health` to check if the server is ready or watch the logs with `docker logs -f <container_id>`.

 docker run --detach --gpus=all --publish 8000:8000 --volume ~/.cache/huggingface:/root/.cache/huggingface --env WHISPER_MODEL=$WHISPER_MODEL fedirz/faster-whisper-server:0.1-cuda

 set -e

 # NOTE: do not use any distil-* model other than the large ones as they don't work on long audio files for some reason.

 # Ensure you have `faster-whisper-server` running. If this is your first time running it expect to wait up-to a minute for the model to be downloaded and loaded into memory. You can run `curl localhost:8000/health` to check if the server is ready or watch the logs with `docker logs -f <container_id>`.

 docker run --detach --gpus=all --publish 8000:8000 --volume ~/.cache/huggingface:/root/.cache/huggingface --env WHISPER_MODEL=$WHISPER_MODEL fedirz/faster-whisper-server:0.1-cuda

 # Download the audio from a YouTube video. In this example I'm downloading "The Evolution of the Operating System" by Asionometry YouTube channel. I highly checking this channel out, the guy produces very high content. If you don't have `youtube-dl`, you'll have to install it. https://github.com/ytdl-org/youtube-dl

 youtube-dl --extract-audio --audio-format mp3 -o the-evolution-of-the-operating-system.mp3 'https://www.youtube.com/watch?v=1lG7lFLXBIs'

 curl -s http://localhost:8000/v1/audio/transcriptions -F "file=@the-evolution-of-the-operating-system.mp3" -F "stream=true" -F "language=en" -F "response_format=text" | tee the-evolution-of-the-operating-system.txt

 # Here I'm using `aichat` which is a CLI LLM client. You could use any other client that supports attaching/uploading files. https://github.com/sigoden/aichat

     # I see a lot of equivalence between this new LLM OS and operating systems of today.

 class Device(enum.StrEnum):

     CPU = "cpu"

     CUDA = "cuda"

 class WhisperConfig(BaseModel):

     inference_device: Device = Field(default=Device.AUTO)

     compute_type: Quantization = Field(default=Quantization.DEFAULT)

     default_response_format: ResponseFormat = ResponseFormat.JSON

     whisper: WhisperConfig = WhisperConfig()

     max_models: int = 1

     """

     Max duration to for the next audio chunk before transcription is finilized and connection is closed.

     """

     min_duration: float = 1.0

     word_timestamp_error_margin: float = 0.2

     """

     Max allowed audio duration without any speech being detected before transcription is finilized and connection is closed.

     """

     """

     Controls how many latest seconds of audio are being passed through VAD.

     Should be greater than `max_inactivity_seconds`

     """

 config = Config()

 from faster_whisper_server.config import (

     SAMPLES_PER_SECOND,

     Language,

     ResponseFormat,

     config,

 )

 )

 from faster_whisper_server.transcriber import audio_transcriber

     if model_name in models:

         logger.debug(f"{model_name} model already loaded")

         return models[model_name]

             f"Max models ({config.max_models}) reached. Unloading the oldest model: {oldest_model_name}"

         )

         del models[oldest_model_name]

     start = time.perf_counter()

     whisper = WhisperModel(

         model_name,

         device=config.whisper.inference_device,

 @app.post("/v1/audio/translations")

 def translate_file(

     file: Annotated[UploadFile, Form()],

     prompt: Annotated[str | None, Form()] = None,

     response_format: Annotated[ResponseFormat, Form()] = config.default_response_format,

     temperature: Annotated[float, Form()] = 0.0,

 @app.post("/v1/audio/transcriptions")

 def transcribe_file(

     file: Annotated[UploadFile, Form()],

     language: Annotated[Language | None, Form()] = config.default_language,

     prompt: Annotated[str | None, Form()] = None,

     response_format: Annotated[ResponseFormat, Form()] = config.default_response_format,

 @app.websocket("/v1/audio/transcriptions")

 async def transcribe_stream(

     ws: WebSocket,

     language: Annotated[Language | None, Query()] = config.default_language,

     response_format: Annotated[

         ResponseFormat, Query()