initial commit

Dockerfile

@@ -0,0 +1,63 @@
+# ===========================================
+#
+# THIS IS A GENERATED DOCKERFILE. DO NOT EDIT
+#
+# ===========================================
+
+# Block SETUP_BENTO_BASE_IMAGE
+FROM python:3.10-slim as base-container
+
+ENV LANG=C.UTF-8
+
+ENV LC_ALL=C.UTF-8
+
+ENV PYTHONIOENCODING=UTF-8
+
+ENV PYTHONUNBUFFERED=1
+
+
+
+USER root
+
+ENV DEBIAN_FRONTEND=noninteractive
+RUN rm -f /etc/apt/apt.conf.d/docker-clean; echo 'Binary::apt::APT::Keep-Downloaded-Packages "true";' > /etc/apt/apt.conf.d/keep-cache
+RUN set -eux && \
+    apt-get update -y && \
+    apt-get install -q -y --no-install-recommends --allow-remove-essential \
+        ca-certificates gnupg2 bash build-essential ffmpeg
+# Block SETUP_BENTO_USER
+ARG BENTO_USER=bentoml
+ARG BENTO_USER_UID=1000
+ARG BENTO_USER_GID=1000
+RUN groupadd -g $BENTO_USER_GID -o $BENTO_USER && useradd -m -u $BENTO_USER_UID -g $BENTO_USER_GID -o -r $BENTO_USER
+ENV BENTOML_CONFIG=src/configuration.yaml
+ARG BENTO_PATH=/home/bentoml/bento
+ENV BENTO_PATH=$BENTO_PATH
+ENV BENTOML_HOME=/home/bentoml/
+
+RUN mkdir $BENTO_PATH && chown bentoml:bentoml $BENTO_PATH -R
+WORKDIR $BENTO_PATH
+
+
+
+# Block SETUP_BENTO_COMPONENTS
+COPY --chown=bentoml:bentoml ./env/python ./env/python/
+# install python packages with install.sh
+RUN bash -euxo pipefail /home/bentoml/bento/env/python/install.sh
+COPY --chown=bentoml:bentoml . ./
+
+# Block SETUP_BENTO_ENTRYPOINT
+RUN rm -rf /var/lib/{apt,cache,log}
+# Default port for BentoServer
+EXPOSE 7860
+
+# Expose Prometheus port
+EXPOSE 3001
+
+RUN chmod +x /home/bentoml/bento/env/docker/entrypoint.sh
+
+USER bentoml
+
+ENTRYPOINT [ "/home/bentoml/bento/env/docker/entrypoint.sh" ]
+
+

apis/openapi.yaml

@@ -0,0 +1,219 @@
+components:
+  schemas:
+    InternalServerError:
+      description: Internal Server Error
+      properties:
+        msg:
+          title: Message
+          type: string
+        type:
+          title: Error Type
+          type: string
+      required:
+      - msg
+      - type
+      title: InternalServerError
+      type: object
+    InvalidArgument:
+      description: Bad Request
+      properties:
+        msg:
+          title: Message
+          type: string
+        type:
+          title: Error Type
+          type: string
+      required:
+      - msg
+      - type
+      title: InvalidArgument
+      type: object
+    NotFound:
+      description: Not Found
+      properties:
+        msg:
+          title: Message
+          type: string
+        type:
+          title: Error Type
+          type: string
+      required:
+      - msg
+      - type
+      title: NotFound
+      type: object
+info:
+  contact:
+    email: [email protected]
+    name: BentoML Team
+  description: "# speech_to_text_pipeline:None\n\n[![pypi_status](https://img.shields.io/badge/BentoML-1.0.20-informational)](https://pypi.org/project/BentoML)\n\
+    [![documentation_status](https://readthedocs.org/projects/bentoml/badge/?version=latest)](https://docs.bentoml.org/)\n\
+    [![join_slack](https://badgen.net/badge/Join/BentoML%20Slack/cyan?icon=slack)](https://l.bentoml.com/join-slack-swagger)\n\
+    [![BentoML GitHub Repo](https://img.shields.io/github/stars/bentoml/bentoml?style=social)](https://github.com/bentoml/BentoML)\n\
+    [![Twitter Follow](https://img.shields.io/twitter/follow/bentomlai?label=Follow%20BentoML&style=social)](https://twitter.com/bentomlai)\n\
+    \nThis is a Machine Learning Service created with BentoML.\n| InferenceAPI | Input\
+    \ | Output |\n| ------------ | ----- | ------ |\n| POST [`/process_uploaded_file`](#operations-Service_APIs-speech_to_text_pipeline__process_uploaded_file)\
+    \ | BytesIOFile | JSON |\n| POST [`/zip_transcription`](#operations-Service_APIs-speech_to_text_pipeline__zip_transcription)\
+    \ | JSON | BytesIOFile |\n\n\n\n\n## Help\n\n* [\U0001F4D6 Documentation](https://docs.bentoml.org/en/latest/):\
+    \ Learn how to use BentoML.\n* [\U0001F4AC Community](https://l.bentoml.com/join-slack-swagger):\
+    \ Join the BentoML Slack community.\n* [\U0001F41B GitHub Issues](https://github.com/bentoml/BentoML/issues):\
+    \ Report bugs and feature requests.\n* Tip: you can also [customize this README](https://docs.bentoml.org/en/latest/concepts/bento.html#description).\n"
+  title: speech_to_text_pipeline
+  version: None
+openapi: 3.0.2
+paths:
+  /healthz:
+    get:
+      description: Health check endpoint. Expecting an empty response with status
+        code <code>200</code> when the service is in health state. The <code>/healthz</code>
+        endpoint is <b>deprecated</b>. (since Kubernetes v1.16)
+      responses:
+        '200':
+          description: Successful Response
+      tags:
+      - Infrastructure
+  /livez:
+    get:
+      description: Health check endpoint for Kubernetes. Healthy endpoint responses
+        with a <code>200</code> OK status.
+      responses:
+        '200':
+          description: Successful Response
+      tags:
+      - Infrastructure
+  /metrics:
+    get:
+      description: Prometheus metrics endpoint. The <code>/metrics</code> responses
+        with a <code>200</code>. The output can then be used by a Prometheus sidecar
+        to scrape the metrics of the service.
+      responses:
+        '200':
+          description: Successful Response
+      tags:
+      - Infrastructure
+  /process_uploaded_file:
+    post:
+      consumes:
+      - null
+      description: ''
+      operationId: speech_to_text_pipeline__process_uploaded_file
+      produces:
+      - application/json
+      requestBody:
+        content:
+          '*/*':
+            schema:
+              format: binary
+              type: string
+        required: true
+        x-bentoml-io-descriptor:
+          args:
+            kind: binaryio
+            mime_type: null
+          id: bentoml.io.File
+      responses:
+        200:
+          content:
+            application/json:
+              schema:
+                type: object
+          description: Successful Response
+          x-bentoml-io-descriptor:
+            args:
+              has_json_encoder: true
+              has_pydantic_model: false
+            id: bentoml.io.JSON
+        400:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/InvalidArgument'
+          description: Bad Request
+        404:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/NotFound'
+          description: Not Found
+        500:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/InternalServerError'
+          description: Internal Server Error
+      summary: "InferenceAPI(BytesIOFile \u2192 JSON)"
+      tags:
+      - Service APIs
+      x-bentoml-name: process_uploaded_file
+  /readyz:
+    get:
+      description: A <code>200</code> OK status from <code>/readyz</code> endpoint
+        indicated the service is ready to accept traffic. From that point and onward,
+        Kubernetes will use <code>/livez</code> endpoint to perform periodic health
+        checks.
+      responses:
+        '200':
+          description: Successful Response
+      tags:
+      - Infrastructure
+  /zip_transcription:
+    post:
+      consumes:
+      - application/json
+      description: ''
+      operationId: speech_to_text_pipeline__zip_transcription
+      produces:
+      - null
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+        required: true
+        x-bentoml-io-descriptor:
+          args:
+            has_json_encoder: true
+            has_pydantic_model: false
+          id: bentoml.io.JSON
+      responses:
+        200:
+          content:
+            '*/*':
+              schema:
+                format: binary
+                type: string
+          description: Successful Response
+          x-bentoml-io-descriptor:
+            args:
+              kind: binaryio
+              mime_type: null
+            id: bentoml.io.File
+        400:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/InvalidArgument'
+          description: Bad Request
+        404:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/NotFound'
+          description: Not Found
+        500:
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/InternalServerError'
+          description: Internal Server Error
+      summary: "InferenceAPI(JSON \u2192 BytesIOFile)"
+      tags:
+      - Service APIs
+      x-bentoml-name: zip_transcription
+servers:
+- url: .
+tags:
+- description: BentoML Service API endpoints for inference.
+  name: Service APIs
+- description: Common infrastructure endpoints for observability.
+  name: Infrastructure

bento.yaml

@@ -0,0 +1,64 @@
+service: service:svc
+name: speech_to_text_pipeline
+version: 4246aqrsa265utka
+bentoml_version: 1.0.20
+creation_time: '2023-08-03T14:06:11.828884+00:00'
+labels:
+  owner: modern-ai-team
+  stage: dev
+models: []
+runners:
+- name: audio_transcriber
+  runnable_type: AudioTranscriber
+  embedded: false
+  models: []
+  resource_config: null
+- name: audio_amplitude
+  runnable_type: AudioAmplitude
+  embedded: false
+  models: []
+  resource_config: null
+- name: keyword_extractor
+  runnable_type: KeywordExtractor
+  embedded: false
+  models: []
+  resource_config: null
+- name: transcription_zipper
+  runnable_type: TranscriptionZipper
+  embedded: false
+  models: []
+  resource_config: null
+apis:
+- name: process_uploaded_file
+  input_type: BytesIOFile
+  output_type: JSON
+- name: zip_transcription
+  input_type: JSON
+  output_type: BytesIOFile
+docker:
+  distro: debian
+  python_version: '3.10'
+  cuda_version: null
+  env:
+    BENTOML_CONFIG: src/configuration.yaml
+  system_packages:
+  - ffmpeg
+  setup_script: null
+  base_image: null
+  dockerfile_template: null
+python:
+  requirements_txt: ../requirements.txt
+  packages: null
+  lock_packages: null
+  index_url: null
+  no_index: null
+  trusted_host: null
+  find_links: null
+  extra_index_url: null
+  pip_args: null
+  wheels: null
+conda:
+  environment_yml: null
+  channels: null
+  dependencies: null
+  pip: null

env/docker/entrypoint.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+# check to see if this file is being run or sourced from another script
+_is_sourced() {
+	# https://unix.stackexchange.com/a/215279
+	[ "${#FUNCNAME[@]}" -ge 2 ] &&
+		[ "${FUNCNAME[0]}" = '_is_sourced' ] &&
+		[ "${FUNCNAME[1]}" = 'source' ]
+}
+
+_main() {
+	# For backwards compatibility with the yatai<1.0.0, adapting the old "yatai" command to the new "start" command.
+	if [ "${#}" -gt 0 ] && [ "${1}" = 'python' ] && [ "${2}" = '-m' ] && { [ "${3}" = 'bentoml._internal.server.cli.runner' ] || [ "${3}" = "bentoml._internal.server.cli.api_server" ]; }; then # SC2235, use { } to avoid subshell overhead
+		if [ "${3}" = 'bentoml._internal.server.cli.runner' ]; then
+			set -- bentoml start-runner-server "${@:4}"
+		elif [ "${3}" = 'bentoml._internal.server.cli.api_server' ]; then
+			set -- bentoml start-http-server "${@:4}"
+		fi
+	# If no arg or first arg looks like a flag.
+	elif [[ "$#" -eq 0 ]] || [[ "${1:0:1}" =~ '-' ]]; then
+		# This is provided for backwards compatibility with places where user may have
+		# discover this easter egg and use it in their scripts to run the container.
+		if [[ -v BENTOML_SERVE_COMPONENT ]]; then
+			echo "\$BENTOML_SERVE_COMPONENT is set! Calling 'bentoml start-*' instead"
+			if [ "${BENTOML_SERVE_COMPONENT}" = 'http_server' ]; then
+				set -- bentoml start-http-server "$@" "$BENTO_PATH"
+			elif [ "${BENTOML_SERVE_COMPONENT}" = 'grpc_server' ]; then
+				set -- bentoml start-grpc-server "$@" "$BENTO_PATH"
+			elif [ "${BENTOML_SERVE_COMPONENT}" = 'runner' ]; then
+				set -- bentoml start-runner-server "$@" "$BENTO_PATH"
+			fi
+		else
+			set -- bentoml serve "$@" "$BENTO_PATH"
+		fi
+	fi
+	# Overide the BENTOML_PORT if PORT env var is present. Used for Heroku and Yatai.
+	if [[ -v PORT ]]; then
+		echo "\$PORT is set! Overiding \$BENTOML_PORT with \$PORT ($PORT)"
+		export BENTOML_PORT=$PORT
+	fi
+	# Handle serve and start commands that is passed to the container.
+	# Assuming that serve and start commands are the first arguments
+	# Note that this is the recommended way going forward to run all bentoml containers.
+	if [ "${#}" -gt 0 ] && { [ "${1}" = 'serve' ] || [ "${1}" = 'serve-http' ] || [ "${1}" = 'serve-grpc' ] || [ "${1}" = 'start-http-server' ] || [ "${1}" = 'start-grpc-server' ] || [ "${1}" = 'start-runner-server' ]; }; then
+		exec bentoml "$@" "$BENTO_PATH"
+	else
+		# otherwise default to run whatever the command is
+		# This should allow running bash, sh, python, etc
+		exec "$@"
+	fi
+}
+
+if ! _is_sourced; then
+	_main "$@"
+fi

env/python/install.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+set -exuo pipefail
+
+# Parent directory https://stackoverflow.com/a/246128/8643197
+BASEDIR="$( cd -- "$( dirname -- "${BASH_SOURCE[0]:-$0}"; )" &> /dev/null && pwd 2> /dev/null; )"
+
+PIP_ARGS=(--no-warn-script-location)
+
+# BentoML by default generates two requirement files:
+#  - ./env/python/requirements.lock.txt: all dependencies locked to its version presented during `build`
+#  - ./env/python/requirements.txt: all dependencies as user specified in code or requirements.txt file
+REQUIREMENTS_TXT="$BASEDIR/requirements.txt"
+REQUIREMENTS_LOCK="$BASEDIR/requirements.lock.txt"
+WHEELS_DIR="$BASEDIR/wheels"
+BENTOML_VERSION=${BENTOML_VERSION:-1.0.20}
+# Install python packages, prefer installing the requirements.lock.txt file if it exist
+if [ -f "$REQUIREMENTS_LOCK" ]; then
+    echo "Installing pip packages from 'requirements.lock.txt'.."
+    pip3 install -r "$REQUIREMENTS_LOCK" "${PIP_ARGS[@]}"
+else
+    if [ -f "$REQUIREMENTS_TXT" ]; then
+        echo "Installing pip packages from 'requirements.txt'.."
+        pip3 install -r "$REQUIREMENTS_TXT" "${PIP_ARGS[@]}"
+    fi
+fi
+
+# Install user-provided wheels
+if [ -d "$WHEELS_DIR" ]; then
+    echo "Installing wheels packaged in Bento.."
+    pip3 install "$WHEELS_DIR"/*.whl "${PIP_ARGS[@]}"
+fi
+
+# Install the BentoML from PyPI if it's not already installed
+if python3 -c "import bentoml" &> /dev/null; then
+    existing_bentoml_version=$(python3 -c "import bentoml; print(bentoml.__version__)")
+    if [ "$existing_bentoml_version" != "$BENTOML_VERSION" ]; then
+        echo "WARNING: using BentoML version ${existing_bentoml_version}"
+    fi
+else
+    pip3 install bentoml=="$BENTOML_VERSION"
+fi

env/python/requirements.txt

@@ -0,0 +1,11 @@
+bentoml==1.0.20
+openai-whisper
+faster-whisper
+pydub==0.25.1
+torch==2.0.1
+torchvision==0.15.2
+torchaudio==2.0.2
+transformers==4.29.2
+yake==0.4.8
+fastapi
+python-docx

env/python/version.txt

@@ -0,0 +1 @@
+3.10.12

src/configuration.yaml

@@ -0,0 +1,14 @@
+runners:
+  timeout: 900
+
+api_server:
+  http:
+    cors:
+      enabled: True
+      access_control_allow_origins: [ "*" ]
+      access_control_allow_methods: ["GET", "OPTIONS", "POST", "HEAD", "PUT"]
+      access_control_allow_credentials: True
+      access_control_allow_headers: [ "*" ]
+      access_control_max_age: Null
+      # access_control_expose_headers: ["Content-Length"]
+      # default_max_request_size: 104857600

src/runners/audio_amplitude.py

@@ -0,0 +1,41 @@
+import bentoml
+import numpy as np
+from pydub import AudioSegment
+from pydub.utils import mediainfo
+
+
+class AudioAmplitude(bentoml.Runnable):
+    SUPPORTED_RESOURCES = ("nvidia.com/gpu", "cpu")
+    SUPPORTS_CPU_MULTI_THREADING = True
+
+    SAMPLE_RATE = 16000
+
+    def __init__(self):
+        pass
+
+    @bentoml.Runnable.method(batchable=False)
+    def get_audio_amplitude(self, temp_file_path):
+        # bit_rate = int(int(mediainfo(temp_file_path)["bit_rate"])/1000)
+        audio = AudioSegment.from_file(temp_file_path)
+
+        # get raw audio data as a bytestring
+        raw_data = audio.raw_data
+        # get the frame rate
+        sample_rate = audio.frame_rate
+        # get amount of bytes contained in one sample
+        sample_size = audio.sample_width
+        # get channels
+        channels = audio.channels
+
+        print("INFO: ", sample_rate, sample_size, channels)
+
+        audio_array = np.array(audio.get_array_of_samples())
+
+        # Normalize the audio array to values between -1 and 1
+        normalized_audio = audio_array / (2 ** 15)  # Assuming 32-bit audio
+
+        # Convert stereo to mono (average the channels)
+        if audio.channels == 2:
+            normalized_audio = (normalized_audio[::2] + normalized_audio[1::2]) / 2
+
+        return normalized_audio

src/runners/audio_transcriber.py

@@ -0,0 +1,73 @@
+import tempfile
+
+import bentoml
+import ffmpeg
+import numpy as np
+import torch
+from faster_whisper import WhisperModel
+from transformers import pipeline
+
+
+class AudioTranscriber(bentoml.Runnable):
+    SUPPORTED_RESOURCES = ("nvidia.com/gpu", "cpu")
+    SUPPORTS_CPU_MULTI_THREADING = True
+
+    SAMPLE_RATE = 16000
+
+    def __init__(self):
+        self.faster_model = WhisperModel("base")
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        # self.model.to(self.device)
+
+    @bentoml.Runnable.method(batchable=False)
+    def transcribe_audio_faster(self, temp_file_path):
+        segments, info = self.faster_model.transcribe(temp_file_path)
+        transcription = []
+        segment_info = []
+        for segment in segments:
+            print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))
+            transcription.append(segment.text)
+            segment_info.append((segment.start, segment.end))
+
+        return transcription, info, segment_info
+
+    @bentoml.Runnable.method(batchable=False)
+    def transcribe_audio(self, file):
+        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+            temp_file.write(file.read())
+            temp_file_path = temp_file.name
+
+        # Use the temporary file path as input for ffmpeg.input()
+
+        try:
+            # This launches a subprocess to decode audio while down-mixing and resampling as necessary.
+            # Requires the ffmpeg CLI and `ffmpeg-python` package to be installed.
+            out, _ = (
+                ffmpeg.input(temp_file_path, threads=0)
+                .output("-", format="s16le", acodec="pcm_s16le", ac=1, ar=self.SAMPLE_RATE)
+                .run(cmd="ffmpeg", capture_stdout=True, capture_stderr=True)
+            )
+        except ffmpeg.Error as e:
+            raise RuntimeError(f"Failed to load audio: {e.stderr.decode()}")
+
+        input_features = np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0
+
+        print("Input_features", type(input_features))
+
+        pipe = pipeline("automatic-speech-recognition",
+                        model=self.model, tokenizer=self.tokenizer, feature_extractor=self.extractor,
+                        device=self.device)
+
+        result = self.get_long_transcription_whisper(input_features, pipe)
+
+        return result
+
+    @staticmethod
+    def get_long_transcription_whisper(input_features, pipe, return_timestamps=True,
+                                       chunk_length_s=10, stride_length_s=2):
+        """Get the transcription of a long audio file using the Whisper model
+        input_feature: numpy.ndarray
+        """
+
+        return pipe(input_features, return_timestamps=return_timestamps,
+                    chunk_length_s=chunk_length_s, stride_length_s=stride_length_s)

src/runners/keyword_extractor.py

@@ -0,0 +1,18 @@
+import bentoml
+import yake
+
+
+class KeywordExtractor(bentoml.Runnable):
+    SUPPORTED_RESOURCES = ("cpu",)
+    SUPPORTS_CPU_MULTI_THREADING = False
+
+    def __init__(self, **kwargs):
+        self.keyword_extractor = yake.KeywordExtractor(**kwargs)
+
+    @bentoml.Runnable.method(batchable=False)
+    def extract_keywords(self, transcript, lang, key_count):
+        self.keyword_extractor.lan = lang
+        self.keyword_extractor.top = key_count
+        keywords = self.keyword_extractor.extract_keywords(transcript)
+        print("keywords successfully extracted")
+        return keywords

src/runners/transcription_zipper.py

@@ -0,0 +1,103 @@
+import io
+import os.path
+import zipfile
+import bentoml
+import tempfile
+from pathlib import Path
+
+from docx.enum.text import WD_COLOR_INDEX
+
+
+class TranscriptionZipper(bentoml.Runnable):
+    SUPPORTED_RESOURCES = ("nvidia.com/gpu", "cpu")
+    SUPPORTS_CPU_MULTI_THREADING = True
+
+    @bentoml.Runnable.method(batchable=False)
+    def zip_transcription(self, transcription_list):
+        zip_buffer = io.BytesIO()
+
+        for t_list in transcription_list:
+            orig_filename = t_list[0]
+            new_content = create_word_content(t_list[1], t_list[2])
+            new_content.save(orig_filename + '.docx')
+            # new_content = create_content(t_list[1], t_list[2])  # html string
+            if ".mp3" in orig_filename:
+                file_name = orig_filename.removesuffix(".mp3")
+            else:
+                file_name = orig_filename.removesuffix(".wav")
+            with zipfile.ZipFile(zip_buffer, "a") as zip_file:
+                #zip_file.writestr(file_name + ".html", new_content)
+                zip_file.write(orig_filename + '.docx')
+
+        # Return the zip file as bytes
+        return zip_buffer.getvalue()
+
+def create_word_content(old_content, new_content):
+    from docx import Document
+
+    document = Document()
+
+    # document.add_heading('Document Title', 0)
+
+    p = document.add_paragraph()
+
+    old_content = old_content.split(" ")
+    changed_content = new_content.split(" ")
+    both = [word for word in changed_content if word in old_content]
+    new_content = ""
+    i = 0
+
+    while i < len(changed_content):
+        try:
+            if changed_content[i] == old_content[i]:
+                p.add_run(" " + changed_content[i])
+                #new_content += " " + changed_content[i]
+                both.pop(0)
+                old_content.pop(0)
+                changed_content.pop(0)
+            else:
+                old_pos = old_content.index(both[0])
+                new_pos = changed_content.index(both[0])
+                p.add_run(" " + " ".join(old_content[0:old_pos])).font.strike = True
+                p.add_run(" " + " ".join(changed_content[0:new_pos])).font.highlight_color = WD_COLOR_INDEX.YELLOW
+                # new_content += " <s>" + " ".join(old_content[0:old_pos]) + "</s> "
+                # new_content += " ".join(changed_content[0:new_pos])
+                del old_content[0:old_pos]
+                del changed_content[0:new_pos]
+        except:
+            p.add_run(" ".join(old_content[i:])).font.strike = True
+            p.add_run(" ".join(changed_content[i:])).font.highlight_color = WD_COLOR_INDEX.YELLOW
+            # new_content += " <s>" + " ".join(old_content[i:]) + "</s> "
+            # new_content += " " + " ".join(changed_content[i:])
+            break
+
+    return document
+
+
+def create_content(old_content, new_content):
+    old_content = old_content.split(" ")
+    changed_content = new_content.split(" ")
+    both = [word for word in changed_content if word in old_content]
+    new_content = ""
+    i = 0
+
+    while i < len(changed_content):
+        try:
+            if changed_content[i] == old_content[i]:
+                new_content += " " + changed_content[i]
+                both.pop(0)
+                old_content.pop(0)
+                changed_content.pop(0)
+            else:
+                old_pos = old_content.index(both[0])
+                new_pos = changed_content.index(both[0])
+                new_content += " <s>" + " ".join(old_content[0:old_pos]) + "</s> "
+                new_content += " ".join(changed_content[0:new_pos])
+                del old_content[0:old_pos]
+                del changed_content[0:new_pos]
+        except:
+            new_content += " <s>" + " ".join(old_content[i:]) + "</s> "
+            new_content += " " + " ".join(changed_content[i:])
+            break
+
+    return new_content

src/service.py

@@ -0,0 +1,56 @@
+import os
+import tempfile
+
+import bentoml
+from bentoml.io import JSON, File
+
+from runners.audio_transcriber import AudioTranscriber
+from runners.keyword_extractor import KeywordExtractor
+from runners.transcription_zipper import TranscriptionZipper
+from runners.audio_amplitude import AudioAmplitude
+
+runner_audio_transcriber = bentoml.Runner(
+    AudioTranscriber,
+    name="audio_transcriber",
+)
+runner_audio_amplitude = bentoml.Runner(
+    AudioAmplitude,
+    name="audio_amplitude",
+)
+runner_keyword_extractor = bentoml.Runner(
+    KeywordExtractor,
+    name="keyword_extractor",
+)
+
+runner_transcription_zipper = bentoml.Runner(
+    TranscriptionZipper,
+    name="transcription_zipper"
+)
+
+svc = bentoml.Service(
+    "speech_to_text_pipeline",
+    runners=[
+        runner_audio_transcriber,
+        runner_audio_amplitude,
+        runner_keyword_extractor,
+        runner_transcription_zipper,
+    ],
+)
+
+
+@svc.api(input=File(), output=JSON())
+async def process_uploaded_file(file):
+    with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+        temp_file.write(file.read())
+        temp_file_path = temp_file.name
+    transcript, info, segment_info = await runner_audio_transcriber.transcribe_audio_faster.async_run(temp_file_path)
+    # amplitudes = await runner_audio_amplitude.get_audio_amplitude.async_run(temp_file_path)
+    output = {"file_name": file.name, "transcript": transcript, "language": info.language,
+              "file_size": os.stat(temp_file_path).st_size, "segments": segment_info}
+    return output
+
+
+@svc.api(input=JSON(), output=File())
+async def zip_transcription(transcription):
+    zip_file = await runner_transcription_zipper.zip_transcription.async_run(transcription)
+    return zip_file