refactor: organize project with tests in a package, start following suggestions from pycharm, sonarlint and snyk

.gitignore

@@ -1,3 +1,61 @@
+
+# Created by https://www.gitignore.io/api/osx,linux,python,windows,pycharm,visualstudiocode
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### OSX ###
+*.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# CMake
+cmake-build-debug/
+
+# Ruby plugin and RubyMine
+/.rakeTasks
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+### Python ###
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -20,12 +78,9 @@ parts/
 sdist/
 var/
 wheels/
-pip-wheel-metadata/
-share/python-wheels/
 *.egg-info/
 .installed.cfg
 *.egg
-MANIFEST
 
 # PyInstaller
 #  Usually these files are written by a python script from a template
@@ -40,27 +95,19 @@ pip-delete-this-directory.txt
 # Unit test / coverage reports
 htmlcov/
 .tox/
-.nox/
 .coverage
 .coverage.*
 .cache
+.pytest_cache/
 nosetests.xml
 coverage.xml
 *.cover
-*.py,cover
 .hypothesis/
-.pytest_cache/
 
 # Translations
 *.mo
 *.pot
 
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
 # Flask stuff:
 instance/
 .webassets-cache
@@ -69,7 +116,8 @@ instance/
 .scrapy
 
 # Sphinx documentation
-docs/_build/
+docs/_build/doctrees/*
+docs/_build/html/*
 
 # PyBuilder
 target/
@@ -77,32 +125,18 @@ target/
 # Jupyter Notebook
 .ipynb_checkpoints
 
-# IPython
-profile_default/
-ipython_config.py
-
 # pyenv
 .python-version
 
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
+# celery beat schedule file
+celerybeat-schedule.*
 
 # SageMath parsed files
 *.sage.py
 
 # Environments
 .env
+.env*
 .venv
 env/
 venv/
@@ -122,8 +156,123 @@ venv.bak/
 
 # mypy
 .mypy_cache/
-.dmypy.json
-dmypy.json
 
-# Pyre type checker
-.pyre/
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.history
+
+### Windows ###
+# Windows thumbnail cache files
+Thumbs.db
+ehthumbs.db
+ehthumbs_vista.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# Build folder
+
+*/build/*
+
+# custom
+*.ori
+tmp
+nohup.out
+/tests/events.tar
+function_dump_*.json
+
+# onnx models
+*.onnx
+
+# End of https://www.gitignore.io/api/osx,linux,python,windows,pycharm,visualstudiocode
+
+## .idea files
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+.idea/*.iml
+# .idea/modules
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+# Sonarlint plugin
+.idea/sonarlint
+/.idea/modules.xml
+
+# node_modules
+node_modules

WordMatching.py → aip_trainer/WordMatching.py

@@ -1,9 +1,11 @@
-import WordMetrics
-from ortools.sat.python import cp_model
-import numpy as np
+import time
 from string import punctuation
+
+import numpy as np
 from dtwalign import dtw_from_distance_matrix
-import time
+from ortools.sat.python import cp_model
+
+from . import WordMetrics, app_logger
 
 offset_blank = 1
 TIME_THRESHOLD_MAPPING = 5.0
@@ -77,7 +79,8 @@ def get_best_path_from_distance_matrix(word_distance_matrix):
                 (solver.Value(estimated_words_order[word_idx])))
 
         return np.array(mapped_indices, dtype=int)
-    except:
+    except Exception as ex:
+        app_logger.error(f"ex:{ex}.")
         return []
 
 

WordMetrics.py → aip_trainer/WordMetrics.py

@@ -1,8 +1,12 @@
 import numpy as np
 
+from aip_trainer import app_logger
+
+
 # ref from https://gitlab.com/-/snippets/1948157
 # For some variants, look here https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#Python
 
+
 # Pure python
 def edit_distance_python2(a, b):
     # This version is commutative, so as an optimization we force |a|>=|b|
@@ -52,5 +56,5 @@ def edit_distance_python(seq1, seq2):
                     matrix[x-1,y-1] + 1,
                     matrix[x,y-1] + 1
                 )
-    #print (matrix)
+    app_logger.debug("matrix:{}\n".format(matrix))
     return matrix[size_x - 1, size_y - 1]

aip_trainer/__init__.py

@@ -0,0 +1,16 @@
+"""Get machine learning predictions from geodata raster images"""
+import os
+from pathlib import Path
+
+import structlog
+from dotenv import load_dotenv
+
+from aip_trainer.utils import session_logger
+
+
+load_dotenv()
+PROJECT_ROOT_FOLDER = Path(globals().get("__file__", "./_")).absolute().parent.parent
+LOG_JSON_FORMAT = bool(os.getenv("LOG_JSON_FORMAT", False))
+log_level = os.getenv("LOG_LEVEL", "INFO")
+session_logger.setup_logging(json_logs=LOG_JSON_FORMAT, log_level=log_level)
+app_logger = structlog.stdlib.get_logger(__name__)

lambdaGetSample.py → aip_trainer/lambdas/lambdaGetSample.py

@@ -1,10 +1,12 @@
-
-import pandas as pd
 import json
-import RuleBasedModels
-import epitran
-import random
 import pickle
+import random
+from pathlib import Path
+
+import epitran
+
+from aip_trainer import PROJECT_ROOT_FOLDER
+from aip_trainer.models import RuleBasedModels
 
 
 class TextDataset:
@@ -27,11 +29,11 @@ class TextDataset:
         return self.number_of_samples
 
 
-sample_folder = "./"
+sample_folder = Path(PROJECT_ROOT_FOLDER / "aip_trainer" / "lambdas")
 lambda_database = {}
 lambda_ipa_converter = {}
 
-with open(sample_folder+'data_de_en_2.pickle', 'rb') as handle:
+with open(sample_folder / 'data_de_en_2.pickle', 'rb') as handle:
     df = pickle.load(handle)
 
 lambda_database['de'] = TextDataset(df, 'de')

lambdaSpeechToScore.py → aip_trainer/lambdas/lambdaSpeechToScore.py

@@ -1,16 +1,18 @@
 
-import torch
+import base64
 import json
 import os
-import WordMatching as wm
-import utilsFileIO
-import pronunciationTrainer
-import base64
 import time
+
 import audioread
 import numpy as np
+import torch
 from torchaudio.transforms import Resample
 
+from aip_trainer import WordMatching as wm, app_logger
+from aip_trainer import pronunciationTrainer
+from aip_trainer import utilsFileIO
+
 
 trainer_SST_lambda = {
     'de': pronunciationTrainer.getTrainer("de"),
@@ -42,25 +44,28 @@ def lambda_handler(event, context):
         }
 
     start = time.time()
-    random_file_name = './'+utilsFileIO.generateRandomString()+'.ogg'
+    random_file_name = './' + utilsFileIO.generateRandomString() + '.ogg'
     f = open(random_file_name, 'wb')
     f.write(file_bytes)
     f.close()
-    print('Time for saving binary in file: ', str(time.time()-start))
+    duration = time.time() - start
+    app_logger.info(f'Time for saving binary in file: {duration}.')
 
     start = time.time()
     signal, fs = audioread_load(random_file_name)
 
     signal = transform(torch.Tensor(signal)).unsqueeze(0)
 
-    print('Time for loading .ogg file file: ', str(time.time()-start))
+    duration = time.time() - start
+    app_logger.info(f'Time for loading .ogg file file: {duration}.')
 
     result = trainer_SST_lambda[language].processAudioForGivenText(
         signal, real_text)
 
     start = time.time()
     os.remove(random_file_name)
-    print('Time for deleting file: ', str(time.time()-start))
+    duration = time.time() - start
+    app_logger.info(f'Time for deleting file: {duration}')
 
     start = time.time()
     real_transcripts_ipa = ' '.join(
@@ -90,7 +95,8 @@ def lambda_handler(event, context):
 
     pair_accuracy_category = ' '.join(
         [str(category) for category in result['pronunciation_categories']])
-    print('Time to post-process results: ', str(time.time()-start))
+    duration = time.time() - start
+    app_logger.info(f'Time to post-process results: {duration}')
 
     res = {'real_transcript': result['recording_transcript'],
            'ipa_transcript': result['recording_ipa'],

aip_trainer/lambdas/lambdaTTS.py

@@ -0,0 +1,48 @@
+
+import base64
+import json
+import tempfile
+
+import soundfile as sf
+
+from aip_trainer import app_logger
+from aip_trainer.models.models import getTTSModel
+from aip_trainer.models.AIModels import NeuralTTS
+
+
+sampling_rate = 16000
+model_de = getTTSModel('de')
+model_TTS_lambda = NeuralTTS(model_de, sampling_rate)
+
+
+def lambda_handler(event, context):
+
+    body = json.loads(event['body'])
+
+    text_string = body['value']
+
+    linear_factor = 0.2
+    audio = model_TTS_lambda.getAudioFromSentence(
+        text_string).detach().numpy()*linear_factor
+    with tempfile.TemporaryFile(prefix="temp_sound_", suffix=".wav") as f1:
+        app_logger.info(f"Saving temp audio to {f1.name}...")
+        # random_file_name = utilsFileIO.generateRandomString(20) + '.wav'
+        # sf.write('./'+random_file_name, audio, 16000)
+
+        sf.write(f1.name, audio, sampling_rate)
+        with open(f1.name, "rb") as f:
+            audio_byte_array = f.read()
+        # os.remove(random_file_name)
+        return {
+            'statusCode': 200,
+            'headers': {
+                'Access-Control-Allow-Headers': '*',
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'OPTIONS,POST,GET'
+            },
+            'body': json.dumps(
+                {
+                    "wavBase64": str(base64.b64encode(audio_byte_array))[2:-1],
+                },
+            )
+        }

AIModels.py → aip_trainer/models/AIModels.py

@@ -1,6 +1,7 @@
-import ModelInterfaces
-import torch
 import numpy as np
+import torch
+
+from aip_trainer.models import ModelInterfaces
 
 
 class NeuralASR(ModelInterfaces.IASRModel):

ModelInterfaces.py → aip_trainer/models/ModelInterfaces.py

@@ -1,5 +1,5 @@
-
 import abc
+
 import numpy as np
 
 

RuleBasedModels.py → aip_trainer/models/RuleBasedModels.py

@@ -1,9 +1,7 @@
-import ModelInterfaces
-import torch
-import numpy as np
-import epitran
 import eng_to_ipa
 
+from aip_trainer.models import ModelInterfaces
+
 
 class EpitranPhonemConverter(ModelInterfaces.ITextToPhonemModel):
     word_locations_in_samples = None

models.py → aip_trainer/models/models.py

@@ -4,9 +4,6 @@ import torch.nn as nn
 import pickle
 
 
-import pickle
-
-
 def getASRModel(language: str) -> nn.Module:
 
     if language == 'de':

pronunciationTrainer.py → aip_trainer/pronunciationTrainer.py

@@ -1,15 +1,14 @@
+import time
+from string import punctuation
 
-import torch
-import numpy as np
-import models as mo
-import WordMetrics
-import WordMatching as wm
 import epitran
-import ModelInterfaces as mi
-import AIModels
-import RuleBasedModels
-from string import punctuation
-import time
+import numpy as np
+import torch
+
+from . import WordMatching as wm
+from . import WordMetrics
+from . import app_logger
+from .models import AIModels, ModelInterfaces as mi, RuleBasedModels, models as mo
 
 
 def getTrainer(language: str):
@@ -66,7 +65,7 @@ class PronunciationTrainer:
     def getWordsRelativeIntonation(self, Audio: torch.tensor, word_locations: list):
         intonations = torch.zeros((len(word_locations), 1))
         intonation_fade_samples = 0.3*self.sampling_rate
-        print(intonations.shape)
+        app_logger.info(intonations.shape)
         for word in range(len(word_locations)):
             intonation_start = int(np.maximum(
                 0, word_locations[word][0]-intonation_fade_samples))
@@ -85,12 +84,15 @@ class PronunciationTrainer:
         start = time.time()
         recording_transcript, recording_ipa, word_locations = self.getAudioTranscript(
             recordedAudio)
-        print('Time for NN to transcript audio: ', str(time.time()-start))
+
+        duration = time.time() - start
+        app_logger.info(f'Time for NN to transcript audio: {duration}.')
 
         start = time.time()
         real_and_transcribed_words, real_and_transcribed_words_ipa, mapped_words_indices = self.matchSampleAndRecordedWords(
             real_text, recording_transcript)
-        print('Time for matching transcripts: ', str(time.time()-start))
+        duration = time.time() - start
+        app_logger.info(f'Time for matching transcripts: {duration}.')
 
         start_time, end_time = self.getWordLocationsFromRecordInSeconds(
             word_locations, mapped_words_indices)

aip_trainer/utils/session_logger.py

@@ -0,0 +1,143 @@
+import logging
+import sys
+
+import structlog
+from structlog.types import EventDict, Processor
+
+
+# https://github.com/hynek/structlog/issues/35#issuecomment-591321744
+def rename_event_key(_, __, event_dict: EventDict) -> EventDict:
+    """
+    Log entries keep the text message in the `event` field, but Datadog
+    uses the `message` field. This processor moves the value from one field to
+    the other.
+    See https://github.com/hynek/structlog/issues/35#issuecomment-591321744
+    """
+    event_dict["message"] = event_dict.pop("event")
+    return event_dict
+
+
+def drop_color_message_key(_, __, event_dict: EventDict) -> EventDict:
+    """
+    Uvicorn logs the message a second time in the extra `color_message`, but we don't
+    need it. This processor drops the key from the event dict if it exists.
+    """
+    event_dict.pop("color_message", None)
+    return event_dict
+
+
+def setup_logging(json_logs: bool = False, log_level: str = "INFO"):
+    """Enhance the configuration of structlog.
+    Needed for correlation id injection with fastapi middleware in samgis-web.
+    After the use of logging_middleware() in samgis_web.web.middlewares, add also the CorrelationIdMiddleware from
+    'asgi_correlation_id' package. (See 'tests/web/test_middlewares.py' in samgis_web).
+    To change an input parameter like the log level, re-run the function changing the parameter
+    (no need to re-instantiate the logger instance: it's a hot change)
+
+    Args:
+        json_logs: set logs in json format
+        log_level: log level string
+
+    Returns:
+
+    """
+    timestamper = structlog.processors.TimeStamper(fmt="iso")
+
+    shared_processors: list[Processor] = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.stdlib.ExtraAdder(),
+        drop_color_message_key,
+        timestamper,
+        structlog.processors.StackInfoRenderer(),
+        # adapted from https://www.structlog.org/en/stable/standard-library.html
+        # If the "exc_info" key in the event dict is either true or a
+        # sys.exc_info() tuple, remove "exc_info" and render the exception
+        # with traceback into the "exception" key.
+        structlog.processors.format_exc_info,
+        # If some value is in bytes, decode it to a Unicode str.
+        structlog.processors.UnicodeDecoder(),
+        # Add callsite parameters.
+        structlog.processors.CallsiteParameterAdder(
+            {
+                structlog.processors.CallsiteParameter.FUNC_NAME,
+                structlog.processors.CallsiteParameter.LINENO,
+            }
+        ),
+        # Render the final event dict as JSON.
+    ]
+
+    if json_logs:
+        # We rename the `event` key to `message` only in JSON logs, as Datadog looks for the
+        # `message` key but the pretty ConsoleRenderer looks for `event`
+        shared_processors.append(rename_event_key)
+        # Format the exception only for JSON logs, as we want to pretty-print them when
+        # using the ConsoleRenderer
+        shared_processors.append(structlog.processors.format_exc_info)
+
+    structlog.configure(
+        processors=shared_processors
+        + [
+            # Prepare event dict for `ProcessorFormatter`.
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+    log_renderer: structlog.types.Processor
+    if json_logs:
+        log_renderer = structlog.processors.JSONRenderer()
+    else:
+        log_renderer = structlog.dev.ConsoleRenderer()
+
+    formatter = structlog.stdlib.ProcessorFormatter(
+        # These run ONLY on `logging` entries that do NOT originate within
+        # structlog.
+        foreign_pre_chain=shared_processors,
+        # These run on ALL entries after the pre_chain is done.
+        processors=[
+            # Remove _record & _from_structlog.
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            log_renderer,
+        ],
+    )
+
+    handler = logging.StreamHandler()
+    # Use OUR `ProcessorFormatter` to format all `logging` entries.
+    handler.setFormatter(formatter)
+    root_logger = logging.getLogger()
+    root_logger.addHandler(handler)
+    root_logger.setLevel(log_level.upper())
+
+    for _log in ["uvicorn", "uvicorn.error"]:
+        # Clear the log handlers for uvicorn loggers, and enable propagation
+        # so the messages are caught by our root logger and formatted correctly
+        # by structlog
+        logging.getLogger(_log).handlers.clear()
+        logging.getLogger(_log).propagate = True
+
+    # Since we re-create the access logs ourselves, to add all information
+    # in the structured log (see the `logging_middleware` in main.py), we clear
+    # the handlers and prevent the logs to propagate to a logger higher up in the
+    # hierarchy (effectively rendering them silent).
+    logging.getLogger("uvicorn.access").handlers.clear()
+    logging.getLogger("uvicorn.access").propagate = False
+
+    def handle_exception(exc_type, exc_value, exc_traceback):
+        """
+        Log any uncaught exception instead of letting it be printed by Python
+        (but leave KeyboardInterrupt untouched to allow users to Ctrl+C to stop)
+        See https://stackoverflow.com/a/16993115/3641865
+        """
+        if issubclass(exc_type, KeyboardInterrupt):
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+
+        root_logger.error(
+            "Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback)
+        )
+
+    sys.excepthook = handle_exception

lambdaTTS.py

@@ -1,46 +0,0 @@
-
-import models
-import soundfile as sf
-import json
-import AIModels
-#from flask import Response
-import utilsFileIO
-import os
-import base64
-
-sampling_rate = 16000
-model_TTS_lambda = AIModels.NeuralTTS(models.getTTSModel('de'), sampling_rate)
-
-
-def lambda_handler(event, context):
-
-    body = json.loads(event['body'])
-
-    text_string = body['value']
-
-    linear_factor = 0.2
-    audio = model_TTS_lambda.getAudioFromSentence(
-        text_string).detach().numpy()*linear_factor
-    random_file_name = utilsFileIO.generateRandomString(20)+'.wav'
-
-    sf.write('./'+random_file_name, audio, 16000)
-
-    with open(random_file_name, "rb") as f:
-        audio_byte_array = f.read()
-
-    os.remove(random_file_name)
-
-
-    return {
-        'statusCode': 200,
-        'headers': {
-            'Access-Control-Allow-Headers': '*',
-            'Access-Control-Allow-Origin': '*',
-            'Access-Control-Allow-Methods': 'OPTIONS,POST,GET'
-        },
-        'body': json.dumps(
-            {
-                "wavBase64": str(base64.b64encode(audio_byte_array))[2:-1],
-            },
-        )
-    }

static/javascript/callbacks.js

@@ -105,7 +105,7 @@ const UIRecordingError = () => {
 //################### Application state functions #######################
 function updateScore(currentPronunciationScore) {
 
-    if (isNaN(currentPronunciationScore))
+    if (Number.isNaN(currentPronunciationScore))
         return;
     currentScore += currentPronunciationScore * scoreMultiplier;
     currentScore = Math.round(currentScore);

unitTests.py → tests/unitTests.py

@@ -1,11 +1,11 @@
+import json
 import unittest
 
-import ModelInterfaces
-import lambdaGetSample
-import RuleBasedModels
 import epitran
-import json
-import pronunciationTrainer
+
+from aip_trainer.models import ModelInterfaces, RuleBasedModels
+from aip_trainer import pronunciationTrainer
+from aip_trainer.lambdas import lambdaGetSample
 
 
 def test_category(category: int, threshold_min: int, threshold_max: int):
@@ -40,12 +40,12 @@ class TestDataset(unittest.TestCase):
         self.assertTrue(test_category(3, 20, 10000))
 
 
-def check_phonem_converter(converter: ModelInterfaces.ITextToPhonemModel, input: str, expected_output: str):
-    output = converter.convertToPhonem(input)
+def check_phonem_converter(converter: ModelInterfaces.ITextToPhonemModel, input_phonem: str, expected_output: str):
+    output = converter.convertToPhonem(input_phonem)
 
     is_correct = output == expected_output
     if not is_correct:
-        print('Conversion from "', input, '" should be "',
+        print('Conversion from "', input_phonem, '" should be "',
               expected_output, '", but was "', output, '"')
     return is_correct
 
@@ -60,7 +60,6 @@ class TestPhonemConverter(unittest.TestCase):
     def test_german(self):
         phonem_converter = RuleBasedModels.EpitranPhonemConverter(
             epitran.Epitran('deu-Latn'))
-
         self.assertTrue(check_phonem_converter(
             phonem_converter, 'Hallo, das ist ein Test', 'haloː, dɑːs ɪst ain tɛst'))
 

webApp.py

@@ -4,9 +4,10 @@ import os
 from flask_cors import CORS
 import json
 
-import lambdaTTS
-import lambdaSpeechToScore
-import lambdaGetSample
+from aip_trainer.lambdas import lambdaTTS
+from aip_trainer.lambdas import lambdaSpeechToScore
+from aip_trainer.lambdas import lambdaGetSample
+
 
 app = Flask(__name__)
 cors = CORS(app)