Upload folder using huggingface_hub

.circleci/config.yml

@@ -0,0 +1,125 @@
+version: 2.1
+
+parameters:
+  # This parameter is used to trigger the main workflow
+  image_name:
+    type: string
+    default: text_to_speech_open_api
+  package_version:
+    type: string
+    default: "2.1.31"
+  dependency_image_name:
+    type: string
+    default: text_to_speech_open_api_dependency
+  dependency_version:
+    type: string
+    default: "2.1.7"
+  build_dependency:
+    type: boolean
+    default: true
+
+executors:
+  node:
+    docker:
+      - image: cimg/python:3.8.6
+jobs:
+  sonar-scan:
+    machine:
+      image: ubuntu-2004:202201-02
+    working_directory: ~/text-to-speech-open-api/
+    steps:
+      - checkout:
+          path: ~/text-to-speech-open-api
+      - run:
+          name: Branch
+          command: echo $CIRCLE_BRANCH
+      - run:
+          name: Sonar Scan
+          command: docker run --rm -e SONAR_HOST_URL="https://sonarcloud.io" -e SONAR_TOKEN=$SONAR_TOKEN -v $PWD:/usr/src sonarsource/sonar-scanner-cli -Dsonar.branch.name=$CIRCLE_BRANCH
+
+  test-suite:
+    executor: node
+    working_directory: ~/text-to-speech-open-api/
+    steps:
+      - checkout:
+          path: ~/text-to-speech-open-api/
+      - run:
+          name: Setup Testing Environment
+          command: |
+            python --version ;pip --version ; pwd ; ls
+            pip install --upgrade pip
+            pip install pytest grpcio grpcio-tools pytest-grpc coverage pydantic
+            python --version ; pip --version ; pwd ; ls
+      - run:
+          name: Run Tests
+          command: |
+            python --version ; pip --version ; pwd ; ls
+            pwd ; coverage run -m unittest discover tests
+            pytest
+            coverage report --fail-under 20  src/*/*.py
+            coverage html  # open htmlcov/index.html in a browser
+      - store_artifacts:
+          path: htmlcov
+
+
+  build_and_deploy_api_image:
+    machine:
+      image: ubuntu-2004:202101-01
+      resource_class: large
+    working_directory: ~/text-to-speech-open-api/
+    steps:
+      - checkout:
+          path: ~/text-to-speech-open-api
+      - run:
+          name: Setup Google credentials
+          command: |
+            echo ${GOOGLE_AUTH} > ${HOME}/gcp-key.json
+            pip install google_compute_engine
+            gcloud auth activate-service-account --key-file ${HOME}/gcp-key.json
+            gcloud --quiet config set project ${GCP_PROJECT}
+      - run:
+          name: Build dependencies image
+          command: |
+            echo "Build dependencies..."
+            if << pipeline.parameters.build_dependency >> ; then
+              docker build --rm=false -t gcr.io/${GCP_PROJECT}/<< pipeline.parameters.dependency_image_name >>:<< pipeline.parameters.dependency_version >> dependencies/
+              gcloud docker -- push gcr.io/${GCP_PROJECT}/<< pipeline.parameters.dependency_image_name >>:<< pipeline.parameters.dependency_version >>
+            fi
+#      - when:
+#          condition:
+#            equal: [ true, << pipeline.paramaters.build_dependency >> ]
+#          steps:
+#            - run: |
+#                docker build --rm=false -t gcr.io/${GCP_PROJECT}/<< pipeline.parameters.dependency_image_name >>:<< pipeline.parameters.dependency_version >> dependencies/
+#                gcloud docker -- push gcr.io/${GCP_PROJECT}/<< pipeline.parameters.dependency_image_name >>:<< pipeline.parameters.dependency_version >>
+      - run:
+          name: Build docker image
+          command: |
+            echo "Build api image..."
+            docker build --rm=false -t gcr.io/${GCP_PROJECT}/<< pipeline.parameters.image_name >>:<< pipeline.parameters.package_version >> .
+      - run:
+          name: deploy image to registry
+          command: |
+            echo "Deploy api image to registry..."
+            gcloud docker -- push gcr.io/${GCP_PROJECT}/<< pipeline.parameters.image_name >>:<< pipeline.parameters.package_version >>
+      - run:
+          name: Remove account details
+          command: |
+            rm ${HOME}/gcp-key.json ; ls
+workflows:
+  version: 2
+  main_workflow:
+    jobs:
+    - sonar-scan:
+        name: sonar-scan
+    - test-suite:
+        name: test-suite
+    - approve_to_publish:
+         name: approve-build-and-deploy
+         type: approval
+         requires:
+           - test-suite
+    - build_and_deploy_api_image:
+         name: build_and_deploy_api_image
+         requires:
+            - approve-build-and-deploy

.gitignore

@@ -0,0 +1,132 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+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
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.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
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+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
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+.idea/
+vakyansh-tts/

Dockerfile

@@ -0,0 +1,18 @@
+FROM gcr.io/ekstepspeechrecognition/text_to_speech_open_api_dependency:2.1.7
+
+
+ARG DEBIAN_FRONTEND=noninteractive
+EXPOSE 5000
+RUN mkdir /opt/text_to_speech_open_api/
+ENV base_path=/opt/text_to_speech_open_api/
+ENV models_base_path=/opt/text_to_speech_open_api/deployed_models/
+ENV model_logs_base_path=/opt/text_to_speech_open_api/deployed_models/logs/
+ENV translit_model_base_path=/opt/text_to_speech_open_api/vakyansh-tts/src/glow_tts/tts_infer/
+RUN echo "export LD_LIBRARY_PATH=/usr/local/nvidia/lib:/usr/local/nvidia/lib64:/usr/local/lib" >> ~/.bashrc
+RUN cp -R /opt/api_dependencies/vakyansh-tts /opt/text_to_speech_open_api/
+RUN cp -R /opt/api_dependencies/vakyansh-tts/tts_infer /opt/text_to_speech_open_api/vakyansh-tts/src/glow_tts/
+WORKDIR /opt/text_to_speech_open_api/vakyansh-tts/src/glow_tts/
+COPY src /opt/text_to_speech_open_api/vakyansh-tts/src/glow_tts/src
+COPY ./server.py /opt/text_to_speech_open_api/vakyansh-tts/src/glow_tts/
+CMD ["python3","/opt/text_to_speech_open_api/vakyansh-tts/src/glow_tts/server.py"]
+

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Open-Speech-EkStep
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dependencies/Dockerfile

@@ -0,0 +1,8 @@
+FROM nvidia/cuda:11.4.0-cudnn8-devel-ubuntu20.04
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN mkdir /opt/api_dependencies/
+WORKDIR /opt/api_dependencies/
+COPY installer.sh /opt/api_dependencies/
+RUN sh /opt/api_dependencies/installer.sh
+

dependencies/installer.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+#
+echo "Setting up model dependencies...."
+
+apt-get update && apt-get upgrade -y
+apt-get install -y sudo wget python3-pip git libsndfile1 libsndfile1-dev
+
+apt install python-is-python3
+git clone https://github.com/Open-Speech-EkStep/vakyansh-tts
+cd vakyansh-tts
+pip3 install --no-cache-dir -r requirements.txt
+bash install.sh
+python3 setup.py bdist_wheel
+pip3 install -e .
+pip3 install torch==1.7.1+cu110 -f https://download.pytorch.org/whl/torch_stable.html
+cd tts_infer
+mkdir -p translit_models
+#gsutil -m cp -r gs://vakyansh-open-models/translit_models .
+
+

server.py

@@ -0,0 +1,29 @@
+import uvicorn
+from fastapi import FastAPI
+from fastapi.exceptions import RequestValidationError
+from fastapi.middleware.cors import CORSMiddleware
+
+from src import log_setup
+from src.config import settings
+from src.routers import tts_routes
+from src.routers.exception_handler import validation_exception_handler
+
+LOGGER = log_setup.get_logger(__name__)
+
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins="*",
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(tts_routes.router)
+app.add_exception_handler(RequestValidationError, validation_exception_handler)
+
+if __name__ == "__main__":
+    LOGGER.info(f'Loading with settings {settings}')
+    uvicorn.run(
+        "server:app", host="0.0.0.0", port=settings.server_port, log_level=settings.log_level.lower(), reload=False
+    )

sonar-project.properties

@@ -0,0 +1,15 @@
+# must be unique in a given SonarQube instance
+sonar.projectKey=text-to-speech-open-api
+sonar.host.url=https://sonarcloud.io
+sonar.organization=vakyansh
+sonar.python.version=3
+# --- optional properties ---
+# defaults to project key
+#sonar.projectName=My project
+# defaults to 'not provided'
+#sonar.projectVersion=1.0
+# Path is relative to the sonar-project.properties file. Defaults to .
+#sonar.sources=src
+# Encoding of the source code. Default is default system encoding
+#sonar.sourceEncoding=UTF-8
+#sonar.branch.name=refactor

src/application/tts_preprocess.py

@@ -0,0 +1,121 @@
+import base64
+import io
+
+import numpy as np
+import torch
+from fastapi import HTTPException
+from indicnlp.tokenize import sentence_tokenize
+from mosestokenizer import MosesSentenceSplitter
+from scipy.io.wavfile import write
+from tts_infer.num_to_word_on_sent import normalize_nums
+
+from src import log_setup
+from src.infer.model_inference import ModelService
+from src.model.language import Language
+from src.model.tts_request import TTSRequest
+from src.model.tts_response import TTSResponse, AudioFile, AudioConfig
+
+LOGGER = log_setup.get_logger(__name__)
+model_service = ModelService()
+_INDIC = ["as", "bn", "gu", "hi", "kn", "ml", "mr", "or", "pa", "ta", "te"]
+_PURAM_VIRAM_LANGUAGES = ["hi", "or", "bn", "as"]
+_TRANSLITERATION_NOT_AVAILABLE_IN = ["en","or"]
+
+def infer_tts_request(request: TTSRequest):
+    config = request.config
+    lang = config.language.sourceLanguage
+    gender = config.gender
+    output_list = []
+    audio_config = AudioConfig(language=Language(sourceLanguage=lang))
+    try:
+        for sentence in request.input:
+            LOGGER.debug(f'infer for gender {gender} and lang {lang} text {sentence.source}')
+            speech_response = infer_tts(language=lang, gender=gender, text_to_infer=sentence.source)
+            LOGGER.debug(f'infer done for text {sentence.source}')
+            output_list.append(speech_response)
+
+        return TTSResponse(audio=output_list, config=audio_config)
+    except Exception as e:
+        LOGGER.exception('Failed to infer %s', e)
+        raise e
+
+
+def infer_tts(language: str, gender: str, text_to_infer: str):
+    choice = language + "_" + gender
+    LOGGER.debug(f'choice for model {choice}')
+
+    if choice in model_service.available_choice.keys():
+        t2s = model_service.available_choice[choice]
+    else:
+        raise NotImplementedError('Requested model not found')
+
+    if text_to_infer:
+        text_to_infer = normalize_text(text_to_infer, language)
+
+        # if len(text_to_infer) > settings.tts_max_text_limit:
+        LOGGER.debug("Running in paragraph mode...")
+        audio, sr = run_tts_paragraph(text_to_infer, language, t2s)
+        #         else:
+        #             LOGGER.debug("Running in text mode...")
+        #             audio, sr = run_tts(text_to_infer, language, t2s)
+        torch.cuda.empty_cache()  # TODO: find better approach for this
+        LOGGER.debug('Audio generates successfully')
+        bytes_wav = bytes()
+        byte_io = io.BytesIO(bytes_wav)
+        write(byte_io, sr, audio)
+        encoded_bytes = base64.b64encode(byte_io.read())
+        encoded_string = encoded_bytes.decode()
+        LOGGER.debug(f'Encoded Audio string {encoded_string}')
+        return AudioFile(audioContent=encoded_string)
+    else:
+        raise HTTPException(status_code=400, detail={"error": "No text"})
+
+
+def split_sentences(paragraph, language):
+    if language == "en":
+        with MosesSentenceSplitter(language) as splitter:
+            return splitter([paragraph])
+    elif language in _INDIC:
+        return sentence_tokenize.sentence_split(paragraph, lang=language)
+
+
+def normalize_text(text, lang):
+    if lang in _PURAM_VIRAM_LANGUAGES:
+        text = text.replace('|', '।')
+        text = text.replace('.', '।')
+    return text
+
+
+def pre_process_text(text, lang):
+    if lang == 'hi':
+        text = text.replace('।', '.')  # only for hindi models
+        
+    if lang == 'en' and text[-1] != '.':
+            text = text + '. '
+            
+    return text
+
+
+def run_tts_paragraph(text, lang, t2s):
+    audio_list = []
+    split_sentences_list = split_sentences(text, language=lang)
+
+    for sent in split_sentences_list:
+        audio, sr = run_tts(pre_process_text(sent, lang), lang, t2s)
+        audio_list.append(audio)
+
+    concatenated_audio = np.concatenate([i for i in audio_list])
+    # write(filename='temp_long.wav', rate=sr, data=concatenated_audio)
+    return concatenated_audio, sr
+
+
+def run_tts(text, lang, t2s):
+    text_num_to_word = normalize_nums(text, lang)  # converting numbers to words in lang
+    if lang not in _TRANSLITERATION_NOT_AVAILABLE_IN:
+        text_num_to_word_and_transliterated = model_service.transliterate_obj.translit_sentence(text_num_to_word,
+                                                                                                lang)  # transliterating english words to lang
+    else:
+        text_num_to_word_and_transliterated = text_num_to_word
+    mel = t2s[0].generate_mel(' ' + text_num_to_word_and_transliterated)
+    audio, sr = t2s[1].generate_wav(mel)
+    return audio, sr

src/config.py

@@ -0,0 +1,14 @@
+from pydantic import BaseSettings
+
+
+class Settings(BaseSettings):
+    app_name: str = "TTS API"
+    server_port: int = 5000
+    log_level: str = 'DEBUG'
+    gpu: bool = True
+    tts_max_text_limit: int = 450
+    models_base_path: str = ''
+    model_config_file_path: str = 'model_dict.json'
+
+
+settings = Settings()

src/infer/model_inference.py

@@ -0,0 +1,70 @@
+import ast
+import json
+import os
+
+import torch
+from mosestokenizer import *
+from tts_infer.transliterate import XlitEngine
+from tts_infer.tts import TextToMel, MelToWav
+
+from src import log_setup, utilities
+from src.config import settings
+
+LOGGER = log_setup.get_logger(__name__)
+
+
+def get_gpu_info(gpu):
+    LOGGER.info(f"*** GPU is enabled: {gpu} ***")
+    if gpu:
+        no_gpus = torch.cuda.device_count()
+        LOGGER.info(f"*** Total number of gpus allocated are {no_gpus} ***")
+        LOGGER.info(f"*** Cuda Version {torch.version.cuda} ***")
+        LOGGER.info(f"*** Python process id {os.getpid()} ***")
+        LOGGER.info("*** The gpu device info : ***")
+        for gpu in range(0, no_gpus):
+            LOGGER.info(f"GPU {str(gpu)} - {str(torch.cuda.get_device_name(gpu))}")
+
+
+class ModelService:
+
+    def __init__(self):
+        LOGGER.info(f'Loading with settings {settings}')
+        gpu_present = torch.cuda.is_available()
+        LOGGER.info("Gpu present : %s", gpu_present)
+        get_gpu_info(settings.gpu)
+
+        self.device = "cuda" if gpu_present & settings.gpu else "cpu"
+        LOGGER.info("Using device : %s", self.device)
+
+        model_config_file_path = settings.models_base_path + settings.model_config_file_path
+        if os.path.exists(model_config_file_path):
+            with open(model_config_file_path, 'r') as f:
+                model_config = json.load(f)
+        else:
+            raise Exception(f'Model configuration file is missing at {model_config_file_path}')
+        languages = ast.literal_eval(utilities.get_env_var('languages', '["all"]'))
+        self.supported_languages = list(model_config.keys())
+        LOGGER.info(f'supported languages {self.supported_languages}')
+        self.available_choice = {}
+        LOGGER.info(f'requested languages are {languages}')
+        for language_code, lang_config in model_config.items():
+            if language_code in languages or 'all' in languages:
+                if lang_config.get("male_glow") is not None:
+                    self.available_choice[f"{language_code}_male"] = [
+                        TextToMel(glow_model_dir=settings.models_base_path + lang_config.get("male_glow"),
+                                  device=self.device),
+                        MelToWav(hifi_model_dir=settings.models_base_path + lang_config.get("male_hifi"),
+                                 device=self.device)]
+                if lang_config.get("female_glow") is not None:
+                    self.available_choice[f"{language_code}_female"] = [
+                        TextToMel(glow_model_dir=settings.models_base_path + lang_config.get("female_glow"),
+                                  device=self.device),
+                        MelToWav(hifi_model_dir=settings.models_base_path + lang_config.get("female_hifi"),
+                                 device=self.device)]
+                LOGGER.info(f'{language_code} Models initialized successfully')
+        LOGGER.info(f'Model service available_choices are {self.available_choice}')
+        if len(self.available_choice) == 0:
+            LOGGER.error(
+                f'Invalid languages requested in {languages} ,only supported languages are {self.supported_languages}')
+            raise Exception(f'Invalid languages requested')
+        self.transliterate_obj = XlitEngine()

src/log_setup.py

@@ -0,0 +1,49 @@
+import logging
+import os
+import socket
+import sys
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
+
+from src.config import settings
+
+_FORMATTER = logging.Formatter(
+    "%(asctime)s — [%(threadName)s] - %(name)s -  %(filename)s.%(funcName)s(%(lineno)d) - %(levelname)s - %(message)s")
+LOGS_MODEL_BASE_PATH = Path(os.environ.get('model_logs_base_path', os.getcwd()))
+LOG_FILE = f"tts_inference_" + socket.gethostname() + ".log"
+
+_FILE_LOGGER_HANDLER = None
+_CONSOLE_LOGGER_HANDLER = None
+_LOGGING_DEBUG = settings.log_level.upper()
+
+
+def get_console_handler():
+    global _CONSOLE_LOGGER_HANDLER
+    if _CONSOLE_LOGGER_HANDLER is None:
+        _CONSOLE_LOGGER_HANDLER = logging.StreamHandler(sys.stdout)
+        _CONSOLE_LOGGER_HANDLER.setFormatter(_FORMATTER)
+
+    return _CONSOLE_LOGGER_HANDLER
+
+
+def get_file_handler():
+    global _FILE_LOGGER_HANDLER
+    if _FILE_LOGGER_HANDLER is None:
+        if not os.path.exists(LOGS_MODEL_BASE_PATH):
+            os.makedirs(LOGS_MODEL_BASE_PATH)
+        _FILE_LOGGER_HANDLER = TimedRotatingFileHandler(LOGS_MODEL_BASE_PATH / LOG_FILE,
+                                                        when='midnight',
+                                                        backupCount=30)
+        _FILE_LOGGER_HANDLER.setFormatter(_FORMATTER)
+
+    return _FILE_LOGGER_HANDLER
+
+
+def get_logger(logger_name):
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(_LOGGING_DEBUG)  # better to have too much log than not enough
+    logger.addHandler(get_console_handler())
+    logger.addHandler(get_file_handler())
+    # with this pattern, it's rarely necessary to propagate the error up to parent
+    logger.propagate = False
+    return logger

src/model/language.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, validator
+
+
+class Language(BaseModel):
+    sourceLanguage: str
+
+    @validator('sourceLanguage', pre=True)
+    def blank_string_in_language(cls, value, field):
+        if value == "":
+            raise ValueError('sourceLanguage cannot be empty')
+        return value

src/model/tts_request.py

@@ -0,0 +1,41 @@
+from typing import List
+
+from pydantic import BaseModel, validator
+
+from src.model.language import Language
+
+SUPPORTED_GENDERS = {'male', 'female'}
+
+
+class Sentence(BaseModel):
+    source: str
+
+    @validator('source', pre=True)
+    def blank_string_in_source(cls, value, field):
+        if value == "":
+            raise ValueError('source cannot be empty')
+        return value
+
+
+class TTSConfig(BaseModel):
+    language: Language
+    gender: str
+
+    @validator('gender', pre=True)
+    def blank_string_in_gender(cls, value, field):
+        if value == "":
+            raise ValueError('gender cannot be empty')
+        if value not in SUPPORTED_GENDERS:
+            raise ValueError('Unsupported gender value')
+        return value
+
+
+class TTSRequest(BaseModel):
+    input: List[Sentence]
+    config: TTSConfig
+
+    @validator('input', pre=True)
+    def input_cannot_be_empty(cls, value, field):
+        if len(value) < 1:
+            raise ValueError('input cannot be empty')
+        return value

src/model/tts_response.py

@@ -0,0 +1,26 @@
+from typing import List
+
+from pydantic import BaseModel
+
+from src.model.language import Language
+
+
+class AudioFile(BaseModel):
+    audioContent: str
+
+
+class AudioConfig(BaseModel):
+    language: Language
+    audioFormat: str = 'wav'
+    encoding: str = 'base64'
+    samplingRate: int = 22050
+
+
+class TTSResponse(BaseModel):
+    audio: List[AudioFile]
+    config: AudioConfig
+
+
+class TTSFailureResponse(BaseModel):
+    status: str = 'ERROR'
+    status_text: str

src/routers/exception_handler.py

@@ -0,0 +1,10 @@
+from fastapi import Request, status
+from fastapi.encoders import jsonable_encoder
+from fastapi.responses import JSONResponse
+
+
+async def validation_exception_handler(request: Request, exc: ValueError):
+    return JSONResponse(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        content=jsonable_encoder({"detail": exc.errors()}),
+    )

src/routers/tts_routes.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter, HTTPException, Response, status
+
+from src import log_setup
+from src.application.tts_preprocess import infer_tts_request
+from src.model.tts_request import TTSRequest
+from src.model.tts_response import TTSFailureResponse
+
+LOGGER = log_setup.get_logger(__name__)
+router = APIRouter()
+
+
+@router.post("/")
+async def tts(request: TTSRequest, response: Response):
+    LOGGER.info(f'TTS request {request}')
+    try:
+        infer_response = infer_tts_request(request)
+        return infer_response
+    except NotImplementedError as e:
+        LOGGER.exception('Failed to infer http exception %s', e)
+        response.status_code = status.HTTP_404_NOT_FOUND
+        return TTSFailureResponse(status_text=str(e))
+    except Exception as e:
+        LOGGER.exception('Failed to infer %s', e)
+        response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
+        return TTSFailureResponse(status_text=f'Failed to process request {str(e)}')

src/utilities.py

@@ -0,0 +1,5 @@
+import os
+
+def get_env_var(var_name=str, default=''):
+    return os.environ.get(var_name, default)
+

tests/test_config.py

@@ -0,0 +1,20 @@
+import unittest
+
+from src.config import Settings
+
+
+class ConfigTest(unittest.TestCase):
+
+    def testDefaultValues(self):
+        settings = Settings()
+        self.assertEqual(settings.app_name, 'TTS API', 'app_name default value does not match')
+        self.assertEqual(settings.server_port, 5000, 'server_port default value does not match')
+        self.assertEqual(settings.gpu, True, 'gpu default value does not match')
+        self.assertEqual(settings.tts_max_text_limit, 450, 'tts_max_text_limit default value does not match')
+        self.assertEqual(settings.models_base_path, '', 'models_base_path default value does not match')
+        self.assertEqual(settings.model_config_file_path, 'model_dict.json',
+                         'model_dict.json default value does not match')
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_language.py

@@ -0,0 +1,25 @@
+import unittest
+
+from pydantic import ValidationError
+
+from src.model.language import Language
+
+
+class LanguageTest(unittest.TestCase):
+
+    def testLanguage(self):
+        language = Language(sourceLanguage='hi')
+        self.assertEqual(language.sourceLanguage, 'hi', 'language does not match')
+
+    def testLanguageRequiredValues(self):
+        try:
+            config = Language()
+            self.fail('Expected validation error got nothing')
+        except ValidationError as e:
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_tts_request.py

@@ -0,0 +1,128 @@
+import unittest
+
+from pydantic import ValidationError
+
+from src.model.tts_request import TTSRequest, Sentence, TTSConfig, Language
+
+
+class TTSRequestTest(unittest.TestCase):
+
+    def test_request(self):
+        request = TTSRequest(input=[Sentence(source='ABC')],
+                             config=TTSConfig(gender='female', language=Language(sourceLanguage='en')))
+        self.assertEqual(request.input[0].source, 'ABC', 'Text does not match')
+        self.assertEqual(request.config.language.sourceLanguage, 'en', 'Language does not match')
+        self.assertEqual(request.config.gender, 'female', 'Gender does not match')
+
+    def test_required_values(self):
+        try:
+            request = TTSRequest()
+            self.fail('Expected validation error got nothing')
+        except ValidationError as e:
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def test_config_is_required(self):
+        try:
+            request = TTSRequest(input=[Sentence(source='ABC')])
+            self.fail('Expected validation error got nothing')
+        except ValidationError as e:
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def test_input_is_required(self):
+        try:
+            request = TTSRequest(input=[Sentence(source='ABC')])
+            self.fail('Expected validation error got nothing')
+        except ValidationError as e:
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def test_TTSConfig_without_gender(self):
+        try:
+            config = TTSConfig(language=Language(sourceLanguage='en'))
+        except ValidationError as e:
+            self.assertEqual(e.errors()[0]['type'], 'value_error.missing')
+            self.assertEqual(e.errors()[0]['loc'][0], 'gender')
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def test_TTSConfig_empty_gender(self):
+        try:
+            config = TTSConfig(language=Language(sourceLanguage='en'), gender='')
+        except ValidationError as e:
+            self.assertEqual(e.errors()[0]['loc'][0], 'gender')
+            self.assertEqual(e.errors()[0]['msg'], 'gender cannot be empty')
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def test_TTSConfig_empty_sourceLanguage(self):
+        try:
+            config = TTSConfig(language=Language(sourceLanguage=''), gender='male')
+        except ValidationError as e:
+            self.assertEqual(e.errors()[0]['loc'][0], 'sourceLanguage')
+            self.assertEqual(e.errors()[0]['msg'], 'sourceLanguage cannot be empty')
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def test_TTSConfig(self):
+        try:
+            config = TTSConfig(gender='male')
+        except ValidationError as e:
+            self.assertEqual(len(e.errors()), 1)
+            self.assertEqual(e.errors()[0]['type'], 'value_error.missing')
+            self.assertEqual(e.errors()[0]['loc'][0], 'language')
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def test_TTSConfig_unsupported_gender(self):
+
+        try:
+            config = TTSConfig(language=Language(sourceLanguage='en'), gender='Male')
+        except ValidationError as e:
+            self.assertEqual(len(e.errors()), 1)
+            self.assertEqual(e.errors()[0]['type'], 'value_error')
+            self.assertEqual(e.errors()[0]['loc'][0], 'gender')
+            self.assertEqual(e.errors()[0]['msg'], 'Unsupported gender value')
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def test_sentence_empty_source(self):
+        try:
+            sentence = Sentence(source='')
+        except ValidationError as e:
+            self.assertEqual(len(e.errors()), 1)
+            self.assertEqual(e.errors()[0]['type'], 'value_error')
+            self.assertEqual(e.errors()[0]['loc'][0], 'source')
+            self.assertEqual(e.errors()[0]['msg'], 'source cannot be empty')
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def test_sentence(self):
+        sentence = Sentence(source='Text')
+        self.assertEqual(sentence.source, 'Text')
+
+    def test_empty_input(self):
+        try:
+            request = TTSRequest(input=[], config=TTSConfig(gender='female', language=Language(sourceLanguage='en')))
+        except ValidationError as e:
+            self.assertEqual(len(e.errors()), 1)
+            self.assertEqual(e.errors()[0]['type'], 'value_error')
+            self.assertEqual(e.errors()[0]['loc'][0], 'input')
+            self.assertEqual(e.errors()[0]['msg'], 'input cannot be empty')
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_tts_response.py

@@ -0,0 +1,62 @@
+import unittest
+
+from pydantic import ValidationError
+
+from src.model.language import Language
+from src.model.tts_response import TTSResponse, AudioConfig, AudioFile
+
+
+class TTSResponseTest(unittest.TestCase):
+
+    def testRequest(self):
+        response = TTSResponse(audio=[AudioFile(audioContent='data')],
+                               config=AudioConfig(language=Language(sourceLanguage='hi')))
+        self.assertEqual(response.audio[0].audioContent, 'data', 'content does not match')
+        self.assertEqual(response.config.language.sourceLanguage, 'hi', 'language does not match')
+        self.assertEqual(response.config.samplingRate, 22050, 'default value for sample rate does not match')
+        self.assertEqual(response.config.encoding, 'base64', 'default value for encoding is not set')
+        self.assertEqual(response.config.audioFormat, 'wav', 'default value for audio format is not set')
+
+    def testTextIsRequiredValues(self):
+        try:
+            response = TTSResponse()
+            self.fail('Expected validation error got nothing')
+        except ValidationError as e:
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def testResponseRequiredConfig(self):
+        try:
+            response = TTSResponse(audio=[AudioFile(audioContent='data')])
+            self.fail('Expected validation error got nothing')
+        except ValidationError as e:
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def testResponseRequiredAudio(self):
+        try:
+            response = TTSResponse(config=AudioConfig(language='hi'))
+            self.fail('Expected validation error got nothing')
+        except ValidationError as e:
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def testAudioConfigRequiredValues(self):
+        try:
+            config = AudioConfig()
+            self.fail('Expected validation error got nothing')
+        except ValidationError as e:
+            pass
+        except Exception as er:
+            self.fail(f'Expected validation error for {er}')
+
+    def testAudioConfigWithFiles(self):
+        config = AudioConfig(language=Language(sourceLanguage='hi'))
+        self.assertEqual(config.language.sourceLanguage, 'hi', 'language does not match')
+
+
+if __name__ == '__main__':
+    unittest.main()