387 deploy whisper

.dockerignore

@@ -3,4 +3,5 @@ venv
 .idea
 .ssl
 __pycache__
-
+Dockerfile*
+app/playground

.github/workflows/main.yml

@@ -4,18 +4,21 @@ on: pull_request
 
 jobs:
   build:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
 
     steps:
     - uses: actions/checkout@v2
 
     - name: Build system images (non-pulling)
       run: |
         # build base image
-        docker build -f Dockerfile_base -t osll/wst_base .
+        docker build -f Dockerfile_base -t dvivanov/wst-base:v0.2 .
 
-        # build vosk
-        docker build -f "Dockerfile.kaldi-ru" -t osll/vosk .
+    - name: Decreasing whisper model for tests
+      run: |
+        cp docker-compose.yml docker-compose-tmp.yml
+        sed -e "s/ASR_MODEL=medium/ASR_MODEL=tiny/" docker-compose-tmp.yml > docker-compose.yml
+        rm docker-compose-tmp.yml
 
     - name: Build docker-compose
       run: |
@@ -29,4 +32,4 @@ jobs:
       run: |
         docker ps -a
         docker-compose logs
-        docker exec web_speech_trainer_web_1 bash -c 'cd /app/tests && pytest .'
+        docker exec web_speech_trainer_web_1 bash -c 'cd /project/tests && pytest .'

.gitignore

@@ -2,4 +2,6 @@ venv
 .idea
 ssl
 __pycache__
-/VERSION.json
+/VERSION.json
+.env
+/whisper_asr_model_cache

Dockerfile

@@ -1,17 +1,15 @@
-FROM osll/wst_base:v0.1
+FROM dvivanov/wst-base:v0.2
 
-RUN apt update
+LABEL version="0.2"
+LABEL project="wst"
 
-# The installation of `fitz` library is really tricky.
-# The library uses `frontend` internal package that can be obtained
-# via installation of `PyMuPDF` package but `PyMuPDF` itself requires `fitz`.
-# That's why `fitz` is installed separately.
-RUN pip3 install fitz==0.0.1.dev2
+WORKDIR /project
+
+COPY requirements.txt requirements.txt
+RUN pip3 install --ignore-installed --no-cache-dir -r requirements.txt
 
-WORKDIR /app
 COPY . .
+RUN rm -rf /project/tests/selenium
 
-RUN pip3 install -r requirements.txt
-ENV PYTHONPATH='/app/:/app/app/'
-WORKDIR /app/app
-CMD /bin/bash
+ENV PYTHONPATH='/project/:/project/app/'
+WORKDIR /project/app

Dockerfile_base

@@ -1,19 +1,16 @@
-FROM ubuntu:18.04
+FROM ubuntu:22.04
 ENV LANG C.UTF-8
-RUN apt-get update && apt-get install -y software-properties-common
-RUN apt-get install -y  libgconf2-4 libnss3 libxss1 python3-pip vim ffmpeg exiftool inkscape mupdf mupdf-tools wget unzip
-WORKDIR /usr/local/bin
-RUN wget https://chromedriver.storage.googleapis.com/90.0.4430.24/chromedriver_linux64.zip
-RUN unzip chromedriver_linux64.zip
-RUN wget http://dl.google.com/linux/chrome/deb/pool/main/g/google-chrome-stable/google-chrome-stable_90.0.4430.72-1_amd64.deb
-RUN apt-get install -y ./google-chrome-stable_90.0.4430.72-1_amd64.deb
-RUN pip3 install --upgrade pip==21.3.1
-RUN pip3 install --upgrade setuptools
 
-# for DB dumps
-RUN apt install -y sudo zip mongodb-clients
+LABEL version="0.2"
+LABEL project="wst"
 
-# for pptx/odp support
-RUN add-apt-repository ppa:libreoffice/ppa
-RUN apt update
-RUN apt install -y unoconv  
+RUN apt update && apt install -y software-properties-common
+RUN add-apt-repository ppa:libreoffice/ppa && apt update
+
+RUN apt install -y --no-install-recommends libgconf-2-4 libnss3 libxss1 libmagic1 python3-pip python3-dev ffmpeg exiftool inkscape mupdf mupdf-tools libmagic1 \
+    nano libreoffice-impress default-jre
+
+RUN pip3 install --upgrade pip
+
+COPY requirements.txt requirements.txt
+RUN pip3 install --ignore-installed --no-cache-dir -r requirements.txt

Dockerfile_test

@@ -0,0 +1,17 @@
+FROM selenium/standalone-chrome:121.0-chromedriver-121.0-grid-4.18.0-20240220
+
+WORKDIR /usr/src/project
+
+USER root
+RUN apt-get update && \
+    apt-get install -y python3 python3-pip && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY tests/requirements.txt requirements.txt
+RUN pip install -r requirements.txt
+
+COPY tests/selenium .
+
+ENV PYTHONPATH='/project/:/project/app/'
+
+ENTRYPOINT pytest .

app/api/dump.py

@@ -84,7 +84,7 @@ def download_dump(backup_name: str) -> (dict, int):
     if backup_name not in backup_filenames or not os.path.isfile(filepath):
         return {'message': "No such backup file: {}".format(backup_name)}, 404
 
-    return send_file(filepath, as_attachment=True, attachment_filename=backup_name)
+    return send_file(filepath, as_attachment=True, download_name=backup_name)
 
 
 def create_db_dump(name):

app/api/files.py

@@ -40,7 +40,7 @@ def get_presentation_record_file(presentation_record_file_id: str):
 
     response = make_response(send_file(
         presentation_record_file,
-        attachment_filename='{}.mp3'.format(presentation_record_file_id),
+        download_name='{}.mp3'.format(presentation_record_file_id),
         as_attachment=as_attachment,
     ))
 

app/api/sessions.py

@@ -6,6 +6,7 @@
 from app.lti_session_passback.auth_checkers import check_auth
 from app.utils import DEFAULT_EXTENSION
 from packaging import version as version_util
+from ua_parser.user_agent_parser import Parse as user_agent_parse
 
 api_sessions = Blueprint('api_sessions', __name__)
 logger = logging.getLogger('root_logger')
@@ -36,26 +37,30 @@ def get_user_agent():
     """
     if not check_auth():
         return {}, 404
+
+    user_info = user_agent_parse(request.user_agent.string)
+    user_info['os']['family'] = user_info['os']['family'].lower() 
+    user_info['user_agent']['family'] = user_info['user_agent']['family'].lower() 
     response = {
-        'platform': request.user_agent.platform,
-        'browser': request.user_agent.browser,
-        'version': request.user_agent.version,
+        'platform': user_info['os']['family'],
+        'browser': user_info['user_agent']['family'],
+        'version': user_info['user_agent']['major'],
         'message': 'OK',
         'outdated': False,
         'supportedPlatforms': list(Config.c.user_agent_platform.__dict__.keys()),
         'supportedBrowsers': Config.c.user_agent_browser.__dict__,
     }
-    if request.user_agent.platform not in Config.c.user_agent_platform.__dict__:
+    if user_info['os']['family'] not in Config.c.user_agent_platform.__dict__:
         response['outdated'] = True
-    browser_found = False
-    for (browser, version) in Config.c.user_agent_browser.__dict__.items():
-        if request.user_agent.browser == browser:
-            browser_found = True
-            if version_util.parse(request.user_agent.version) < version_util.parse(version):
+
+    user_browser_name = user_info['user_agent']['family']
+    if user_browser_name in Config.c.user_agent_browser.__dict__:
+        version = Config.c.user_agent_browser.__dict__[user_browser_name]
+        if version_util.parse(user_info['user_agent']['major']) < version_util.parse(version):
                 response['outdated'] = True
-                break
-    if not browser_found:
+    else:
         response['outdated'] = True
+
     return response, 200
 
 

app/audio_processor.py

@@ -1,9 +1,11 @@
 import sys
+import time
 from datetime import datetime
 
+import librosa
 from bson import ObjectId
 
-from app.audio_recognizer import AudioRecognizer, VoskAudioRecognizer
+from app.audio_recognizer import AudioRecognizer, WhisperAudioRecognizer
 from app.config import Config
 from app.mongo_models import Trainings
 from app.mongo_odm import DBManager, AudioToRecognizeDBManager, TrainingsDBManager, RecognizedAudioToProcessDBManager
@@ -52,7 +54,15 @@ def _try_extract_and_process(self):
                 self._hangle_error(training_id, verdict)
                 return
             try:
+                audio_length = librosa.get_duration(path=presentation_record_file)
+
+                start_time = time.time()
+
                 recognized_audio = self._audio_recognizer.recognize(presentation_record_file)
+
+                end_time = time.time()
+                processing_time = end_time - start_time
+                logger.info(f'audio processing time: {processing_time} s\naudio record length: {audio_length} s')
             except Exception as e:
                 verdict = 'Recognition of a presentation record file with presentation_record_file_id = {} ' \
                           'has failed.\n{}'.format(presentation_record_file_id, e)
@@ -85,7 +95,7 @@ class StuckAudioResender:
     Class to resend stuck raw audio files.
     """
 
-    def __init__(self, resend_stuck_audio_timeout_seconds=30, is_stuck_predicate=default_is_stuck_predicate):
+    def __init__(self, resend_stuck_audio_timeout_seconds=300, is_stuck_predicate=default_is_stuck_predicate):
         self._resend_stuck_audio_timeout_seconds = resend_stuck_audio_timeout_seconds
         self._is_stuck_predicate = is_stuck_predicate
 
@@ -118,7 +128,7 @@ def run(self):
 
 if __name__ == "__main__":
     Config.init_config(sys.argv[1])
-    audio_recognizer = VoskAudioRecognizer(host=Config.c.vosk.url)
+    audio_recognizer = WhisperAudioRecognizer(url=Config.c.whisper.url)
     audio_processor = AudioProcessor(audio_recognizer)
     audio_processor.run()
     stuck_audio_resender = StuckAudioResender()

app/audio_recognizer.py

@@ -2,14 +2,16 @@
 import json
 import wave
 
-import websockets
+import requests
 
 from app import utils
 from app.recognized_audio import RecognizedAudio
 from app.recognized_word import RecognizedWord
+from app.root_logger import get_root_logger
 from app.word import Word
-from playground.noise_reduction.denoiser import Denoiser
+from denoiser import Denoiser
 
+logger = get_root_logger(service_name='audio_processor')
 
 class AudioRecognizer:
     def recognize(self, audio):
@@ -25,6 +27,52 @@ def recognize(self, audio):
         return RecognizedAudio(recognized_words)
 
 
+class WhisperAudioRecognizer(AudioRecognizer):
+    def __init__(self, url):
+        self._url = url
+
+    def parse_recognizer_result(self, recognizer_result):
+        return RecognizedWord(
+            word=Word(recognizer_result['word']),
+            begin_timestamp=recognizer_result['start'],
+            end_timestamp=recognizer_result['end'],
+            probability=recognizer_result['probability'],
+        )
+
+    def recognize(self, audio):
+        recognizer_results = self.send_audio_to_recognizer(audio)
+        recognized_words = list(map(self.parse_recognizer_result, recognizer_results))
+        return RecognizedAudio(recognized_words)
+
+    def send_audio_to_recognizer(self, audio, language='ru'):
+        params = {
+            'task': 'transcribe',
+            'language': language,
+            'word_timestamps': 'true',
+            'output': 'json'
+        }
+        headers = {'accept': 'application/json'}
+
+        audio_to_recognize_buffer = audio.read()
+        audio.close()
+
+        try:
+            files = {'audio_file': ("student_speech", audio_to_recognize_buffer, 'audio/mpeg')}
+            response = requests.post(self._url, params=params, headers=headers, files=files)
+            response.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            logger.info(f"Recognition error occurred while processing audio file: {e}")
+            return []
+
+        data = response.json()
+
+        recognizer_results = []
+        for segment in data["segments"]:
+            for recognized_word in segment["words"]:
+                recognizer_results.append(recognized_word)
+        return recognizer_results
+
+
 class VoskAudioRecognizer(AudioRecognizer):
     def __init__(self, host):
         self._host = host
@@ -52,6 +100,7 @@ def recognize(self, audio):
 
     async def send_audio_to_recognizer(self, file_name):
         recognizer_results = []
+        import websockets
         async with websockets.connect(self._host) as websocket:
             wf = wave.open(file_name, "rb")
             await websocket.send('''{"config" : { "sample_rate" : 8000.0 }}''')

app/db_versioning/db_versioning.py

@@ -41,7 +41,7 @@ def update_db_version():
     version_doc = DBCollections().db_version.find_one()
 
     if not version_doc:
-        version_doc_id = add_version(VERSIONS['1.0'])    # if no version == 1.0
+        version_doc_id = add_version(VERSIONS[LAST_VERSION])  # if no version == LAST_VERSION
         version_doc = DBCollections().db_version.find_one({
             '_id': version_doc_id})
     version_doc_id = version_doc['_id']