Complete the endpoint

.gitignore

@@ -0,0 +1,3 @@
+venv
+env
+__pycache__

Dockerfile

@@ -0,0 +1,71 @@
+# Use Python 3.10.5 as the base image
+FROM python:3.10.5-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Upgrade pip, install git, MeCab and its dependencies
+RUN apt-get update \
+    && apt-get install -y git mecab libmecab-dev mecab-ipadic mecab-ipadic-utf8 \
+    && pip install --upgrade pip
+
+# Install PyTorch
+# Note: Replace the next line with the correct command to install the PyTorch version compatible with your deepspeed version
+RUN pip install torch
+RUN pip install librosa -U
+
+# Install other dependencies from requirements.txt
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r requirements.txt
+
+# List installed packages for debugging
+RUN pip list
+
+# Copy the rest of your application's code
+COPY . /app/
+
+# RUN cd /tmp && mkdir cache1
+
+ENV NUMBA_CACHE_DIR=/tmp
+
+
+# Expose the port your app runs on
+EXPOSE 7860
+
+# Download UniDic for MeCab
+RUN pip install unidic \
+    && python -m unidic download
+
+# Set the environment variable for Coqui TTS
+ENV COQUI_TOS_AGREED=1
+RUN pip install numba==0.48
+
+# Apply migrations
+RUN python manage.py migrate
+
+# Use Django's built-in server to serve the app
+CMD ["python", "manage.py", "runserver", "0.0.0.0:7860"]
+
+
+
+# # Fast api
+# # Use the official Python image as a parent image
+# FROM python:3.10.5-slim
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Copy the requirements file into the container at /app
+# COPY requirements.txt .
+
+# # Install any needed packages specified in requirements.txt
+# RUN pip install -r requirements.txt
+
+# # Copy the current directory contents into the container at /app
+# COPY . .
+
+# # Expose port 7860 to the outside world
+# EXPOSE 7860
+
+# # Define the command to run your FastAPI application using uvicorn
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,499 @@
+import sys
+from TTS.api import TTS
+import io, os, stat
+import subprocess
+import random
+from zipfile import ZipFile
+import uuid
+import time
+import torch
+import torchaudio
+
+
+#download for mecab
+# os.system('python -m unidic download')
+
+# By using XTTS you agree to CPML license https://coqui.ai/cpml
+os.environ["COQUI_TOS_AGREED"] = "1"
+
+# langid is used to detect language for longer text
+# Most users expect text to be their own language, there is checkbox to disable it
+import langid
+import base64
+import csv
+from io import StringIO
+import datetime
+import re
+
+import gradio as gr
+from scipy.io.wavfile import write
+from pydub import AudioSegment
+
+from TTS.api import TTS
+from TTS.tts.configs.xtts_config import XttsConfig
+from TTS.tts.models.xtts import Xtts
+from TTS.utils.generic_utils import get_user_data_dir
+
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+from huggingface_hub import HfApi
+
+# will use api to restart space on a unrecoverable error
+api = HfApi(token=HF_TOKEN)
+repo_id = "coqui/xtts"
+
+# Use never ffmpeg binary for Ubuntu20 to use denoising for microphone input
+print("Export newer ffmpeg binary for denoise filter")
+ZipFile("ffmpeg.zip").extractall()
+print("Make ffmpeg binary executable")
+st = os.stat("ffmpeg")
+os.chmod("ffmpeg", st.st_mode | stat.S_IEXEC)
+
+# This will trigger downloading model
+print("Downloading if not downloaded Coqui XTTS V2")
+from TTS.utils.manage import ModelManager
+
+model_name = "tts_models/multilingual/multi-dataset/xtts_v2"
+ModelManager().download_model(model_name)
+model_path = os.path.join(get_user_data_dir("tts"), model_name.replace("/", "--"))
+print("XTTS downloaded")
+
+config = XttsConfig()
+config.load_json(os.path.join(model_path, "config.json"))
+
+model = Xtts.init_from_config(config)
+model.load_checkpoint(
+    config,
+    checkpoint_path=os.path.join(model_path, "model.pth"),
+    vocab_path=os.path.join(model_path, "vocab.json"),
+    eval=True,
+    use_deepspeed=True,
+)
+model.cuda()
+
+# This is for debugging purposes only
+DEVICE_ASSERT_DETECTED = 0
+DEVICE_ASSERT_PROMPT = None
+DEVICE_ASSERT_LANG = None
+
+supported_languages = config.languages
+
+def predict(
+    prompt,
+    language,
+    audio_file_pth,
+    mic_file_path,
+    use_mic,
+    voice_cleanup,
+    no_lang_auto_detect,
+    agree,
+):
+    if agree == True:
+        if language not in supported_languages:
+            gr.Warning(
+                f"Language you put {language} in is not in is not in our Supported Languages, please choose from dropdown"
+            )
+
+            return (
+                None,
+                None,
+                None,
+                None,
+            )
+
+        language_predicted = langid.classify(prompt)[
+            0
+        ].strip()  # strip need as there is space at end!
+
+        # tts expects chinese as zh-cn
+        if language_predicted == "zh":
+            # we use zh-cn
+            language_predicted = "zh-cn"
+
+        print(f"Detected language:{language_predicted}, Chosen language:{language}")
+
+        # After text character length 15 trigger language detection
+        if len(prompt) > 15:
+            # allow any language for short text as some may be common
+            # If user unchecks language autodetection it will not trigger
+            # You may remove this completely for own use
+            if language_predicted != language and not no_lang_auto_detect:
+                # Please duplicate and remove this check if you really want this
+                # Or auto-detector fails to identify language (which it can on pretty short text or mixed text)
+                gr.Warning(
+                    f"It looks like your text isn’t the language you chose , if you’re sure the text is the same language you chose, please check disable language auto-detection checkbox"
+                )
+
+                return (
+                    None,
+                    None,
+                    None,
+                    None,
+                )
+
+        if use_mic == True:
+            if mic_file_path is not None:
+                speaker_wav = mic_file_path
+            else:
+                gr.Warning(
+                    "Please record your voice with Microphone, or uncheck Use Microphone to use reference audios"
+                )
+                return (
+                    None,
+                    None,
+                    None,
+                    None,
+                )
+
+        else:
+            speaker_wav = audio_file_pth
+
+        # Filtering for microphone input, as it has BG noise, maybe silence in beginning and end
+        # This is fast filtering not perfect
+
+        # Apply all on demand
+        lowpassfilter = denoise = trim = loudness = True
+
+        if lowpassfilter:
+            lowpass_highpass = "lowpass=8000,highpass=75,"
+        else:
+            lowpass_highpass = ""
+
+        if trim:
+            # better to remove silence in beginning and end for microphone
+            trim_silence = "areverse,silenceremove=start_periods=1:start_silence=0:start_threshold=0.02,areverse,silenceremove=start_periods=1:start_silence=0:start_threshold=0.02,"
+        else:
+            trim_silence = ""
+
+        if voice_cleanup:
+            try:
+                out_filename = (
+                    speaker_wav + str(uuid.uuid4()) + ".wav"
+                )  # ffmpeg to know output format
+
+                # we will use newer ffmpeg as that has afftn denoise filter
+                shell_command = f"./ffmpeg -y -i {speaker_wav} -af {lowpass_highpass}{trim_silence} {out_filename}".split(
+                    " "
+                )
+
+                command_result = subprocess.run(
+                    [item for item in shell_command],
+                    capture_output=False,
+                    text=True,
+                    check=True,
+                )
+                speaker_wav = out_filename
+                print("Filtered microphone input")
+            except subprocess.CalledProcessError:
+                # There was an error - command exited with non-zero code
+                print("Error: failed filtering, use original microphone input")
+        else:
+            speaker_wav = speaker_wav
+
+        if len(prompt) < 2:
+            gr.Warning("Please give a longer prompt text")
+            return (
+                None,
+                None,
+                None,
+                None,
+            )
+        if len(prompt) > 200:
+            gr.Warning(
+                "Text length limited to 200 characters for this demo, please try shorter text. You can clone this space and edit code for your own usage"
+            )
+            return (
+                None,
+                None,
+                None,
+                None,
+            )
+        global DEVICE_ASSERT_DETECTED
+        if DEVICE_ASSERT_DETECTED:
+            global DEVICE_ASSERT_PROMPT
+            global DEVICE_ASSERT_LANG
+            # It will likely never come here as we restart space on first unrecoverable error now
+            print(
+                f"Unrecoverable exception caused by language:{DEVICE_ASSERT_LANG} prompt:{DEVICE_ASSERT_PROMPT}"
+            )
+
+            # HF Space specific.. This error is unrecoverable need to restart space
+            space = api.get_space_runtime(repo_id=repo_id)
+            if space.stage!="BUILDING":
+                api.restart_space(repo_id=repo_id)
+            else:
+                print("TRIED TO RESTART but space is building")
+
+        try:
+            metrics_text = ""
+            t_latent = time.time()
+
+            # note diffusion_conditioning not used on hifigan (default mode), it will be empty but need to pass it to model.inference
+            try:
+                (
+                    gpt_cond_latent,
+                    speaker_embedding,
+                ) = model.get_conditioning_latents(audio_path=speaker_wav, gpt_cond_len=30, gpt_cond_chunk_len=4, max_ref_length=60)
+            except Exception as e:
+                print("Speaker encoding error", str(e))
+                gr.Warning(
+                    "It appears something wrong with reference, did you unmute your microphone?"
+                )
+                return (
+                    None,
+                    None,
+                    None,
+                    None,
+                )
+
+            latent_calculation_time = time.time() - t_latent
+            # metrics_text=f"Embedding calculation time: {latent_calculation_time:.2f} seconds\n"
+
+            # temporary comma fix
+            prompt= re.sub("([^\x00-\x7F]|\w)(\.|\。|\?)",r"\1 \2\2",prompt)
+
+            wav_chunks = []
+            ## Direct mode
+            
+            print("I: Generating new audio...")
+            t0 = time.time()
+            out = model.inference(
+                prompt,
+                language,
+                gpt_cond_latent,
+                speaker_embedding,
+                repetition_penalty=5.0,
+                temperature=0.75,
+            )
+            inference_time = time.time() - t0
+            print(f"I: Time to generate audio: {round(inference_time*1000)} milliseconds")
+            metrics_text+=f"Time to generate audio: {round(inference_time*1000)} milliseconds\n"
+            real_time_factor= (time.time() - t0) / out['wav'].shape[-1] * 24000
+            print(f"Real-time factor (RTF): {real_time_factor}")
+            metrics_text+=f"Real-time factor (RTF): {real_time_factor:.2f}\n"
+            torchaudio.save("output.wav", torch.tensor(out["wav"]).unsqueeze(0), 24000)
+
+
+            """
+            print("I: Generating new audio in streaming mode...")
+            t0 = time.time()
+            chunks = model.inference_stream(
+                prompt,
+                language,
+                gpt_cond_latent,
+                speaker_embedding,
+                repetition_penalty=7.0,
+                temperature=0.85,
+            )
+
+            first_chunk = True
+            for i, chunk in enumerate(chunks):
+                if first_chunk:
+                    first_chunk_time = time.time() - t0
+                    metrics_text += f"Latency to first audio chunk: {round(first_chunk_time*1000)} milliseconds\n"
+                    first_chunk = False
+                wav_chunks.append(chunk)
+                print(f"Received chunk {i} of audio length {chunk.shape[-1]}")
+            inference_time = time.time() - t0
+            print(
+                f"I: Time to generate audio: {round(inference_time*1000)} milliseconds"
+            )
+            #metrics_text += (
+            #    f"Time to generate audio: {round(inference_time*1000)} milliseconds\n"
+            #)
+
+            wav = torch.cat(wav_chunks, dim=0)
+            print(wav.shape)
+            real_time_factor = (time.time() - t0) / wav.shape[0] * 24000
+            print(f"Real-time factor (RTF): {real_time_factor}")
+            metrics_text += f"Real-time factor (RTF): {real_time_factor:.2f}\n"
+
+            torchaudio.save("output.wav", wav.squeeze().unsqueeze(0).cpu(), 24000)
+            """
+
+        except RuntimeError as e:
+            if "device-side assert" in str(e):
+                # cannot do anything on cuda device side error, need tor estart
+                print(
+                    f"Exit due to: Unrecoverable exception caused by language:{language} prompt:{prompt}",
+                    flush=True,
+                )
+                gr.Warning("Unhandled Exception encounter, please retry in a minute")
+                print("Cuda device-assert Runtime encountered need restart")
+                if not DEVICE_ASSERT_DETECTED:
+                    DEVICE_ASSERT_DETECTED = 1
+                    DEVICE_ASSERT_PROMPT = prompt
+                    DEVICE_ASSERT_LANG = language
+
+                # just before restarting save what caused the issue so we can handle it in future
+                # Uploading Error data only happens for unrecovarable error
+                error_time = datetime.datetime.now().strftime("%d-%m-%Y-%H:%M:%S")
+                error_data = [
+                    error_time,
+                    prompt,
+                    language,
+                    audio_file_pth,
+                    mic_file_path,
+                    use_mic,
+                    voice_cleanup,
+                    no_lang_auto_detect,
+                    agree,
+                ]
+                error_data = [str(e) if type(e) != str else e for e in error_data]
+                print(error_data)
+                print(speaker_wav)
+                write_io = StringIO()
+                csv.writer(write_io).writerows([error_data])
+                csv_upload = write_io.getvalue().encode()
+
+                filename = error_time + "_" + str(uuid.uuid4()) + ".csv"
+                print("Writing error csv")
+                error_api = HfApi()
+                error_api.upload_file(
+                    path_or_fileobj=csv_upload,
+                    path_in_repo=filename,
+                    repo_id="coqui/xtts-flagged-dataset",
+                    repo_type="dataset",
+                )
+
+                # speaker_wav
+                print("Writing error reference audio")
+                speaker_filename = (
+                    error_time + "_reference_" + str(uuid.uuid4()) + ".wav"
+                )
+                error_api = HfApi()
+                error_api.upload_file(
+                    path_or_fileobj=speaker_wav,
+                    path_in_repo=speaker_filename,
+                    repo_id="coqui/xtts-flagged-dataset",
+                    repo_type="dataset",
+                )
+
+                # HF Space specific.. This error is unrecoverable need to restart space
+                space = api.get_space_runtime(repo_id=repo_id)
+                if space.stage!="BUILDING":
+                    api.restart_space(repo_id=repo_id)
+                else:
+                    print("TRIED TO RESTART but space is building")
+                    
+            else:
+                if "Failed to decode" in str(e):
+                    print("Speaker encoding error", str(e))
+                    gr.Warning(
+                        "It appears something wrong with reference, did you unmute your microphone?"
+                    )
+                else:
+                    print("RuntimeError: non device-side assert error:", str(e))
+                    gr.Warning("Something unexpected happened please retry again.")
+                return (
+                    None,
+                    None,
+                    None,
+                    None,
+                )
+        return (
+            gr.make_waveform(
+                audio="output.wav",
+            ),
+            "output.wav",
+            metrics_text,
+            speaker_wav,
+        )
+    else:
+        gr.Warning("Please accept the Terms & Condition!")
+        return (
+            None,
+            None,
+            None,
+            None,
+        )
+
+
+
+with gr.Blocks(analytics_enabled=False) as demo:
+    with gr.Row():
+        with gr.Column():
+            input_text_gr = gr.Textbox(
+                label="Text Prompt",
+                info="One or two sentences at a time is better. Up to 200 text characters.",
+                value="Hi there, I'm your new voice clone. Try your best to upload quality audio.",
+            )
+            language_gr = gr.Dropdown(
+                label="Language",
+                info="Select an output language for the synthesised speech",
+                choices=[
+                    "en",
+                    "es",
+                    "fr",
+                    "de",
+                    "it",
+                    "pt",
+                    "pl",
+                    "tr",
+                    "ru",
+                    "nl",
+                    "cs",
+                    "ar",
+                    "zh-cn",
+                    "ja",
+                    "ko",
+                    "hu",
+                    "hi"
+                ],
+                max_choices=1,
+                value="en",
+            )
+            ref_gr = gr.Audio(
+                label="Reference Audio",
+                info="Click on the ✎ button to upload your own target speaker audio",
+                type="filepath",
+                value="examples/female.wav",
+            )
+            mic_gr = gr.Audio(
+                source="microphone",
+                type="filepath",
+                info="Use your microphone to record audio",
+                label="Use Microphone for Reference",
+            )
+            use_mic_gr = gr.Checkbox(
+                label="Use Microphone",
+                value=False,
+                info="Notice: Microphone input may not work properly under traffic",
+            )
+            clean_ref_gr = gr.Checkbox(
+                label="Cleanup Reference Voice",
+                value=False,
+                info="This check can improve output if your microphone or reference voice is noisy",
+            )
+            auto_det_lang_gr = gr.Checkbox(
+                label="Do not use language auto-detect",
+                value=False,
+                info="Check to disable language auto-detection",
+            )
+            tos_gr = gr.Checkbox(
+                label="Agree",
+                value=False,
+                info="I agree to the terms of the CPML: https://coqui.ai/cpml",
+            )
+
+            tts_button = gr.Button("Send", elem_id="send-btn", visible=True)
+
+
+        with gr.Column():
+            video_gr = gr.Video(label="Waveform Visual")
+            audio_gr = gr.Audio(label="Synthesised Audio", autoplay=True)
+            out_text_gr = gr.Text(label="Metrics")
+            ref_audio_gr = gr.Audio(label="Reference Audio Used")
+
+    with gr.Row():
+        gr.Examples(examples,
+                    label="Examples",
+                    inputs=[input_text_gr, language_gr, ref_gr, mic_gr, use_mic_gr, clean_ref_gr, auto_det_lang_gr, tos_gr],
+                    outputs=[video_gr, audio_gr, out_text_gr, ref_audio_gr],
+                    fn=predict,
+                    cache_examples=False,)
+
+    tts_button.click(predict, [input_text_gr, language_gr, ref_gr, mic_gr, use_mic_gr, clean_ref_gr, auto_det_lang_gr, tos_gr], outputs=[video_gr, audio_gr, out_text_gr, ref_audio_gr])
+
+demo.queue()  
+demo.launch(debug=True, show_api=True)

config/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for config project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.0/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
+
+application = get_asgi_application()

config/settings.py

@@ -0,0 +1,140 @@
+"""
+Django settings for config project.
+
+Generated by 'django-admin startproject' using Django 5.0.1.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.0/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/5.0/ref/settings/
+"""
+
+import os
+import pprint
+pprint.pprint(os.environ)
+
+os.environ[ 'NUMBA_CACHE_DIR' ] = '/tmp/'
+
+from numba.caching import _UserProvidedCacheLocator
+print("@@@@@@@@@@@@@",_UserProvidedCacheLocator(lambda x:x, 'string').get_cache_path())
+
+
+
+from pathlib import Path
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/5.0/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = 'django-insecure-0%9gzn*t$0ca^@v@*-!cmjw_&*ig&8jp_26b=m-&9!$fc3wdy$'
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = True
+
+ALLOWED_HOSTS = ["*"]
+
+
+# Application definition
+
+INSTALLED_APPS = [
+    'django.contrib.admin',
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.messages',
+    'django.contrib.staticfiles',
+    'rest_framework',
+    'drf_yasg',
+    'texttovoice'
+]
+
+X_FRAME_OPTIONS = 'ALLOW-FROM https://huggingface.co/'
+
+MIDDLEWARE = [
+    'django.middleware.security.SecurityMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+    'django.middleware.clickjacking.XFrameOptionsMiddleware',
+]
+
+ROOT_URLCONF = 'config.urls'
+
+TEMPLATES = [
+    {
+        'BACKEND': 'django.template.backends.django.DjangoTemplates',
+        'DIRS': [],
+        'APP_DIRS': True,
+        'OPTIONS': {
+            'context_processors': [
+                'django.template.context_processors.debug',
+                'django.template.context_processors.request',
+                'django.contrib.auth.context_processors.auth',
+                'django.contrib.messages.context_processors.messages',
+            ],
+        },
+    },
+]
+
+
+WSGI_APPLICATION = 'config.wsgi.application'
+
+
+# Database
+# https://docs.djangoproject.com/en/5.0/ref/settings/#databases
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': BASE_DIR / 'db.sqlite3',
+    }
+}
+
+
+# Password validation
+# https://docs.djangoproject.com/en/5.0/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
+    },
+    {
+        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
+    },
+]
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/5.0/topics/i18n/
+
+LANGUAGE_CODE = 'en-us'
+
+TIME_ZONE = 'UTC'
+
+USE_I18N = True
+
+USE_TZ = True
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/5.0/howto/static-files/
+
+STATIC_URL = 'static/'
+
+# Default primary key field type
+# https://docs.djangoproject.com/en/5.0/ref/settings/#default-auto-field
+
+DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'

config/urls.py

@@ -0,0 +1,29 @@
+from django.contrib import admin
+from django.urls import path, re_path, include
+from rest_framework import permissions
+from drf_yasg.views import get_schema_view
+from drf_yasg import openapi
+
+schema_view = get_schema_view(
+    openapi.Info(
+        title="Your API",
+        default_version='v1',
+        description="Your API Description",
+        terms_of_service="https://www.yourwebsite.com/terms/",
+        contact=openapi.Contact(email="[email protected]"),
+        license=openapi.License(name="Your License"),
+    ),
+    public=True,
+    permission_classes=(permissions.AllowAny,),
+)
+
+
+from texttovoice.views import TextToSpeechCreateView
+
+urlpatterns = [
+    path('admin/', admin.site.urls),
+    path('generate-speech/', TextToSpeechCreateView.as_view(), name='generate-speech-create'),
+     path('swagger/', schema_view.with_ui('swagger', cache_timeout=0), name='schema-swagger-ui'),
+    re_path(r'^swagger(?P<format>\.json|\.yaml)$', schema_view.without_ui(cache_timeout=0), name='schema-json'),
+
+]

config/wsgi.py

@@ -0,0 +1,16 @@
+"""
+WSGI config for config project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.0/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
+
+application = get_wsgi_application()

manage.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == '__main__':
+    main()

requirements.txt

@@ -0,0 +1,17 @@
+TTS
+pydantic==1.10.13
+python-multipart==0.0.6
+typing-extensions>=4.8.0
+cutlet
+mecab-python3==1.0.6
+unidic-lite==1.0.8
+unidic==1.1.0
+langid
+deepspeed
+pydub
+Django
+djangorestframework
+drf-yasg
+
+# fastapi==0.70.0
+# uvicorn==0.15.0

texttovoice/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

texttovoice/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class TexttovoiceConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'texttovoice'

texttovoice/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

texttovoice/serializers.py

@@ -0,0 +1,6 @@
+from rest_framework import serializers
+
+class TextToSpeechSerializer(serializers.Serializer):
+    text = serializers.CharField()
+    speaker_wav = serializers.FileField()
+    language = serializers.CharField(default="en")

texttovoice/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

texttovoice/views.py

@@ -0,0 +1,50 @@
+import os
+import uuid
+from django.http import FileResponse
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.generics import CreateAPIView
+from TTS.api import TTS
+from .serializers import TextToSpeechSerializer
+
+class TextToSpeechCreateView(CreateAPIView):
+    serializer_class = TextToSpeechSerializer
+
+    def create(self, request, *args, **kwargs):
+        serializer = self.get_serializer(data=request.data)
+        if serializer.is_valid():
+            text = serializer.validated_data.get("text")
+            speaker_wav = serializer.validated_data.get("speaker_wav")
+            language = serializer.validated_data.get("language")
+            output_filename = f"output_{uuid.uuid4()}.wav"
+
+            try:
+                # Save the uploaded speaker file to a temporary location
+                speaker_file_path = os.path.join("/tmp", speaker_wav.name)
+                with open(speaker_file_path, "wb") as destination:
+                    for chunk in speaker_wav.chunks():
+                        destination.write(chunk)
+
+                # Generate speech using tts.tts_to_file
+                tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2", gpu=False)
+                tts.tts_to_file(text=text, file_path=output_filename, speaker_wav=speaker_file_path, language=language)
+
+                # Define a function to delete the output file
+                def file_iterator(file_name):
+                    with open(file_name, 'rb') as f:
+                        yield from f
+
+                    # Delete the file after sending it
+                    try:
+                        os.remove(file_name)
+                    except Exception as e:
+                        # You might want to log this error
+                        pass
+
+                # Use the file_iterator to create a FileResponse
+                response = FileResponse(file_iterator(output_filename), as_attachment=True, content_type='audio/wav')
+                return response
+
+            except Exception as e:
+                return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)