Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+alltalk_tts/system/word_addin/AllTalk[[:space:]]Word[[:space:]]Add-in.pdf filter=lfs diff=lfs merge=lfs -text

alltalk_tts/.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: erew123

alltalk_tts/.github/ISSUE_TEMPLATE/bug-report-support-request.md

@@ -0,0 +1,33 @@
+---
+name: Support Request/Issue
+about: Use this to create a support request or report a bug/issue
+title: ''
+labels: ''
+assignees: ''
+
+---
+🔴 If you have installed AllTalk in a custom Python environment, I will only be able to provide limited assistance/support. AllTalk draws on a variety of scripts and libraries that are not written or managed by myself, and they may fail, error or give strange results in custom built python environments.
+
+🔴 Please generate a diagnostics report and upload the "diagnostics.log" as this helps me understand your configuration.
+
+https://github.com/erew123/alltalk_tts/tree/main?#-how-to-make-a-diagnostics-report-file
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behaviour:
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Text/logs**
+If applicable, copy/paste in your logs here from the console.
+
+**Desktop (please complete the following information):**
+AllTalk was updated: [approx. date]
+Custom Python environment: [yes/no give details if yes]
+Text-generation-webUI was updated: [approx. date]
+
+**Additional context**
+Add any other context about the problem here.

alltalk_tts/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

alltalk_tts/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,23 @@
+---
+name: Feature request
+about: Use this to create a Feature request
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Please confirm you have read the current Features request list**
+https://github.com/erew123/alltalk_tts/discussions/74
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

alltalk_tts/.github/actions/docker-setup/action.yml

@@ -0,0 +1,73 @@
+name: 'Setting up docker'
+
+inputs:
+  DOCKERHUB_USERNAME:
+    description: "Docker hub username"
+    required: true
+  DOCKERHUB_REPO_NAME:
+    description: "Docker hub repo name"
+    required: true
+  DOCKERHUB_TOKEN:
+    description: "Docker hub token"
+    required: true
+
+runs:
+  using: "composite"
+  steps:
+    - name: Free Disk Space (Ubuntu)
+      uses: jlumbroso/free-disk-space@v1.3.1
+      with:
+        tool-cache: true
+        swap-storage: false
+        large-packages: false
+    - name: Read variables
+      shell: bash
+      run: |
+        source ./docker/variables.sh
+        for key in "${!ALLTALK_VARS[@]}"
+        do
+          echo "${key}=${ALLTALK_VARS[${key}]}"
+          echo "${key}=${ALLTALK_VARS[${key}]}" >> $GITHUB_ENV
+        done
+
+    - name: Extract version from Git Tag
+      shell: bash {0}
+      run: |
+        # Use the git tag if existing, otherwise 'latest':
+        DOCKER_TAG=$( echo "${{ github.ref }}" | grep -q tags | cut -d'/' -f 3 )
+        if [ -z "${DOCKER_TAG}" ]; then
+          DOCKER_TAG="latest"
+        fi
+        echo "Using DOCKER_TAG=${DOCKER_TAG}"
+        echo "DOCKER_TAG=${DOCKER_TAG}" >> $GITHUB_ENV
+
+    - name: Extract Docker Hub User and Repo Name
+      shell: bash
+      env:
+        DOCKERHUB_USERNAME: ${{ inputs.DOCKERHUB_USERNAME }}
+        DOCKERHUB_REPO_NAME: ${{ inputs.DOCKERHUB_REPO_NAME }}
+      run: |
+        if [ -n "${DOCKERHUB_USERNAME}" ]; then
+          echo "Using Github repository variable 'DOCKERHUB_USERNAME' as Docker hub username with value: '${DOCKERHUB_USERNAME}'"
+          echo "DOCKERHUB_USERNAME=${DOCKERHUB_USERNAME}" >> $GITHUB_ENV
+        else
+          echo "Using Github repository name as Docker hub username"
+          echo "DOCKERHUB_USERNAME=$(echo ${{ github.repository }} | cut -d'/' -f 1)" >> $GITHUB_ENV
+        fi
+
+        if [ -n "${DOCKERHUB_REPO_NAME}" ]; then
+          echo "Using Github repository variable 'DOCKERHUB_REPO_NAME' as Docker hub repo name with value: '${DOCKERHUB_REPO_NAME}'"
+          echo "DOCKERHUB_REPO_NAME=${DOCKERHUB_REPO_NAME}" >> $GITHUB_ENV
+        else
+          echo "Using Github repository name as Docker hub repo name"
+          echo "DOCKERHUB_REPO_NAME=$(echo ${{ github.repository }} | cut -d'/' -f 2)" >> $GITHUB_ENV
+        fi
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Login to DockerHub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ inputs.DOCKERHUB_USERNAME }}
+        password: ${{ inputs.DOCKERHUB_TOKEN }}

alltalk_tts/.github/workflows/publish-docker-v2.yml

@@ -0,0 +1,124 @@
+name: Publish Docker v2
+
+on:
+  workflow_dispatch:
+  release:
+    types: [ published ]
+  push:
+    branches:
+      - 'alltalkbeta'
+    tags:
+      - 'v*'
+
+# Limit the concurrency of entire workflow runs for a specific branch:
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build_base_environment_docker_image:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup docker
+        uses: ./.github/actions/docker-setup
+        with:
+          DOCKERHUB_USERNAME: ${{ vars.DOCKERHUB_USERNAME }}
+          DOCKERHUB_REPO_NAME: ${{ vars.DOCKERHUB_REPO_NAME }}
+          DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            ${{ env.DOCKERHUB_USERNAME }}/${{ env.DOCKERHUB_REPO_NAME }}_environment
+          tags: |
+            # Use sematic versioning on push tag event:
+            type=semver,pattern={{version}}
+            # set latest tag for main and alltalkbeta branch:
+            type=raw,value=latest,enable=${{ github.ref == format('refs/heads/{0}', 'main') || github.ref == format('refs/heads/{0}', 'alltalkbeta') }}
+
+      - uses: dorny/paths-filter@v3
+        id: changes
+        with:
+          base: 'alltalkbeta'
+          filters: |
+            docker-base:
+              - 'docker/variables.sh'
+              - 'docker/base/Dockerfile'
+            docker-workflow:
+              - '.github/workflows/publish-docker*.yml'
+
+      - name: Build and push base Docker image
+        if: |
+          steps.changes.outputs.docker-base == 'true' ||
+          steps.changes.outputs.docker-workflow == 'true' ||
+          github.event_name == 'release' ||
+          (github.event_name == 'push' && contains(github.ref, 'refs/tags/'))
+        uses: docker/build-push-action@v6
+        with:
+          context: ./docker/base
+          file: ./docker/base/Dockerfile
+          platforms: "linux/amd64"
+          push: true
+          build-args: |
+            CUDA_VERSION=${{ env.CUDA_VERSION }}
+            PYTHON_VERSION=${{ env.PYTHON_VERSION }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=registry,ref=${{ env.DOCKERHUB_USERNAME }}/${{ env.DOCKERHUB_REPO_NAME }}_environment:buildcache
+          cache-to: type=registry,ref=${{ env.DOCKERHUB_USERNAME }}/${{ env.DOCKERHUB_REPO_NAME }}_environment:buildcache,mode=max
+
+  build_main_docker_image:
+    needs: build_base_environment_docker_image
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        tts: [ xtts, vits, piper ]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup docker
+        uses: ./.github/actions/docker-setup
+        with:
+          DOCKERHUB_USERNAME: ${{ vars.DOCKERHUB_USERNAME }}
+          DOCKERHUB_REPO_NAME: ${{ vars.DOCKERHUB_REPO_NAME }}
+          DOCKERHUB_TOKEN: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            ${{ env.DOCKERHUB_USERNAME }}/${{ env.DOCKERHUB_REPO_NAME }}
+          flavor: |
+            suffix=-${{ matrix.tts }},onlatest=true
+          tags: |
+            # Use sematic versioning on push tag event:
+            type=semver,pattern={{version}}
+            # set latest tag for main and alltalkbeta branch:
+            type=raw,value=latest,enable=${{ github.ref == format('refs/heads/{0}', 'main') || github.ref == format('refs/heads/{0}', 'alltalkbeta') }}
+
+      - name: Build and push base Docker image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: "linux/amd64"
+          push: true
+          build-args: |
+            TTS_MODEL=${{ matrix.tts }}
+            ALLTALK_DIR=${{ env.ALLTALK_DIR }}
+            DEEPSPEED_VERSION=${{ env.DEEPSPEED_VERSION }}
+            DOCKER_TAG=${{ env.DOCKER_TAG }}
+            DOCKER_REPOSITORY=${{ env.DOCKERHUB_USERNAME }}/
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=registry,ref=${{ env.DOCKERHUB_USERNAME }}/${{ env.DOCKERHUB_REPO_NAME }}:buildcache-${{ matrix.tts }}
+          cache-to: type=registry,ref=${{ env.DOCKERHUB_USERNAME }}/${{ env.DOCKERHUB_REPO_NAME }}:buildcache-${{ matrix.tts }},mode=max

alltalk_tts/.github/workflows/publish-docker.yml

@@ -0,0 +1,67 @@
+name: Publish Docker image (main branch)
+
+on:
+#  push:
+#    branches: [main]
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build_and_push:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - dockerfile: "Dockerfile"
+            platforms: "linux/amd64"
+            tag_name: "cpu"
+          - dockerfile: "nvidia.Dockerfile"
+            platforms: "linux/amd64"
+            tag_name: "cuda"
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Lowercase Actor and Extract Repo Name
+        run: |
+          echo "ACTOR_LOWER=$(echo ${{ github.actor }} | tr '[:upper:]' '[:lower:]')" >> $GITHUB_ENV
+          echo "REPO_NAME=$(echo ${{ github.repository }} | cut -d'/' -f 2)" >> $GITHUB_ENV
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ env.ACTOR_LOWER }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ vars.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./${{ matrix.dockerfile }}
+          platforms: ${{ matrix.platforms }}
+          push: true
+          tags: |
+            ghcr.io/${{ env.ACTOR_LOWER }}/${{ env.REPO_NAME }}:${{ matrix.tag_name }}-${{ github.sha }}
+            ghcr.io/${{ env.ACTOR_LOWER }}/${{ env.REPO_NAME }}:${{ matrix.tag_name }}
+            ghcr.io/${{ env.ACTOR_LOWER }}/${{ env.REPO_NAME }}:latest
+            ${{ vars.DOCKERHUB_USERNAME }}/${{ env.REPO_NAME }}:${{ matrix.tag_name }}-${{ github.sha }}
+            ${{ vars.DOCKERHUB_USERNAME }}/${{ env.REPO_NAME }}:${{ matrix.tag_name }}
+            ${{ vars.DOCKERHUB_USERNAME }}/${{ env.REPO_NAME }}:latest
+
+      - name: Docker Hub Description
+        uses: peter-evans/dockerhub-description@v3.4.2
+        with:
+          username: ${{ vars.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          repository: ${{ vars.DOCKERHUB_USERNAME }}/${{ env.REPO_NAME }}

alltalk_tts/.github/workflows/python-ci.yml

@@ -0,0 +1,53 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Python CI
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python 3.11.9
+        uses: actions/setup-python@v3
+        if: ${{ hashFiles('./test') != '' }}
+        with:
+          python-version: "3.11.9"
+      - name: Install dependencies
+        if: ${{ hashFiles('./test') != '' }}
+        run: |
+          python -m pip install --upgrade pip
+          if [ -f system/requirements/requirements_unit_test.txt ]; then
+            pip install -r system/requirements/requirements_unit_test.txt;
+          fi
+      - name: Test with pytest
+        if: ${{ hashFiles('./test') != '' }}
+        run: |
+          pytest test --doctest-modules --junitxml=junit/test-results.xml --cov=com --cov-report=xml --cov-report=html
+      - name: Surface failing tests
+        if: always()
+        uses: pmeier/pytest-results-action@v0.6.0
+        with:
+          # A list of JUnit XML files, directories containing the former, and wildcard
+          # patterns to process.
+          # See @actions/glob for supported patterns.
+          path: junit/test-results.xml
+
+          # (Optional) Add a summary of the results at the top of the report
+          summary: true
+
+          # (Optional) Select which results should be included in the report.
+          # Follows the same syntax as `pytest -r`
+          display-options: fEX
+
+          # (Optional) Fail the workflow if no JUnit XML was found.
+          fail-on-empty: false
+
+          # (Optional) Title of the test results section in the workflow summary
+          title: Test results

alltalk_tts/.gitignore

@@ -0,0 +1,8 @@
+voices/*.*
+models/*.*
+outputs/*.*
+finetune/*.*
+config.json
+confignew.json
+models.json
+diagnostics.log

alltalk_tts/.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+    "files.associations": {
+        "*.html": "jinja-html"
+    },
+    "emmet.includeLanguages": {
+        "jinja-html": "html",
+        "jinja2": "html"
+    },
+}

alltalk_tts/Dockerfile

@@ -0,0 +1,20 @@
+FROM nvidia/cuda:12.1.1-devel-ubuntu22.04
+ENV HOST 0.0.0.0
+RUN apt-get update && apt-get upgrade -y \
+    && apt-get install -y git build-essential portaudio19-dev \
+    python3 python3-pip gcc wget \
+    ocl-icd-opencl-dev opencl-headers clinfo \
+    libclblast-dev libopenblas-dev libaio-dev \
+    && mkdir -p /etc/OpenCL/vendors && echo "libnvidia-opencl.so.1" > /etc/OpenCL/vendors/nvidia.icd \
+    && ln -s /usr/bin/python3 /usr/bin/python
+
+WORKDIR /app
+ENV CUDA_DOCKER_ARCH=all
+COPY system/requirements/requirements_docker.txt system/requirements/requirements_docker.txt
+RUN pip install --no-cache-dir --no-deps -r system/requirements/requirements_docker.txt && \
+    pip install --no-cache-dir deepspeed
+COPY . .
+
+EXPOSE 7851 7852
+RUN chmod +x launch.sh
+ENTRYPOINT ["sh", "-c", "./launch.sh"]

alltalk_tts/LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

alltalk_tts/atsetup.bat

@@ -0,0 +1,659 @@
+@echo off
+cd /D "%~dp0"
+setlocal enabledelayedexpansion
+@set "PATH=%PATH%;%SystemRoot%\system32"
+
+:: Generate the ESC character
+for /F %%a in ('echo prompt $E ^| cmd') do set "ESC=%%a"
+
+:: Standard Colors
+set "BLACK=%ESC%[30m"
+set "RED=%ESC%[31m"
+set "GREEN=%ESC%[32m"
+set "YELLOW=%ESC%[33m"
+set "BLUE=%ESC%[34m"
+set "MAGENTA=%ESC%[35m"
+set "CYAN=%ESC%[36m"
+set "WHITE=%ESC%[37m"
+set "L_BLACK=%ESC%[90m"
+set "L_RED=%ESC%[91m"
+set "L_GREEN=%ESC%[92m"
+set "L_YELLOW=%ESC%[93m"
+set "L_BLUE=%ESC%[94m"
+set "L_MAGENTA=%ESC%[95m"
+set "L_CYAN=%ESC%[96m"
+set "L_WHITE=%ESC%[97m"
+set "RESET=%ESC%[0m"
+
+echo "%CD%"| findstr /C:" " >nul &&  echo. && echo    %L_BLUE%ALLTALK WINDOWS SETUP UTILITY%RESET% && echo. &&  echo. &&  echo    You are trying to install AllTalk in a folder that has a space in the folder path e.g. && echo. && echo       C:\%L_RED%program files%RESET%\alltalk_tts && echo.	&& echo    This causes errors with Conda and Python scripts. Please follow this link for reference: &&  echo. && echo      %L_CYAN%https://docs.anaconda.com/free/working-with-conda/reference/faq/#installing-anaconda%RESET% && echo. && echo    Please use a folder path that has no spaces in it e.g. && echo. && echo       C:\myfiles\alltalk_tts\ && echo. && echo. && pause && goto :end
+
+@rem Check for special characters in installation path
+set "SPCHARMESSAGE="WARNING: Special characters were detected in the installation path!" "         This can cause the installation to fail!""
+echo "%CD%"| findstr /R /C:"[!#\$%&()\*+,;<=>?@\[\]\^`{|}~]" >nul && (
+	call :PrintBigMessage %SPCHARMESSAGE%
+)
+set SPCHARMESSAGE=
+
+@rem Check if curl is available
+curl --version >nul 2>&1
+if "%ERRORLEVEL%" NEQ "0" (
+    echo curl is not available on this system. Please install curl then re-run the script https://curl.se/ 
+	echo or perform a manual installation of a Conda Python environment.
+    goto end
+)
+
+:MainMenu
+cls
+echo.
+echo    %L_BLUE%ALLTALK WINDOWS SETUP UTILITY%RESET%
+echo.
+echo    INSTALLATION TYPE
+echo    1) I am using AllTalk as part of %L_GREEN%Text-generation-webui%RESET%
+echo    2) I am using AllTalk as a %L_GREEN%Standalone Application%RESET%
+echo.
+echo    9) %L_RED%Exit/Quit%RESET%
+echo.
+set /p UserOption="    Enter your choice: "
+
+if "%UserOption%"=="1" goto WebUIMenu
+if "%UserOption%"=="2" goto StandaloneMenu
+if "%UserOption%"=="9" goto End
+goto MainMenu
+
+:WebUIMenu
+cls
+echo.
+echo    %L_BLUE%TEXT-GENERATION-WEBUI SETUP%RESET%
+echo.
+echo    Please ensure you have started your Text-generation-webui Python 
+echo    environment. If you have NOT done this, please run %L_GREEN%cmd_windows.bat%RESET% 
+echo    in the %L_GREEN%text-generation-webui%RESET% folder and then re-run this script.
+echo.
+echo    BASE REQUIREMENTS
+echo    1) Apply/Re-Apply the requirements for %L_GREEN%Text-generation-webui%RESET%.
+echo.
+echo    OPTIONAL
+echo    2) Git Pull the latest AllTalk updates from Github
+echo.
+echo    DEEPSPEED FOR %L_YELLOW=%PyTorch 2.1.x%RESET%
+echo    4) Install DeepSpeed v11.2 for CUDA %L_GREEN%11.8%RESET% and Python-3.11.x and %L_YELLOW%PyTorch 2.1.x%RESET%.
+echo    5) Install DeepSpeed v11.2 for CUDA %L_GREEN%12.1%RESET% and Python-3.11.x and %L_YELLOW%PyTorch 2.1.x%RESET%.
+echo.
+echo    DEEPSPEED FOR %L_YELLOW=%PyTorch 2.2.x%RESET% (March 2024 builds of Text-gen-webui and later)
+echo    6) Install DeepSpeed v14.0 for CUDA %L_GREEN%12.1%RESET% and Python-3.11.x and %L_YELLOW%PyTorch 2.2.x%RESET%.
+echo    7) Install DeepSpeed v14.0 for CUDA %L_GREEN%11.8%RESET% and Python-3.11.x and %L_YELLOW%PyTorch 2.2.x%RESET%.
+echo.
+echo    U) Uninstall DeepSpeed.
+echo.
+echo.   OTHER
+echo    8) Generate a diagnostics file.
+echo.
+echo    9) %L_RED%Exit/Quit%RESET%
+echo.
+set /p WebUIOption="Enter your choice: "
+if "%WebUIOption%"=="1" goto InstallNvidiaTextGen
+if "%WebUIOption%"=="2" goto TGGitpull
+if "%WebUIOption%"=="4" goto InstallDeepSpeed118TextGen
+if "%WebUIOption%"=="5" goto InstallDeepSpeed121TextGen
+if "%WebUIOption%"=="6" goto InstallDeepSpeed121TextGenPytorch221
+if "%WebUIOption%"=="7" goto InstallDeepSpeed118TextGenPytorch221
+if "%WebUIOption%"=="U" goto UnInstallDeepSpeed
+if "%WebUIOption%"=="u" goto UnInstallDeepSpeed
+if "%WebUIOption%"=="8" goto GenerateDiagsTextGen
+if "%WebUIOption%"=="9" goto End
+goto WebUIMenu
+
+:StandaloneMenu
+cls
+echo.
+echo    %L_BLUE%ALLTALK STANDALONE APPLICATION SETUP%RESET%
+echo.
+echo    BASE REQUIREMENTS
+echo    1) Install AllTalk as a Standalone Application
+echo.
+echo    OPTIONAL
+echo    2) Git Pull the latest AllTalk updates from Github
+echo    3) Re-Apply/Update the requirements file
+echo    4) Delete AllTalk's custom Python environment
+echo    5) Purge the PIP cache
+echo.
+echo.   OTHER
+echo    8) Generate a diagnostics file
+echo.
+echo    9) %L_RED%Exit/Quit%RESET%
+echo.
+set /p StandaloneOption="Enter your choice: "
+if "%StandaloneOption%"=="1" goto InstallCustomStandalone
+if "%StandaloneOption%"=="2" goto STGitpull
+if "%StandaloneOption%"=="3" goto STReapplyrequirements
+if "%StandaloneOption%"=="4" goto STDeleteCustomStandalone
+if "%StandaloneOption%"=="5" goto STPurgepipcache
+if "%StandaloneOption%"=="8" goto GenerateDiagsStandalone
+if "%StandaloneOption%"=="9" goto EndStandalone
+goto StandaloneMenu
+
+:InstallNvidiaTextGen
+pip install -r system\requirements\requirements_textgen.txt
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    There was an error installing the requirements.
+    echo    Have you started your Text-gen-webui Python environment
+    echo    with cmd_{yourOS} before running atsetup.bat?
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+Echo.
+echo.
+Echo    Requirements installed successfully.
+Echo. 
+pause
+goto WebUIMenu
+
+:TGGitpull
+git pull
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    There was an error pulling from Github.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+Echo.
+echo     AllTalk Updated from Github. Please re-apply
+echo     the latest requirements file. Option 1
+Echo. 
+pause
+goto WebUIMenu
+
+:InstallDeepSpeed118TextGen
+echo Downloading DeepSpeed...
+curl -LO https://github.com/erew123/alltalk_tts/releases/download/deepspeed/deepspeed-0.11.2+cuda118-cp311-cp311-win_amd64.whl
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    Failed to download DeepSpeed wheel file.
+    echo    Please check your internet connection or try again later.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+echo DeepSpeed wheel file downloaded successfully.
+echo Installing DeepSpeed...
+pip install deepspeed-0.11.2+cuda118-cp311-cp311-win_amd64.whl
+if %ERRORLEVEL% neq 0 (
+    echo. 
+    echo    Failed to install DeepSpeed.
+    echo    Please check if the wheel file is compatible with your system.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+Echo.
+echo.
+Echo    DeepSpeed installed successfully.
+Echo. 
+del deepspeed-0.11.2+cuda118-cp311-cp311-win_amd64.whl
+pause
+goto WebUIMenu
+
+:InstallDeepSpeed121TextGen
+echo Downloading DeepSpeed...
+curl -LO https://github.com/erew123/alltalk_tts/releases/download/deepspeed/deepspeed-0.11.2+cuda121-cp311-cp311-win_amd64.whl
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    Failed to download DeepSpeed wheel file.
+    echo    Please check your internet connection or try again later.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+echo    DeepSpeed wheel file downloaded successfully.
+echo    Installing DeepSpeed...
+pip install deepspeed-0.11.2+cuda121-cp311-cp311-win_amd64.whl
+if %ERRORLEVEL% neq 0 (
+    echo. 
+    echo    Failed to install DeepSpeed.
+    echo    Please check if the wheel file is compatible with your system.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+Echo.
+echo.
+Echo    DeepSpeed installed successfully.
+Echo. 
+del deepspeed-0.11.2+cuda121-cp311-cp311-win_amd64.whl
+pause
+goto WebUIMenu
+
+:InstallDeepSpeed121TextGenPytorch221
+echo Downloading DeepSpeed...
+curl -LO https://github.com/erew123/alltalk_tts/releases/download/DeepSpeed-14.0/deepspeed-0.14.0+ce78a63-cp311-cp311-win_amd64.whl
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    Failed to download DeepSpeed wheel file.
+    echo    Please check your internet connection or try again later.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+echo    DeepSpeed wheel file downloaded successfully.
+echo    Installing DeepSpeed...
+pip install deepspeed-0.14.0+ce78a63-cp311-cp311-win_amd64.whl
+if %ERRORLEVEL% neq 0 (
+    echo. 
+    echo    Failed to install DeepSpeed.
+    echo    Please check if the wheel file is compatible with your system.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+Echo.
+echo.
+Echo    DeepSpeed installed successfully.
+Echo. 
+del deepspeed-0.14.0+ce78a63-cp311-cp311-win_amd64.whl
+pause
+goto WebUIMenu
+
+:InstallDeepSpeed118TextGenPytorch221
+echo Downloading DeepSpeed...
+curl -LO https://github.com/erew123/alltalk_tts/releases/download/DeepSpeed-14.0/deepspeed-0.14.0+cu118-cp311-cp311-win_amd64.whl
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    Failed to download DeepSpeed wheel file.
+    echo    Please check your internet connection or try again later.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+echo    DeepSpeed wheel file downloaded successfully.
+echo    Installing DeepSpeed...
+pip install deepspeed-0.14.0+cu118-cp311-cp311-win_amd64.whl
+if %ERRORLEVEL% neq 0 (
+    echo. 
+    echo    Failed to install DeepSpeed.
+    echo    Please check if the wheel file is compatible with your system.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+Echo.
+echo.
+Echo    DeepSpeed installed successfully.
+Echo. 
+del deepspeed-0.14.0+cu118-cp311-cp311-win_amd64.whl
+pause
+goto WebUIMenu
+
+:UnInstallDeepSpeed
+pip uninstall deepspeed
+if %ERRORLEVEL% neq 0 (
+    echo. 
+    echo    There was an error uninstalling DeepSpeed.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto WebUIMenu
+)
+echo.
+Echo    DeepSpeed uninstalled successfully.
+Echo. 
+pause
+goto WebUIMenu
+
+:GenerateDiagsTextGen
+Python diagnostics.py
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    There was an error running diagnostics. Have you correctly started your 
+    echo    Text-generation-webui Python environment with %L_GREEN%cmd_windows.bat%RESET%?
+    echo.
+    pause
+    goto WebUIMenu
+)
+Echo.
+echo.
+Echo    Diagnostics.log generated. Please scroll up to look over the log.
+Echo. 
+pause
+goto WebUIMenu
+
+:InstallCustomStandalone
+set PATH=%PATH%;%SystemRoot%\system32
+
+@rem Check if curl is available
+curl --version >nul 2>&1
+if "%ERRORLEVEL%" NEQ "0" (
+    echo curl is not available on this system. Please install curl then re-run the script https://curl.se/ 
+	echo or perform a manual installation of a Conda Python environment.
+    goto end
+)
+echo "%CD%"| findstr /C:" " >nul && echo This script relies on Miniconda which can not be silently installed under a path with spaces. Please correct your folder names and re-try installation. && goto exit
+
+@rem Check for special characters in installation path
+set "SPCHARMESSAGE=WARNING: Special characters were detected in the installation path! This can cause the installation to fail!"
+echo "%CD%"| findstr /R /C:"[!#\$%&()\*+,;<=>?@\[\]\^`{|}~]" >nul && (
+    call :PrintBigMessage %SPCHARMESSAGE%
+)
+set SPCHARMESSAGE=
+
+@rem fix failed install when installing to a separate drive
+set TMP=%cd%\alltalk_environment
+set TEMP=%cd%\alltalk_environment
+
+@rem deactivate existing conda envs as needed to avoid conflicts
+(call conda deactivate && call conda deactivate && call conda deactivate) 2>nul
+
+@rem config
+set INSTALL_DIR=%cd%\alltalk_environment
+set CONDA_ROOT_PREFIX=%cd%\alltalk_environment\conda
+set INSTALL_ENV_DIR=%cd%\alltalk_environment\env
+set MINICONDA_DOWNLOAD_URL=https://repo.anaconda.com/miniconda/Miniconda3-py310_23.3.1-0-Windows-x86_64.exe
+set conda_exists=F
+
+@rem figure out whether git and conda need to be installed
+call "%CONDA_ROOT_PREFIX%\_conda.exe" --version >nul 2>&1
+if "%ERRORLEVEL%" EQU "0" (
+    set conda_exists=T
+    call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%"
+    goto RunScript
+)
+
+@rem download and install conda if not installed
+echo Downloading Miniconda from %MINICONDA_DOWNLOAD_URL% to %INSTALL_DIR%\miniconda_installer.exe
+mkdir "%INSTALL_DIR%"
+call curl -Lk "%MINICONDA_DOWNLOAD_URL%" > "%INSTALL_DIR%\miniconda_installer.exe" || ( echo. && echo Miniconda failed to download. && goto end )
+echo Installing Miniconda to %CONDA_ROOT_PREFIX%
+start /wait "" "%INSTALL_DIR%\miniconda_installer.exe" /InstallationType=JustMe /NoShortcuts=1 /AddToPath=0 /RegisterPython=0 /NoRegistry=1 /S /D=%CONDA_ROOT_PREFIX%
+echo Miniconda version:
+call "%CONDA_ROOT_PREFIX%\_conda.exe" --version || ( echo. && echo Miniconda not found. && goto end )
+
+@rem create the installer env
+echo Packages to install: %PACKAGES_TO_INSTALL%
+call "%CONDA_ROOT_PREFIX%\_conda.exe" create --no-shortcuts -y -k --prefix "%INSTALL_ENV_DIR%" python=3.11 || ( echo. && echo Conda environment creation failed. && goto end )
+
+@rem check if conda environment was actually created
+if not exist "%INSTALL_ENV_DIR%\python.exe" ( echo. && echo Conda environment is empty. && goto end )
+
+@rem activate installer env
+call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%" || ( echo. && echo Miniconda hook not found. && goto end )
+
+echo.
+echo     Downloading and installing PyTorch. This step can take a long time
+echo     depending on your internet connection and hard drive speed. Please
+echo     be patient.
+echo.
+pip install torch==2.2.2+cu121 torchaudio>=2.2.2+cu121 --upgrade --force-reinstall --extra-index-url https://download.pytorch.org/whl/cu121
+echo Installing other requirements.
+echo.
+pip install -r system\requirements\requirements_standalone.txt
+curl -LO https://github.com/erew123/alltalk_tts/releases/download/DeepSpeed-14.0/deepspeed-0.14.0+ce78a63-cp311-cp311-win_amd64.whl
+echo Installing DeepSpeed...
+pip install deepspeed-0.14.0+ce78a63-cp311-cp311-win_amd64.whl
+del deepspeed-0.14.0+ce78a63-cp311-cp311-win_amd64.whl
+
+
+@rem Create start_environment.bat to run AllTalk environment
+echo @echo off > start_environment.bat
+echo cd /D "%~dp0" >> start_environment.bat
+echo set CONDA_ROOT_PREFIX=%cd%\alltalk_environment\conda >> start_environment.bat
+echo set INSTALL_ENV_DIR=%cd%\alltalk_environment\env >> start_environment.bat
+echo call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%" >> start_environment.bat
+@rem Create start_alltalk.bat to run AllTalk
+echo @echo off > start_alltalk.bat
+echo cd /D "%~dp0" >> start_alltalk.bat
+echo set CONDA_ROOT_PREFIX=%cd%\alltalk_environment\conda >> start_alltalk.bat
+echo set INSTALL_ENV_DIR=%cd%\alltalk_environment\env >> start_alltalk.bat
+echo call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%" >> start_alltalk.bat
+echo call python script.py >> start_alltalk.bat
+@rem Create start_finetune.bat to run AllTalk
+echo @echo off > start_finetune.bat
+echo cd /D "%~dp0" >> start_finetune.bat
+echo set CONDA_ROOT_PREFIX=%cd%\alltalk_environment\conda >> start_finetune.bat
+echo set INSTALL_ENV_DIR=%cd%\alltalk_environment\env >> start_finetune.bat
+echo call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%" >> start_finetune.bat
+echo call python finetune.py >> start_finetune.bat
+Echo.
+Echo    Run %L_YELLOW%start_alltalk.bat%RESET% to start AllTalk.
+Echo    Run %L_YELLOW%start_finetune.bat%RESET% to start Finetuning.
+Echo    Run %L_YELLOW%start_environment.bat%RESET% to start the AllTalk Python environment.
+Echo.
+pause
+goto StandaloneMenu
+
+:STDeleteCustomStandalone
+@rem Check if the alltalk_environment directory exists
+if not exist "%cd%\alltalk_environment\" (
+    echo.
+    echo    %L_GREEN%alltalk_environment%RESET% directory does not exist. No need to delete.
+    echo.
+    pause
+    goto StandaloneMenu
+)
+@rem Check if a Conda environment is active
+if not defined CONDA_PREFIX goto NoCondaEnvDeleteCustomStandalone
+@rem Deactivate Conda environment if it's active
+Echo    Exiting the Conda Environment. Please run %L_GREEN%atsetup.bat%RESET% again and delete the environment.
+conda deactivate
+:NoCondaEnvDeleteCustomStandalone
+echo Deleting "alltalk_environment". Please wait.
+rd /s /q "alltalk_environment"
+del start_alltalk.bat
+del start_environment.bat
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    Failed to delete alltalk_environment folder.
+    echo    Please make sure it is not in use and try again.
+    echo.
+    pause
+    goto StandaloneMenu
+)
+echo.
+Echo.
+echo    Environment %L_GREEN%alltalk_environment%RESET% deleted. Please set up the environment again.
+Echo.
+pause
+goto StandaloneMenu
+
+:GenerateDiagsStandalone
+cd /D "%~dp0"
+set CONDA_ROOT_PREFIX=%cd%\alltalk_environment\conda
+set INSTALL_ENV_DIR=%cd%\alltalk_environment\env
+@rem Check if the Conda environment exists
+if not exist "%INSTALL_ENV_DIR%\python.exe" (
+    echo.
+    echo    The Conda environment at "%INSTALL_ENV_DIR%" does not exist.
+    echo    Please install the environment before proceeding.
+    echo. 
+    pause
+    goto StandaloneMenu
+)
+@rem Attempt to activate the Conda environment
+call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%"
+if errorlevel 1 (
+    echo. 
+    echo    Failed to activate the Conda environment.
+    echo    Please check your installation and try again.
+    echo.
+    pause
+    goto StandaloneMenu
+)
+@rem Run diagnostics
+Python diagnostics.py
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    There was an error running diagnostics.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto StandaloneMenu
+)
+Echo.
+Echo.
+Echo    Diagnostics.log generated. Please scroll up to look over the log.
+Echo.
+pause
+goto StandaloneMenu
+
+:STReapplyrequirements
+cd /D "%~dp0"
+set CONDA_ROOT_PREFIX=%cd%\alltalk_environment\conda
+set INSTALL_ENV_DIR=%cd%\alltalk_environment\env
+@rem Check if the Conda environment exists
+if not exist "%INSTALL_ENV_DIR%\python.exe" (
+    echo.
+    echo    The Conda environment at "%INSTALL_ENV_DIR%" does not exist.
+    echo    Please install the environment before proceeding.
+    echo. 
+    pause
+    goto StandaloneMenu
+)
+@rem Attempt to activate the Conda environment
+call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%"
+if errorlevel 1 (
+    echo. 
+    echo    Failed to activate the Conda environment.
+    echo    Please check your installation and try again.
+    echo.
+    pause
+    goto StandaloneMenu
+)
+@rem Run Reapply requirements
+echo.
+echo     Downloading and installing PyTorch. This step can take a long time
+echo     depending on your internet connection and hard drive speed. Please
+echo     be patient.
+echo.
+pip install torch==2.2.2+cu121 torchaudio>=2.2.2+cu121 --upgrade --force-reinstall --extra-index-url https://download.pytorch.org/whl/cu121
+echo Installing other requirements.
+echo.
+pip install -r system\requirements\requirements_standalone.txt
+C:/Windows/system32/curl.exe -LO https://github.com/erew123/alltalk_tts/releases/download/DeepSpeed-14.0/deepspeed-0.14.0+ce78a63-cp311-cp311-win_amd64.whl
+echo Installing DeepSpeed...
+pip install deepspeed-0.14.0+ce78a63-cp311-cp311-win_amd64.whl
+del deepspeed-0.14.0+ce78a63-cp311-cp311-win_amd64.whl
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    There was an error.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto StandaloneMenu
+)
+Echo.
+Echo.
+Echo    Requirements have been re-applied/updated.
+Echo.
+pause
+goto StandaloneMenu
+
+:STPurgepipcache
+cd /D "%~dp0"
+set CONDA_ROOT_PREFIX=%cd%\alltalk_environment\conda
+set INSTALL_ENV_DIR=%cd%\alltalk_environment\env
+@rem Check if the Conda environment exists
+if not exist "%INSTALL_ENV_DIR%\python.exe" (
+    echo.
+    echo    The Conda environment at "%INSTALL_ENV_DIR%" does not exist.
+    echo    Please install the environment before proceeding.
+    echo. 
+    pause
+    goto StandaloneMenu
+)
+@rem Attempt to activate the Conda environment
+call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%"
+if errorlevel 1 (
+    echo. 
+    echo    Failed to activate the Conda environment.
+    echo    Please check your installation and try again.
+    echo.
+    pause
+    goto StandaloneMenu
+)
+@rem Clear the PIP cache
+echo.
+echo     Purging the PIP cache of downloaded files.
+echo.
+pip cache purge
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    There was an error.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto StandaloneMenu
+)
+Echo.
+Echo    The PIP cache has been purged.
+Echo.
+pause
+goto StandaloneMenu
+
+:STGitpull
+cd /D "%~dp0"
+set CONDA_ROOT_PREFIX=%cd%\alltalk_environment\conda
+set INSTALL_ENV_DIR=%cd%\alltalk_environment\env
+@rem Check if the Conda environment exists
+if not exist "%INSTALL_ENV_DIR%\python.exe" (
+    echo.
+    echo    The Conda environment at "%INSTALL_ENV_DIR%" does not exist.
+    echo    Please install the environment before proceeding.
+    echo. 
+    pause
+    goto StandaloneMenu
+)
+@rem Attempt to activate the Conda environment
+call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%"
+if errorlevel 1 (
+    echo. 
+    echo    Failed to activate the Conda environment.
+    echo    Please check your installation and try again.
+    echo.
+    pause
+    goto StandaloneMenu
+)
+@rem Pull from Github
+echo.
+echo     Pulling the latest updates. Please re-apply
+echo     the latest requirements file. Option 3
+echo.
+git pull
+if %ERRORLEVEL% neq 0 (
+    echo.
+    echo    There was an error pulling from Github.
+    echo    Press any key to return to the menu.
+    echo.
+    pause
+    goto StandaloneMenu
+)
+Echo.
+echo     AllTalk Updated from Github. Please re-apply
+echo     the latest requirements file. Option 3
+Echo.
+pause
+goto StandaloneMenu
+
+:EndStandalone
+echo Exiting AllTalk Setup Utility...
+echo.
+Echo    Remember, after installation you can....
+Echo    Run %L_YELLOW%start_alltalk.bat%RESET% to start AllTalk.
+Echo    Run %L_YELLOW%start_finetune.bat%RESET% to start Finetuning.
+Echo    Run %L_YELLOW%start_environment.bat%RESET% to start the AllTalk Python environment.
+Echo.
+exit /b
+
+:End
+echo Exiting AllTalk Setup Utility...
+exit /b

alltalk_tts/atsetup.sh

@@ -0,0 +1,520 @@
+#!/bin/bash
+
+# ANSI color codes
+RED='\033[1;31m'
+GREEN='\033[1;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[1;34m'
+CYAN='\033[1;36m'
+MAGENTA='\033[1;35m'
+WHITE='\033[1;37m'
+L_RED='\033[1;91m'
+L_GREEN='\033[1;92m'
+L_YELLOW='\033[1;93m'
+L_BLUE='\033[1;94m'
+L_CYAN='\033[1;96m'
+L_MAGENTA='\033[1;95m'
+NC='\033[0m' # No Color
+
+# Navigate to the script's directory
+cd "$(dirname "$0")"
+
+# Function to check if curl is installed
+check_curl() {
+    if ! command -v curl &> /dev/null; then
+        echo "curl is not available on this system. Please install curl then re-run the script https://curl.se/"
+        echo "or perform a manual installation of a Conda Python environment."
+        exit 1
+    fi
+}
+
+# Check if the current directory path contains a space
+containsSpace=false
+currentPath=$(pwd)
+if echo "$currentPath" | grep -q ' '; then
+    containsSpace=true
+fi
+
+if [ "$containsSpace" = true ]; then
+    echo
+    echo -e "    ${L_BLUE}ALLTALK LINUX SETUP UTILITY${NC}"
+    echo
+    echo
+    echo -e "    You are trying to install AllTalk in a folder that has a space in the"
+    echo -e "    folder path e.g."
+    echo 
+    echo -e "       /home/${L_RED}program files${NC}/alltalk_tts"
+    echo 
+    echo -e "    This causes errors with Conda and Python scripts. Please follow this"
+    echo -e "    link for reference:"
+    echo 
+    echo -e "      ${L_CYAN}https://docs.anaconda.com/free/working-with-conda/reference/faq/#installing-anaconda${NC}"
+    echo 
+    echo -e "    Please use a folder path that has no spaces in it e.g." 
+    echo 
+    echo -e "       /home/myfiles/alltalk_tts/"
+    echo 
+    echo
+    read -p "Press Enter to continue..." 
+    exit 1
+else
+    # Continue with the main menu
+    echo "Continue with the main menu."
+fi
+
+# Main Menu
+main_menu() {
+    while true; do
+        clear
+        echo
+        echo -e "    ${L_BLUE}ALLTALK LINUX SETUP UTILITY${NC}"
+        echo
+        echo "    INSTALLATION TYPE"
+        echo -e "    1) I am using AllTalk as part of ${L_GREEN}Text-generation-webui${NC}"
+        echo -e "    2) I am using AllTalk as a ${L_GREEN}Standalone Application${NC}"
+        echo
+        echo -e "    9)${L_RED} Exit/Quit${NC}"
+        echo
+        read -p "    Enter your choice: " user_option
+
+        case $user_option in
+            1) webui_menu ;;
+            2) standalone_menu ;;
+            9) exit 0 ;;
+            *) echo "Invalid option"; sleep 2 ;;
+        esac
+    done
+}
+
+# Text-generation-webui Menu
+webui_menu() {
+    while true; do
+        clear
+        echo
+        echo -e "    ${L_BLUE}TEXT-GENERATION-WEBUI SETUP${NC}"
+        echo
+        echo -e "    Please ensure you have started your Text-generation-webui Python"
+        echo -e "    environment. If you have NOT done this, please run ${L_GREEN}/cmd_linux.sh${NC}"
+        echo -e "    in the ${L_GREEN}text-generation-webui${NC} folder and then re-run this script."
+        echo
+        echo "    BASE REQUIREMENTS"
+        echo -e "    1) Apply/Re-Apply the requirements for an ${L_GREEN}Text-generation-webui${NC}"
+        echo
+        echo "    OPTIONAL"
+        echo "    2) Git Pull the latest AllTalk updates from Github"
+        echo
+        echo "    DEEPSPEED"
+        echo "    4) Install DeepSpeed."
+        echo "    5) Uninstall DeepSpeed."
+        echo
+        echo "    OTHER"
+        echo "    6) Generate a diagnostics file."
+        echo
+        echo -e "    9)${L_RED} Exit/Quit${NC}"
+        echo
+        read -p "    Enter your choice: " webui_option
+
+        case $webui_option in
+            1) install_nvidia_textgen ;;
+            2) tg_gitpull ;;
+            4) install_deepspeed ;;
+            5) uninstall_deepspeed ;;
+            6) generate_diagnostics_textgen ;;
+            9) exit 0 ;;
+            *) echo "Invalid option"; sleep 2 ;;
+        esac
+    done
+}
+
+install_nvidia_textgen() {
+    local requirements_file="system/requirements/requirements_textgen.txt"
+    echo "    Installing Requirements from $requirements_file..."
+    if ! pip install -r "$requirements_file"; then
+        echo
+        echo "    There was an error pulling from Github."
+        echo "    Please check the output for details."
+        read -p "    Press any key to return to the menu. " -n 1
+        echo
+        return
+    fi
+    echo
+    echo "    Requirements installed successfully."
+    echo
+    echo -e "    To install ${L_YELLOW}DeepSpeed${NC} on Linux, there are additional"
+    echo -e "    steps required. Please see the Github or documentation on DeepSeed."
+    echo
+    read -p "    Press any key to continue. " -n 1
+    echo
+}
+
+tg_gitpull() {
+    echo
+    if ! git pull; then
+        echo
+        echo "    There was an error installing the requirements."
+        echo "    Please check the output for details."
+        echo
+        read -p "    Press any key to return to the menu. " -n 1
+        echo
+        return
+    fi
+    echo
+    echo "    AllTalk Updated from Github. Please re-apply"
+    echo "    the latest requirements file. (Option 1)"
+    echo
+    read -p "    Press any key to continue. " -n 1
+    echo
+}
+
+# Function to install DeepSpeed
+install_deepspeed() {
+    clear
+    echo
+    echo -e "    ${L_BLUE}DEEPSPEED INSTALLATION REQUIREMENTS${NC}"
+    echo
+    echo -e "    - NVIDIA CUDA Toolkit must be installed from your ${L_GREEN}Linux package manager${NC}"
+    echo -e "      or ${L_GREEN}https://developer.nvidia.com/cuda-toolkit-archive${NC}"
+    echo -e "    - The environment variable ${L_GREEN}CUDA_HOME${NC} must be set in your Python env"
+    echo -e "      e.g. export CUDA_HOME=/usr/local/cuda."
+    echo -e "    - ${L_GREEN}libaio-dev${NC} must be installed."
+    echo
+    echo -e "    See the following link for full instructions:"
+    echo -e "    ${L_GREEN}https://github.com/erew123/alltalk_tts?#-deepspeed-installation-options${NC}"
+    echo
+    echo -e "    ${L_BLUE}Please ${L_RED}confirm${L_BLUE} that you have completed these steps before continuing" 
+    echo -e "    with the DeepSpeed installation, or the install ${L_RED}will fail.${NC}"
+    echo
+    read -p "    Have you completed all the above steps? (y/n): " confirm
+
+    if [ "$confirm" != "y" ]; then
+        echo -e "    ${RED}DeepSpeed installation cannot proceed without completing the prerequisites.${NC}"
+        return
+    fi
+
+    echo -e "\n    ${GREEN}Proceeding with DeepSpeed installation...${NC}"
+    pip install deepspeed
+    if [ $? -ne 0 ]; then
+        echo -e "    ${RED}There was an error installing DeepSpeed.${NC}"
+        return
+    fi
+
+    echo -e "    ${GREEN}DeepSpeed installed successfully.${NC}"
+    read -p "    Press any key to continue. " -n 1
+    echo
+}
+
+uninstall_deepspeed() {
+    echo "Uninstalling DeepSpeed..."
+    pip uninstall -y deepspeed
+    if [ $? -ne 0 ]; then
+        echo
+        echo "    There was an error uninstalling DeepSpeed."
+        echo
+        echo "    Press any key to return to the menu."
+        read -n 1
+        return
+    fi
+    echo
+    echo "    DeepSpeed uninstalled successfully."
+    echo
+    echo "    Press any key to continue."
+    read -n 1
+}
+
+generate_diagnostics_textgen() {
+    # Run diagnostics
+    if ! python diagnostics.py; then
+        echo
+        echo "    There was an error running diagnostics."
+        echo
+        read -p "    Press any key to return to the menu. " -n 1
+        echo
+        return
+    fi
+    echo
+    echo "    Diagnostics log file generated successfully."
+    echo "    Please see diagnostics.log"
+    echo
+    read -p "    Press any key to continue. " -n 1
+    echo
+}
+
+# Standalone Menu
+standalone_menu() {
+    while true; do
+        clear
+        echo
+        echo -e "    ${L_BLUE}ALLTALK STANDALONE APPLICATION SETUP${NC}"
+        echo
+        echo "    BASE REQUIREMENTS"
+        echo "    1) Install AllTalk as a Standalone Application"
+        echo
+        echo "    OPTIONAL"
+        echo "    2) Git Pull the latest AllTalk updates from Github"
+        echo "    3) Re-Apply/Update the requirements file"
+        echo "    4) Delete AllTalk's custom Python environment"
+        echo "    5) Purge the PIP cache"
+        echo
+        echo "    DEEPSPEED"
+        echo "    6) DeepSpeed Instructions/Install"
+        echo
+        echo "    OTHER"        
+        echo "    8) Generate a diagnostics file"
+        echo
+        echo -e "    9)${L_RED} Exit/Quit${NC}"
+        echo
+        read -p "    Enter your choice: " standalone_option
+
+        case $standalone_option in
+            1) install_custom_standalone ;;
+            2) gitpull_standalone ;;
+            3) reapply_standalone ;;
+            4) delete_custom_standalone ;;
+            5) pippurge_standalone ;;
+            6) install_deepspeed ;;
+            8) generate_diagnostics_standalone ;;
+            9) exit 0 ;;
+            *) echo "Invalid option"; sleep 2 ;;
+        esac
+    done
+}
+
+
+install_custom_standalone() {
+    cd "$(dirname "${BASH_SOURCE[0]}")"
+
+    if [[ "$(pwd)" =~ " " ]]; then
+        echo "This script relies on Miniconda which can not be silently installed under a path with spaces."
+        exit
+    fi
+
+    # Deactivate existing conda envs as needed to avoid conflicts
+    { conda deactivate && conda deactivate && conda deactivate; } 2> /dev/null
+
+    OS_ARCH=$(uname -m)
+    case "${OS_ARCH}" in
+        x86_64*)    OS_ARCH="x86_64" ;;
+        arm64* | aarch64*) OS_ARCH="aarch64" ;;
+        *)          echo "Unknown system architecture: $OS_ARCH! This script runs only on x86_64 or arm64" && exit ;;
+    esac
+
+    # Config
+    INSTALL_DIR="$(pwd)/alltalk_environment"
+    CONDA_ROOT_PREFIX="${INSTALL_DIR}/conda"
+    INSTALL_ENV_DIR="${INSTALL_DIR}/env"
+    MINICONDA_DOWNLOAD_URL="https://repo.anaconda.com/miniconda/Miniconda3-py310_23.3.1-0-Linux-${OS_ARCH}.sh"
+
+    if [ ! -x "${CONDA_ROOT_PREFIX}/bin/conda" ]; then
+        echo "Downloading Miniconda from $MINICONDA_DOWNLOAD_URL to ${INSTALL_DIR}/miniconda_installer.sh"
+        mkdir -p "${INSTALL_DIR}"
+        curl -L "${MINICONDA_DOWNLOAD_URL}" -o "${INSTALL_DIR}/miniconda_installer.sh"
+        chmod +x "${INSTALL_DIR}/miniconda_installer.sh"
+        bash "${INSTALL_DIR}/miniconda_installer.sh" -b -p "${CONDA_ROOT_PREFIX}"
+        echo "Miniconda installed."
+    fi
+
+    if [ ! -d "${INSTALL_ENV_DIR}" ]; then
+        "${CONDA_ROOT_PREFIX}/bin/conda" create -y --prefix "${INSTALL_ENV_DIR}" python=3.11
+        echo "Conda environment created at ${INSTALL_ENV_DIR}."
+    fi
+
+    # Activate the environment and install requirements
+    source "${CONDA_ROOT_PREFIX}/etc/profile.d/conda.sh"
+    conda activate "${INSTALL_ENV_DIR}"
+    echo
+    echo "    Downloading and installing PyTorch. This step can take a long time"
+    echo "    depending on your internet connection and hard drive speed. Please"
+    echo "    be patient."
+    pip install torch==2.2.1+cu121 torchaudio==2.2.1+cu121 --upgrade --force-reinstall --extra-index-url https://download.pytorch.org/whl/cu121
+    echo
+    echo "    Installing additional requirements."
+    echo
+    pip install -r system/requirements/requirements_standalone.txt
+    # Create start_environment.sh to run AllTalk
+    cat << EOF > start_environment.sh
+#!/bin/bash
+cd "$(dirname "${BASH_SOURCE[0]}")"
+if [[ "$(pwd)" =~ " " ]]; then echo This script relies on Miniconda which can not be silently installed under a path with spaces. && exit; fi
+# deactivate existing conda envs as needed to avoid conflicts
+{ conda deactivate && conda deactivate && conda deactivate; } 2> /dev/null
+# config
+CONDA_ROOT_PREFIX="$(pwd)/alltalk_environment/conda"
+INSTALL_ENV_DIR="$(pwd)/alltalk_environment/env"
+# environment isolation
+export PYTHONNOUSERSITE=1
+unset PYTHONPATH
+unset PYTHONHOME
+export CUDA_PATH="$INSTALL_ENV_DIR"
+export CUDA_HOME="$CUDA_PATH"
+export LD_LIBRARY_PATH=`python3 -c 'import os; import nvidia.cublas.lib; import nvidia.cudnn.lib; print(os.path.dirname(nvidia.cublas.lib.__file__) + ":" + os.path.dirname(nvidia.cudnn.lib.__file__))'`
+# activate env
+bash --init-file <(echo "source \"$CONDA_ROOT_PREFIX/etc/profile.d/conda.sh\" && conda activate \"$INSTALL_ENV_DIR\"")
+EOF
+    # Create start_alltalk.sh to run AllTalk
+    cat << EOF > start_alltalk.sh
+#!/bin/bash
+export LD_LIBRARY_PATH=`python3 -c 'import os; import nvidia.cublas.lib; import nvidia.cudnn.lib; print(os.path.dirname(nvidia.cublas.lib.__file__) + ":" + os.path.dirname(nvidia.cudnn.lib.__file__))'`
+source "${CONDA_ROOT_PREFIX}/etc/profile.d/conda.sh"
+conda activate "${INSTALL_ENV_DIR}"
+python script.py
+EOF
+    # Create start_finetune.sh to run AllTalk
+    cat << EOF > start_finetune.sh
+#!/bin/bash
+export TRAINER_TELEMETRY=0
+export LD_LIBRARY_PATH=`python3 -c 'import os; import nvidia.cublas.lib; import nvidia.cudnn.lib; print(os.path.dirname(nvidia.cublas.lib.__file__) + ":" + os.path.dirname(nvidia.cudnn.lib.__file__))'`
+source "${CONDA_ROOT_PREFIX}/etc/profile.d/conda.sh"
+conda activate "${INSTALL_ENV_DIR}"
+python finetune.py
+EOF
+    chmod +x start_alltalk.sh
+    chmod +x start_environment.sh
+    chmod +x start_finetune.sh
+    echo
+    echo
+    echo -e "    Run ${L_YELLOW}./start_alltalk.sh${NC} to start AllTalk."
+    echo -e "    Run ${L_YELLOW}./start_finetune.sh${NC} to start Finetuning."
+    echo -e "    Run ${L_YELLOW}./start_environment.sh${NC} to start the AllTalk Python environment."
+    echo
+    echo -e "    To install ${L_YELLOW}DeepSpeed${NC} on Linux, there are additional"
+    echo -e "    steps required. Please see the Github or documentation on DeepSeed."
+    echo
+    read -p "    Press any key to continue. " -n 1
+}
+
+delete_custom_standalone() {
+    local env_dir="$PWD/alltalk_environment"
+    # Check if the alltalk_environment directory exists
+    if [ ! -d "$env_dir" ]; then
+        echo "    \"$env_dir\" directory does not exist. No need to delete."
+        read -p "    Press any key to continue. " -n 1
+        echo
+        return
+    fi
+    # Check if a Conda environment is active and deactivate it
+    if [ -n "$CONDA_PREFIX" ]; then
+        echo "    Exiting the Conda environment. You may need to start ./atstart.sh again"
+        conda deactivate
+    fi
+    echo "Deleting \"$env_dir\". Please wait."
+    rm -rf "$env_dir"
+    if [ -d "$env_dir" ]; then
+        echo "    Failed to delete \"$env_dir\" folder."
+        echo "    Please make sure it is not in use and try again."
+    else
+        echo "    Environment \"$env_dir\" deleted successfully."
+    fi
+    read -p "    Press any key to continue. " -n 1
+    echo
+}
+
+generate_diagnostics_standalone() {
+    local env_dir="$PWD/alltalk_environment"
+    local conda_root_prefix="${env_dir}/conda"
+    local install_env_dir="${env_dir}/env"
+    if [ ! -d "${install_env_dir}" ]; then
+        echo
+        echo "    The Conda environment at '${install_env_dir}' does not exist."
+        echo "    Please install the environment before proceeding."
+        echo
+        read -p "    Press any key to return to the menu. " -n 1
+        echo
+        return
+    fi
+    source "${conda_root_prefix}/etc/profile.d/conda.sh"
+    conda activate "${install_env_dir}"
+    if ! python diagnostics.py; then
+        echo
+        echo "    There was an error running diagnostics."
+        echo
+        read -p "    Press any key to return to the menu. " -n 1
+        echo
+        return
+    fi
+    echo
+    echo "    Diagnostics completed successfully."
+    read -p "    Press any key to continue. " -n 1
+    echo
+}
+
+gitpull_standalone() {
+    local env_dir="$PWD/alltalk_environment"
+    local conda_root_prefix="${env_dir}/conda"
+    local install_env_dir="${env_dir}/env"
+    if [ ! -d "${install_env_dir}" ]; then
+        echo
+        echo "    The Conda environment at '${install_env_dir}' does not exist."
+        echo "    Please install the environment before proceeding."
+        echo
+        read -p "    Press any key to return to the menu. " -n 1
+        echo
+        return
+    fi
+    source "${conda_root_prefix}/etc/profile.d/conda.sh"
+    conda activate "${install_env_dir}"
+    if ! git pull; then
+        echo
+        echo "    There was an error pulling from Github."
+        echo
+        read -p "    Press any key to return to the menu. " -n 1
+        echo
+        return
+    fi
+    echo
+    echo "    AllTalk Updated from Github. Please re-apply."
+    echo "    the latest requirements file. (Option 3)"
+    echo
+    read -p "    Press any key to continue. " -n 1
+    echo
+}
+
+pippurge_standalone() {
+    if ! pip cache purge; then
+        echo
+        echo "    There was an error."
+        echo
+        read -p "    Press any key to return to the menu. " -n 1
+        echo
+        return
+    fi
+    echo
+    echo "    The PIP cache has been purged."
+    echo
+    read -p "    Press any key to continue. " -n 1
+    echo
+}
+
+reapply_standalone() {
+    local env_dir="$PWD/alltalk_environment"
+    local conda_root_prefix="${env_dir}/conda"
+    local install_env_dir="${env_dir}/env"
+    if [ ! -d "${install_env_dir}" ]; then
+        echo
+        echo "    The Conda environment at '${install_env_dir}' does not exist."
+        echo "    Please install the environment before proceeding."
+        echo
+        read -p "    Press any key to return to the menu. " -n 1
+        echo
+        return
+    fi
+    source "${conda_root_prefix}/etc/profile.d/conda.sh"
+    conda activate "${install_env_dir}"
+    echo
+    echo "    Downloading and installing PyTorch. This step can take a long time"
+    echo "    depending on your internet connection and hard drive speed. Please"
+    echo "    be patient."
+    pip install torch>=2.2.1+cu121 torchaudio>=2.2.1+cu121 --upgrade --force-reinstall --extra-index-url https://download.pytorch.org/whl/cu121
+    echo
+    echo "    Installing additional requirements."
+    echo
+    pip install -r system/requirements/requirements_standalone.txt
+    echo
+    echo "    Requirements have been re-applied/updated."
+    echo
+    read -p "    Press any key to continue. " -n 1
+    echo
+}
+
+
+# Start the main menu
+main_menu

alltalk_tts/confignew.json

@@ -0,0 +1,25 @@
+{
+    "activate": true,
+    "autoplay": true,
+    "branding": "AllTalk ",
+    "narrator_enabled": false,
+    "deepspeed_activate": false,
+    "delete_output_wavs": "Disabled",
+    "ip_address": "127.0.0.1",
+    "language": "English",
+    "low_vram": false,
+    "local_temperature": "0.7",
+    "local_repetition_penalty": "10.0",
+    "tts_model_loaded": true,
+    "tts_model_name": "tts_models/multilingual/multi-dataset/xtts_v2",
+    "narrator_voice": "female_01.wav",
+    "output_folder_wav": "extensions/alltalk_tts/outputs/",
+    "output_folder_wav_standalone": "outputs/",
+    "port_number": "7851",
+    "remove_trailing_dots": false,
+    "show_text": true,
+    "tts_method_api_local": false,
+    "tts_method_api_tts": false,
+    "tts_method_xtts_local": true,
+    "voice": "female_01.wav"
+}

alltalk_tts/diagnostics.py

@@ -0,0 +1,325 @@
+try:
+    import platform
+    import subprocess
+    import logging
+    from importlib_metadata import distributions
+    import torch
+    import os  # Import the os module
+    import re
+    import sys
+    import glob
+    import site
+    import textwrap
+    import torch
+    import packaging.version
+    import packaging.specifiers
+    from packaging.specifiers import SpecifierSet
+    from packaging.specifiers import SpecifierSet
+    from packaging.version import parse as parse_version
+    from pathlib import Path
+except ImportError as e:
+    print(f"\033[91mError importing module: {e}\033[0m\n")
+    print("\033[94mPlease ensure you started the Text-generation-webUI Python environment with either\033[0m")
+    print("\033[92mcmd_linux.sh\033[0m, \033[92mcmd_windows.bat\033[0m, \033[92mcmd_macos.sh\033[0m, or \033[92mcmd_wsl.bat\033[0m")
+    print("\033[94mfrom the text-generation-webui directory, and then try running the diagnostics again.\033[0m")
+    exit(1)
+
+this_dir = Path(__file__).parent
+
+try:
+    import psutil
+except ImportError:
+    print("psutil not found. Installing...")
+    subprocess.run(['pip', 'install', 'psutil'])
+    import psutil
+
+def get_requirements_file():
+    this_dir = Path(__file__).parent  # Assuming 'this_dir' is defined as the script's directory
+    requirements_dir = this_dir / 'system' / 'requirements'
+    requirements_files = list(requirements_dir.glob('requirements*.txt'))  # Using pathlib for globbing
+    
+    if not requirements_files:
+        print("\033[91mNo requirements files found.\033[0m")
+        return None
+
+    print("\033[94m\nSelect a requirements file to check against (or press Enter for default 'requirements.txt'):\033[0m\n")
+    for i, file_path in enumerate(requirements_files, start=1):
+        print(f"    {i}. {file_path.name}")  # Only print the filename
+
+    choice = input("\nEnter the number of your choice: ")
+    try:
+        choice = int(choice) - 1
+        return str(requirements_files[choice])  # Return the full path as a string
+    except (ValueError, IndexError):
+        return str(requirements_dir / "requirements.txt")  # Return the default path as a string
+
+# Set up logging with filemode='w'
+logging.basicConfig(filename='diagnostics.log',
+                    filemode='w',
+                    level=logging.INFO,
+                    format='%(message)s')  # Custom format
+
+# Function to get GPU information using subprocess
+def get_gpu_info():
+    try:
+        result = subprocess.run(['nvidia-smi'], stdout=subprocess.PIPE, text=True)
+        return result.stdout
+    except FileNotFoundError:
+        return "NVIDIA GPU information not available"
+    
+def get_cpu_info():
+    cpu_info = {
+        'physical_cores': psutil.cpu_count(logical=False),
+        'total_cores': psutil.cpu_count(logical=True),
+        'max_frequency': psutil.cpu_freq().max
+    }
+    return cpu_info
+
+def get_disk_info():
+    disk_info = []
+    partitions = psutil.disk_partitions()
+    for p in partitions:
+        usage = psutil.disk_usage(p.mountpoint)
+        disk_info.append(f" Drive: {p.device} | Total: {usage.total / (1024 ** 3):.2f} GB | Used: {usage.used / (1024 ** 3):.2f} GB | Free: {usage.free / (1024 ** 3):.2f} GB | Type: {p.fstype}")
+    return disk_info
+
+# Function to check if a port is in use
+def is_port_in_use(port):
+    for conn in psutil.net_connections():
+        if conn.laddr.port == port:
+            return True
+    return False
+
+def satisfies_wildcard(installed_version, required_version):
+    if '*' in required_version:
+        required_parts = required_version.split('.')
+        installed_parts = installed_version.split('.')
+        for req, inst in zip(required_parts, installed_parts):
+            if req != '*' and req != inst:
+                return False
+        return True
+    return False
+
+def test_cuda():
+    cuda_available = torch.cuda.is_available()
+    if cuda_available:
+        try:
+            # Attempt to create a tensor on GPU
+            torch.tensor([1.0, 2.0]).cuda()
+            return "Success - CUDA is available and working."
+        except Exception as e:
+            return f"Fail - CUDA is available but not working. Error: {e}"
+    else:
+        return "Fail - CUDA is not available."
+
+def find_files_in_path_with_wildcard(pattern):
+    # Get the site-packages directory of the current Python environment
+    site_packages_path = site.getsitepackages()
+    found_paths = []
+    # Adjust the sub-directory based on the operating system
+    sub_directory = "nvidia/cublas"
+    if platform.system() == "Linux":
+        sub_directory = os.path.join(sub_directory, "lib")
+    else:
+        sub_directory = os.path.join(sub_directory, "bin")
+    # Iterate over each site-packages directory (there can be more than one)
+    for directory in site_packages_path:
+        # Construct the search directory path
+        search_directory = os.path.join(directory, sub_directory)
+        # Use glob to find all files matching the pattern in this directory
+        for file_path in glob.glob(os.path.join(search_directory, pattern)):
+            if os.path.isfile(file_path):  # Ensure it's a file
+                found_paths.append(file_path)
+    return found_paths
+
+# Function to log and print system information
+def log_system_info():
+    # System information
+    os_version = platform.system() + " " + platform.version()
+    
+    # Get CUDA_HOME environment variable
+    cuda_home = os.environ.get('CUDA_HOME', 'N/A')
+
+    gpu_info = get_gpu_info()
+
+    # Python environment information
+    python_version = platform.python_version()
+
+    # Torch version
+    torch_version = torch.__version__
+    cuda_test_result = test_cuda()
+    cpu_info = get_cpu_info()
+    disk_info = get_disk_info()
+
+    # System RAM using psutil
+    try:
+        virtual_memory = psutil.virtual_memory()
+        total_ram = f"{virtual_memory.total / (1024 ** 3):.2f} GB"
+        available_ram = f"{virtual_memory.available / (1024 ** 3):.2f} GB"
+        system_ram = f"{available_ram} available out of {total_ram} total"
+    except NameError:
+        print("psutil is not installed. Unable to check system RAM.")
+        system_ram = "N/A"
+
+    # Port check (if psutil is available)
+    port_status = "N/A"
+    if 'psutil' in globals():
+        port_to_check = 7851
+        if is_port_in_use(port_to_check):
+            port_status = f"Port {port_to_check} is in use."
+        else:
+            port_status = f"Port {port_to_check} is available."
+
+    # Package versions using importlib_metadata
+    package_versions = {d.metadata['Name']: d.version for d in distributions()}
+
+    # Python environment information
+    python_executable = sys.executable
+    python_version_info = sys.version_info
+    python_virtual_env = os.environ.get('VIRTUAL_ENV', 'N/A')
+
+    # Conda environment information
+    conda_env = os.environ.get('CONDA_DEFAULT_ENV', 'N/A')
+
+    # Get Path environment information
+    search_path = sys.path
+    path_env = os.environ.get('PATH', 'N/A')
+
+    # Check for cublas
+    file_name = 'cublas64_11.*' if platform.system() == "Windows" else 'libcublas.so.11*'
+    found_paths = find_files_in_path_with_wildcard(file_name)
+
+    # Compare with requirements file
+    requirements_file = get_requirements_file()
+    if requirements_file:
+        required_packages = {}
+        installed_packages = {}
+
+        try:
+            with open(requirements_file, 'r') as req_file:
+                requirements = [line.strip() for line in req_file]
+                for req in requirements:
+                    # Use regular expression to parse package name and version
+                    match = re.match(r'([^\s>=]+)\s*([>=<]+)\s*([^,]+)', req)
+                    if match:
+                        package_name, operator, version_spec = match.groups()
+                        installed_version = package_versions.get(package_name, 'Not installed')
+                        if installed_version != 'Not installed':
+                            required_packages[package_name] = (operator, version_spec)
+                            installed_packages[package_name] = installed_version
+        except FileNotFoundError:
+            print(f"\n{requirements_file} not found. Skipping version checks.")
+            logging.info(f"NOTE {requirements_file} not found. Skipping version checks.")
+
+    # Log and print information
+    logging.info(f"OPERATING SYSTEM:")
+    logging.info(f" OS Version: {os_version}")
+    logging.info(f" Note: Windows 11 will list as build is 10.x.22xxx")
+    logging.info(f"\nHARDWARE ENVIRONMENT:")
+    logging.info(f" CPU: Physical Cores: {cpu_info['physical_cores']}, Total Cores: {cpu_info['total_cores']}, Max Frequency: {cpu_info['max_frequency']} MHz")
+    logging.info(f" System RAM: {system_ram}")
+    logging.info(f"\nGPU INFORMATION:{gpu_info}")
+    logging.info("DISK INFORMATION:")
+    for disk in disk_info:
+        logging.info(disk)
+    logging.info("\nNETWORK PORT:")
+    logging.info(f" Port Status: {port_status}")
+    logging.info("\nCUDA:")
+    logging.info(f" CUDA Working: {cuda_test_result}")
+    logging.info(f" CUDA_HOME: {cuda_home}")
+    if found_paths:
+        logging.info(f" Cublas64_11 Path: {', '.join(found_paths)}")
+    else:
+        logging.info(f" Cublas64_11 Path: Not found in any search path directories.")
+    logging.info("\nPYTHON & PYTORCH:")
+    logging.info(f" Torch Version: {torch_version}")
+    logging.info(f" Python Version: {platform.python_version()}")
+    logging.info(f" Python Version Info: {python_version_info}")
+    logging.info(f" Python Executable: {python_executable}")
+    logging.info(f" Python Virtual Environment: {python_virtual_env} (Should be N/A when in Text-generation-webui Conda Python environment)")
+    logging.info(f" Conda Environment: {conda_env}")
+    logging.info("\nPython Search Path:")
+    for path in search_path:
+        logging.info(f"  {path}")
+    logging.info("\nOS SEARCHPATH ENVIRONMENT:")
+    for path in path_env.split(';'):
+        logging.info(f"  {path}")
+    if required_packages:  # Check if the dictionary is not empty
+        logging.info("\nPACKAGE VERSIONS vs REQUIREMENTS FILE:")
+        max_package_length = max(len(package) for package in required_packages.keys())
+        for package_name, (operator, required_version) in required_packages.items():
+            installed_version = installed_packages.get(package_name, 'Not installed')
+            logging.info(f" {package_name.ljust(max_package_length)}  Required: {operator} {required_version.ljust(12)}  Installed: {installed_version}")
+    logging.info("\nPYTHON PACKAGES:")
+    for package, version in package_versions.items():
+        logging.info(f" {package}>= {version}")
+
+    # Print to screen
+    print(f"\n\033[94mOS Version:\033[0m \033[92m{os_version}\033[0m")
+    print(f"\033[94mOS Ver note:\033[0m \033[92m(Windows 11 will say build is 10.x.22xxx)\033[0m")
+    print(f"\033[94mSystem RAM:\033[0m \033[92m{system_ram}\033[0m")
+    for disk in disk_info:
+        print(f"\033[94mDisk:\033[0m \033[92m{disk}\033[0m")
+    print(f"\033[94m\nGPU Information:\033[0m {gpu_info}")
+    print(f"\033[94mPort Status:\033[0m \033[92m{port_status}\033[0m\n")
+    if "Fail" in cuda_test_result:
+        print(f"\033[91mCUDA Working:\033[0m \033[91m{cuda_test_result}\033[0m")
+    else:
+        print(f"\033[94mCUDA Working:\033[0m \033[92m{cuda_test_result}\033[0m")
+    print(f"\033[94mCUDA_HOME:\033[0m \033[92m{cuda_home}\033[0m")
+    if found_paths:
+        print(f"\033[94mCublas64_11 Path:\033[0m \033[92m{', '.join(found_paths)}\033[0m")
+    else:
+        print(f"\033[94mCublas64_11 Path:\033[0m \033[91mNot found in any search path directories.\033[0m")    
+    print(f"\033[94m\nTorch Version:\033[0m \033[92m{torch_version}\033[0m")
+    print(f"\033[94mPython Version:\033[0m \033[92m{platform.python_version()}\033[0m")
+    print(f"\033[94mPython Executable:\033[0m \033[92m{python_executable}\033[0m")
+    print(f"\033[94mConda Environment:\033[0m \033[92m{conda_env}\033[0m")
+    print(f"\n\033[94mPython Search Path:\033[0m")
+    for path in search_path:
+        print(f"  {path}")
+    if required_packages:  # Check if the dictionary is not empty
+        print("\033[94m\nRequirements file package comparison:\033[0m")
+        max_package_length = max(len(package) for package in required_packages.keys())
+
+        for package_name, (operator, required_version) in required_packages.items():
+            installed_version = installed_packages.get(package_name, 'Not installed')
+
+            # Exclude build information (e.g., +cu118) before creating the SpecifierSet
+            required_version_no_build = required_version.split("+")[0]
+
+            if '*' in required_version:
+                condition_met = satisfies_wildcard(installed_version, required_version)
+            else:
+                # Compare versions using packaging.version
+                required_specifier = SpecifierSet(f"{operator}{required_version_no_build}")
+                installed_version = parse_version(installed_version)
+                condition_met = installed_version in required_specifier
+
+            color_required = "\033[92m" if condition_met else "\033[91m"
+            color_installed = "\033[92m" if condition_met else "\033[91m"
+
+            # Print colored output
+            print(f"  {package_name.ljust(max_package_length)}  Required: {color_required}{operator} {required_version.ljust(12)}\033[0m  Installed: {color_installed}{installed_version}\033[0m")
+
+        print("\nOn Nvidia Graphics cards machines, if your \033[92mInstalled\033[0m version of \033[92mTorch\033[0m and \033[92mTorchaudio\033[0m does")    
+        print("not have \033[92m+cu118\033[0m (Cuda 11.8) or \033[92m+cu121\033[0m (Cuda 12.1) listed after them, you do not have CUDA")
+        print("installed for Torch or Torchaudio in this Python environment. This will cause you problems")
+        print("with \033[94mAllTalk\033[0m and \033[94mFinetuning.\033[0m You may have to 'pip install' a new version of torch and")
+        print("torchaudio, using '\033[94m--upgrade --force-reinstall\033[0m' with the correct version of PyTorch for\033[0m")
+        print("your Python environment.\033[0m")
+        print("\033[94m\nRequirements file specifier meanings:\033[0m")
+        explanation = textwrap.dedent("""
+        == Exact version              != Any version except          < Less than               
+        <= Less than or equal to      >  Greater than                >= Greater than or equal to
+        ~ Compatible release          ;  Environment marker          AND Logical AND           
+        OR Logical OR
+        """)
+        print(explanation.strip())
+    print("")
+    print(f"\033[94mDiagnostic log created:\033[0m \033[92mdiagnostics.log. \033[94mA brief summary of results is displayed above on\033[0m")
+    print(f"\033[94mscreen. Please see the log file for more detail.\033[0m")
+    print(f"\033[94m\nPlease upload the log file with any support ticket.\033[0m")
+
+if __name__ == "__main__":
+    log_system_info()

alltalk_tts/docker-compose-cuda.yml

@@ -0,0 +1,20 @@
+version: '3.8'
+services:
+  alltalk-tts:
+    image: erew123/alltalk_tts:cuda
+    restart: unless-stopped
+    ports:
+      - "7851:7851"
+    volumes:
+      - ./outputs:/app/outputs/
+      - ./models:/app/models/
+      - ./voices:/app/voices/
+      - ./finetune/put-voice-samples-in-here:/app/finetune/put-voice-samples-in-here
+      - ./dockerconfig.json:/app/confignew.json
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [ gpu ]

alltalk_tts/docker-compose.yml

@@ -0,0 +1,27 @@
+version: '3.8'
+services:
+  alltalk-tts:
+    image: ${IMAGE:-alltalk:v1-9c}
+    restart: unless-stopped
+    ports:
+      - "7851:7851"
+      - "7852:7852"
+    volumes:
+      - ./outputs:/app/outputs/
+      - ./models:/app/models/
+      - ./voices:/app/voices/
+      - ./finetune/put-voice-samples-in-here:/app/finetune/put-voice-samples-in-here
+      - ./dockerconfig.json:/app/confignew.json
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://localhost:7851/api/ready"]
+      interval: 1m30s
+      timeout: 30s
+      retries: 5
+      start_period: 30s
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [ gpu ]

alltalk_tts/dockerconfig.json

@@ -0,0 +1,25 @@
+{
+    "activate": true,
+    "autoplay": true,
+    "branding": "AllTalk ",
+    "narrator_enabled": false,
+    "deepspeed_activate": true,
+    "delete_output_wavs": "Disabled",
+    "ip_address": "127.0.0.1",
+    "language": "English",
+    "low_vram": false,
+    "local_temperature": "0.7",
+    "local_repetition_penalty": "10.0",
+    "tts_model_loaded": true,
+    "tts_model_name": "tts_models/multilingual/multi-dataset/xtts_v2",
+    "narrator_voice": "female_01.wav",
+    "output_folder_wav": "extensions/alltalk_tts/outputs/",
+    "output_folder_wav_standalone": "outputs/",
+    "port_number": "7851",
+    "remove_trailing_dots": false,
+    "show_text": true,
+    "tts_method_api_local": false,
+    "tts_method_api_tts": false,
+    "tts_method_xtts_local": true,
+    "voice": "female_01.wav"
+}

alltalk_tts/launch.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+python modeldownload.py
+uvicorn tts_server:app --host 0.0.0.0 --port 7851 --workers 1 --proxy-headers &
+sleep 5
+python script.py

alltalk_tts/modeldownload.json

@@ -0,0 +1,14 @@
+{
+    "base_path": "models",
+    "model_path": "xttsv2_2.0.2",
+    "files_to_download": {
+        "LICENSE.txt": "https://huggingface.co/coqui/XTTS-v2/resolve/v2.0.2/LICENSE.txt?download=true",
+        "README.md": "https://huggingface.co/coqui/XTTS-v2/resolve/v2.0.2/README.md?download=true",
+        "config.json": "https://huggingface.co/coqui/XTTS-v2/resolve/v2.0.2/config.json?download=true",
+        "model.pth": "https://huggingface.co/coqui/XTTS-v2/resolve/v2.0.2/model.pth?download=true",
+        "dvae.pth": "https://huggingface.co/coqui/XTTS-v2/resolve/v2.0.2/dvae.pth?download=true",
+        "mel_stats.pth": "https://huggingface.co/coqui/XTTS-v2/resolve/v2.0.2/mel_stats.pth?download=true",
+        "speakers_xtts.pth": "https://huggingface.co/coqui/XTTS-v2/resolve/v2.0.2/speakers_xtts.pth?download=true",
+        "vocab.json": "https://huggingface.co/coqui/XTTS-v2/resolve/v2.0.2/vocab.json?download=true"
+    }
+}

alltalk_tts/modeldownload.py

@@ -0,0 +1,193 @@
+import os
+import sys
+from pathlib import Path
+import requests
+from requests.exceptions import ConnectionError
+from tqdm import tqdm
+import importlib.metadata as metadata
+import json
+from packaging import version
+from datetime import datetime
+
+#################################################################
+#### LOAD PARAMS FROM confignew.json - REQUIRED FOR BRANDING ####
+#################################################################
+# STARTUP VARIABLE - Create "this_dir" variable as the current script directory
+this_dir = Path(__file__).parent.resolve()
+
+# load standard config file in and get settings
+def load_config(file_path):
+    with open(file_path, "r") as config_file:
+        config = json.load(config_file)
+    return config
+
+config_file_path = this_dir / "confignew.json"
+params = load_config(config_file_path)
+
+# Define the path to the modeldownload config file file
+modeldownload_config_file_path = this_dir / "modeldownload.json"
+
+# Check if the JSON file exists
+if modeldownload_config_file_path.exists():
+    with open(modeldownload_config_file_path, "r") as config_file:
+        settings = json.load(config_file)
+
+    # Extract settings from the loaded JSON
+    base_path = Path(settings.get("base_path", ""))
+    model_path = Path(settings.get("model_path", ""))
+    files_to_download = settings.get("files_to_download", {})
+else:
+    # Default settings if the JSON file doesn't exist or is empty
+    print(f"[{params['branding']}Startup] \033[91mWarning\033[0m modeldownload.json is missing so please re-download it and save it in the coquii_tts main folder.")
+    print(f"[{params['branding']}Startup] \033[91mWarning\033[0m API Local and XTTSv2 Local will error unless this is corrected.")
+
+# Read the version specifier from requirements_nvidia.txt
+with open(this_dir / "system" / "requirements" / "requirements_standalone.txt", "r") as req_file:
+    requirements = req_file.readlines()
+
+tts_version_required = None
+for req in requirements:
+    if req.startswith("TTS=="):
+        tts_version_required = req.strip().split("==")[1]
+        break
+
+if tts_version_required is None:
+    raise ValueError(f"[{params['branding']}Startup] \033[91mWarning\033[0m Could not find TTS version specifier in requirements file")
+
+def create_directory_if_not_exists(directory):
+    if not directory.exists():
+        directory.mkdir(parents=True)
+
+def download_file(url, destination):
+    response = requests.get(url, stream=True)
+    total_size_in_bytes = int(response.headers.get("content-length", 0))
+    block_size = 1024  # 1 Kibibyte
+
+    progress_bar = tqdm(total=total_size_in_bytes, unit="iB", unit_scale=True)
+
+    with open(destination, "wb") as file:
+        for data in response.iter_content(block_size):
+            progress_bar.update(len(data))
+            file.write(data)
+
+    progress_bar.close()
+
+
+def check_tts_version():
+    try:
+        tts_version = metadata.version("tts")
+        print(f"[{params['branding']}Startup] \033[92mCurrent TTS Version    : \033[93m"+tts_version+"\033[0m")
+
+        if version.parse(tts_version) < version.parse(tts_version_required):
+            print(f"[{params['branding']}Startup] \033[91mWarning\033[0m TTS version is too old. Please upgrade to version \033[93m"+tts_version_required+"\033[0m or later.\033[0m")
+            print(f"[{params['branding']}Startup] \033[91mWarning\033[0m At your terminal/command prompt \033[94mpip install --upgrade tts\033[0m")
+        else:
+            print(f"[{params['branding']}Startup] \033[92mCurrent TTS Version is :\033[93m Up to date\033[0m")
+    except metadata.PackageNotFoundError:
+        print(f"[{params['branding']}Startup] \033[91mWarning\033[0m TTS is not installed")
+
+def check_torch_version():
+    import torch
+    pytorch_version = torch.__version__
+    cuda_version = torch.version.cuda
+    major, minor, micro = sys.version_info[:3]
+    python_version = f"{major}.{minor}.{micro}"
+    print(f"[{params['branding']}Startup] \033[92mCurrent Python Version :\033[93m {python_version}\033[0m")
+    print(f"[{params['branding']}Startup] \033[92mCurrent PyTorch Version:\033[93m {pytorch_version}\033[0m")
+    if cuda_version is None:
+        print(f"[{params['branding']}Startup] \033[92mCurrent CUDA Version   :\033[91m CUDA is not available\033[0m")
+    else:
+        print(f"[{params['branding']}Startup] \033[92mCurrent CUDA Version   :\033[93m {cuda_version}\033[0m")
+
+def ordinal(n):
+    return "%d%s" % (n, "th" if 4 <= n % 100 <= 20 else {1: "st", 2: "nd", 3: "rd"}.get(n % 10, "th"))
+
+def format_datetime(iso_str):
+    # Parse the ISO 8601 string to datetime
+    dt = datetime.strptime(iso_str, "%Y-%m-%dT%H:%M:%SZ")
+    # Format the datetime into a more readable string
+    return dt.strftime(f"{ordinal(dt.day)} %B %Y at %H:%M")
+
+def fetch_latest_commit_sha_and_date(owner, repo):
+    url = f"https://api.github.com/repos/{owner}/{repo}/commits"
+    try:
+        response = requests.get(url)
+        if response.status_code == 200:
+            latest_commit = response.json()[0]
+            latest_commit_sha = latest_commit['sha']
+            latest_commit_date = latest_commit['commit']['committer']['date']
+            return latest_commit_sha, latest_commit_date
+        else:
+            print(f"[{params['branding']}Startup] \033[92m{params['branding']}Github updated :\033[91m Failed to fetch the latest commits due to an unexpected response from GitHub")
+            return None, None
+    except ConnectionError:
+        # This block is executed when a connection error occurs
+        print(f"[{params['branding']}Startup] \033[92m{params['branding']}Github updated :\033[91m Could not reach GitHub to check for updates\033[0m")
+        return None, None
+
+def read_or_initialize_sha(file_path):
+    if os.path.exists(file_path):
+        with open(file_path, 'r') as file:
+            data = json.load(file)
+            return data.get("last_known_commit_sha")
+    else:
+        # File doesn't exist, fetch the latest SHA and create the file
+        latest_commit_sha = fetch_latest_commit_sha_and_date(github_site, github_repository)
+        if latest_commit_sha:
+            with open(file_path, 'w') as file:
+                json.dump({"last_known_commit_sha": latest_commit_sha}, file)
+            return latest_commit_sha
+        else:
+            # Handle the case where GitHub couldn't be reached
+            return None
+
+def update_sha_file(file_path, new_sha):
+    with open(file_path, 'w') as file:
+        json.dump({"last_known_commit_sha": new_sha}, file)
+
+# Check and create directories
+if str(base_path) == "models":
+    create_directory_if_not_exists(this_dir / base_path / model_path)
+else:
+    create_directory_if_not_exists(base_path / model_path)
+    print(f"[{params['branding']}Startup] \033[94mInfo\033[0m Custom path set in \033[93mmodeldownload.json\033[0m. Using the following settings:")
+    print(f"[{params['branding']}Startup] \033[94mInfo\033[0m Base folder Path:\033[93m",base_path,"\033[0m",)
+    print(f"[{params['branding']}Startup] \033[94mInfo\033[0m Model folder Path:\033[93m",model_path,"\033[0m",)
+    print(f"[{params['branding']}Startup] \033[94mInfo\033[0m Full Path:\033[93m",base_path / model_path,"\033[0m",)
+
+# Download files if they don't exist
+print(f"[{params['branding']}Startup] \033[92mModel is available     :\033[93m Checking\033[0m")
+for filename, url in files_to_download.items():
+    if str(base_path) == "models":
+        destination = this_dir / base_path / model_path / filename
+    else:
+        destination = Path(base_path) / model_path / filename
+    if not destination.exists():
+        print(f"[{params['branding']}Startup] \033[92mModel Downloading file : \033[93m" + filename + "\033[0m")
+        download_file(url, destination)
+print(f"[{params['branding']}Startup] \033[92mModel is available     :\033[93m Checked\033[0m")
+
+github_site = "erew123"
+github_repository = "alltalk_tts"
+
+check_torch_version()
+check_tts_version()
+# Define the file path based on your directory structure
+sha_file_path = this_dir / "system" / "config" / "at_github_sha.json"
+
+# Read or initialize the SHA (adjusted for handling both SHA and date)
+last_known_commit_sha = read_or_initialize_sha(sha_file_path)  # Assuming adjustment for date
+
+# Assuming you have fetched the latest commit SHA and date
+latest_commit_sha, latest_commit_date = fetch_latest_commit_sha_and_date(github_site, github_repository)
+
+formatted_date = format_datetime(latest_commit_date) if latest_commit_date else "an unknown date"
+
+if latest_commit_sha and latest_commit_sha != last_known_commit_sha:
+    #print(f"There's an update available for alltalk_tts.")
+    print(f"[{params['branding']}Startup] \033[92m{params['branding']}Github updated :\033[93m {formatted_date}\033[0m")
+    # Update the file with the new SHA
+    update_sha_file(sha_file_path, latest_commit_sha)
+elif latest_commit_sha == last_known_commit_sha:
+    #print(f"Your alltalk_tts software is up to date.")
+    print(f"[{params['branding']}Startup] \033[92m{params['branding']}Github updated :\033[93m {formatted_date}\033[0m")

alltalk_tts/nvidia.Dockerfile

@@ -0,0 +1,22 @@
+FROM nvidia/cuda:12.1.1-devel-ubuntu22.04
+ENV HOST 0.0.0.0
+RUN apt-get update && apt-get upgrade -y \
+    && apt-get install -y git build-essential portaudio19-dev \
+    python3 python3-pip gcc wget \
+    ocl-icd-opencl-dev opencl-headers clinfo \
+    libclblast-dev libopenblas-dev \
+    && mkdir -p /etc/OpenCL/vendors && echo "libnvidia-opencl.so.1" > /etc/OpenCL/vendors/nvidia.icd \
+    && ln -s /usr/bin/python3 /usr/bin/python
+
+RUN mkdir /app/pip_cache
+ENV PIP_CACHE_DIR=/app/pip_cache
+
+WORKDIR /app
+COPY . .
+ENV CUDA_DOCKER_ARCH=all
+RUN pip install --no-cache-dir --no-deps -r system/requirements/requirements_standalone.txt --cache-dir=/app/pip_cache && \
+    pip install --no-cache-dir deepspeed --cache-dir=/app/pip_cache
+
+EXPOSE 7851
+RUN chmod +x launch.sh
+ENTRYPOINT ["sh", "-c", "./launch.sh"]

alltalk_tts/script.py

@@ -0,0 +1,1086 @@
+import html
+import json
+import random
+import subprocess
+import time
+import os
+import requests
+import threading
+import signal
+import sys
+import atexit
+import shutil
+from pathlib import Path
+from datetime import datetime, timedelta
+import re
+import numpy as np
+import soundfile as sf
+import uuid
+import logging
+# Store the current disable level
+current_disable_level = logging.getLogger().manager.disable
+
+######################################
+#### ALLTALK ALLOWED STARTUP TIME ####
+######################################
+startup_wait_time = 120
+
+# You can change the above setting to a larger number to allow AllTAlk more time to start up. The default setting is 120 seconds (2 minutes).
+# On some older systems you may need to allow AllTalk more time. So you could set it to 240 (4 minutes) which will give AllTalk more to load.
+
+#################################################################
+#### LOAD PARAMS FROM confignew.json - REQUIRED FOR BRANDING ####
+#################################################################
+# STARTUP VARIABLE - Create "this_dir" variable as the current script directory
+this_dir = Path(__file__).parent.resolve()
+
+# load config file in and get settings
+def load_config(file_path):
+    with open(file_path, "r") as config_file:
+        config = json.load(config_file)
+    return config
+                               
+config_file_path = this_dir / "confignew.json"
+# Load the params dictionary from the confignew.json file
+params = load_config(config_file_path)
+
+print(f"[{params['branding']}Startup]\033[94m     _    _ _ \033[1;35m_____     _ _     \033[0m  _____ _____ ____  ")
+print(f"[{params['branding']}Startup]\033[94m    / \  | | |\033[1;35m_   _|_ _| | | __ \033[0m |_   _|_   _/ ___| ")
+print(f"[{params['branding']}Startup]\033[94m   / _ \ | | |\033[1;35m | |/ _` | | |/ / \033[0m   | |   | | \___ \ ")
+print(f"[{params['branding']}Startup]\033[94m  / ___ \| | |\033[1;35m | | (_| | |   <  \033[0m   | |   | |  ___) |")
+print(f"[{params['branding']}Startup]\033[94m /_/   \_\_|_|\033[1;35m |_|\__,_|_|_|\_\ \033[0m   |_|   |_| |____/ ")
+print(f"[{params['branding']}Startup]")
+
+##############################################
+#### Update any changes to confignew.json ####
+##############################################
+
+update_config_path = this_dir / "system" / "config" / "at_configupdate.json"
+downgrade_config_path = this_dir / "system" / "config" / "at_configdowngrade.json"
+
+def changes_needed(main_config, update_config, downgrade_config):
+    """Check if there are any changes to be made to the main configuration."""
+    for key in downgrade_config.keys():
+        if key in main_config:
+            return True
+    for key, value in update_config.items():
+        if key not in main_config:
+            return True
+    return False
+
+def update_config(config_file_path, update_config_path, downgrade_config_path):
+    try:
+        with open(config_file_path, 'r') as file:
+            main_config = json.load(file)
+        with open(update_config_path, 'r') as file:
+            update_config = json.load(file)
+        with open(downgrade_config_path, 'r') as file:
+            downgrade_config = json.load(file)
+
+        # Determine if changes are needed
+        if changes_needed(main_config, update_config, downgrade_config):
+            # Backup with timestamp to avoid overwriting
+            timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+            backup_path = config_file_path.with_suffix(f".{timestamp}.bak")
+            logging.info(f"Creating backup of the main config to {backup_path}")
+            shutil.copy(config_file_path, backup_path)
+
+            # Proceed with updates and downgrades
+            for key, value in update_config.items():
+                if key not in main_config:
+                    main_config[key] = value
+            for key in downgrade_config.keys():
+                if key in main_config:
+                    del main_config[key]
+
+            # Save the updated configuration
+            with open(config_file_path, 'w') as file:
+                json.dump(main_config, file, indent=4)
+
+            print(f"[{params['branding']}Startup] \033[92mConfig file check      : \033[91mUpdates applied\033[0m")
+        else:
+            print(f"[{params['branding']}Startup] \033[92mConfig file check      : \033[93mNo Updates required\033[0m")
+
+    except Exception as e:
+        print(f"[{params['branding']}Startup] \033[92mConfig file check      : \033[91mError updating\033[0m")
+
+# Update the configuration
+update_config(config_file_path, update_config_path, downgrade_config_path)
+# Re-Load the params dictionary from the confignew.json file
+params = load_config(config_file_path)
+
+#########################################
+#### Continue on with Startup Checks ####
+#########################################
+            
+# Required for sentence splitting
+try:
+    from TTS.api import TTS
+    from TTS.utils.synthesizer import Synthesizer
+except ModuleNotFoundError:
+    # Inform the user about the missing module and suggest next steps
+    print(f"[{params['branding']}]\033[91mWarning\033[0m Could not find the TTS module. Make sure to install the requirements for the {params['branding']} extension.")
+    print(f"[{params['branding']}]\033[91mWarning\033[0m Please use the ATSetup utility or check the Github installation instructions.")
+    # Re-raise the ModuleNotFoundError to stop the program and print the traceback
+    raise 
+
+# Suppress logging
+logging.disable(logging.ERROR)
+try:
+    import deepspeed
+    deepspeed_installed = True
+except ImportError:
+    deepspeed_installed = False
+# Restore previous logging level
+logging.disable(current_disable_level)
+
+# Import gradio if being used within text generation webUI
+try:
+    import gradio as gr
+    from modules import chat, shared, ui_chat
+    from modules.logging_colors import logger
+    from modules.ui import create_refresh_button
+    from modules.utils import gradio
+
+    # This is set to check if the script is being run within text generation webui or as a standalone script. False is running as part of text gen web ui or a gradio interface
+    running_in_standalone = False
+    output_folder_wav = params["output_folder_wav"]
+    print(f"[{params['branding']}Startup] \033[92m{params['branding']}startup Mode   : \033[93mText-Gen-webui mode\033[0m")
+except ModuleNotFoundError:
+    output_folder_wav = params["output_folder_wav_standalone"]
+    print(f"[{params['branding']}Startup] \033[92m{params['branding']}startup Mode   : \033[93mStandalone mode\033[0m")
+    # This is set to check if the script is being run within text generation webui or as a standalone script. true means standalone
+    running_in_standalone = True
+
+###########################
+#### STARTUP VARIABLES ####
+###########################
+# STARTUP VARIABLE - Import languges file for Gradio to be able to display them in the interface
+with open(this_dir / "system" / "config" / "languages.json", encoding="utf8") as f:
+    languages = json.load(f)
+# Create a global lock
+process_lock = threading.Lock()
+# Base setting for a possible FineTuned model existing and the loader being available
+tts_method_xtts_ft = False
+
+
+# Gather the voice files
+def get_available_voices():
+    return sorted([voice.name for voice in Path(f"{this_dir}/voices").glob("*.wav")])
+
+
+############################################
+#### DELETE OLD OUTPUT WAV FILES IF SET ####
+############################################
+def delete_old_files(folder_path, days_to_keep):
+    current_time = datetime.now()
+    print(f"[{params['branding']}Startup] \033[92mWAV file deletion      :\033[93m", delete_output_wavs_setting,"\033[0m")
+    for file_name in os.listdir(folder_path):
+        file_path = os.path.join(folder_path, file_name)
+        if os.path.isfile(file_path):
+            file_creation_time = datetime.fromtimestamp(os.path.getctime(file_path))
+            age = current_time - file_creation_time
+            if age > timedelta(days=days_to_keep):
+                os.remove(file_path)
+
+
+# Extract settings using params dictionary
+delete_output_wavs_setting = params["delete_output_wavs"]
+output_folder_wav = os.path.normpath(output_folder_wav)
+
+# Check and perform file deletion
+if delete_output_wavs_setting.lower() == "disabled":
+    print("["+ params["branding"]+"Startup] \033[92mWAV file deletion      :\033[93m Disabled\033[0m")
+else:
+    try:
+        days_to_keep = int(delete_output_wavs_setting.split()[0])
+        delete_old_files(output_folder_wav, days_to_keep)
+    except ValueError:
+        print(f"[{params['branding']}Startup] \033[92mWAV file deletion      :\033[93m Invalid setting for deleting old wav files. Please use 'Disabled' or 'X Days' format\033[0m")
+
+if deepspeed_installed:
+    print(f"[{params['branding']}Startup] \033[92mDeepSpeed version      :\033[93m",deepspeed.__version__,"\033[0m")
+else:
+    print(f"[{params['branding']}Startup] \033[92mDeepSpeed version      :\033[91m Not Detected\033[0m")
+
+########################
+#### STARTUP CHECKS ####
+########################
+# STARTUP Checks routine
+def check_required_files():
+    this_dir = Path(__file__).parent.resolve()
+    download_script_path = this_dir / "modeldownload.py"
+    subprocess.run(["python", str(download_script_path)])
+
+# STARTUP Call Check routine
+check_required_files()
+
+##################################################
+#### Check to see if a finetuned model exists ####
+##################################################
+# Set the path to the directory
+trained_model_directory = this_dir / "models" / "trainedmodel"
+# Check if the directory "trainedmodel" exists
+finetuned_model = trained_model_directory.exists()
+# If the directory exists, check for the existence of the required files
+# If true, this will add a extra option in the Gradio interface for loading Xttsv2 FT
+if finetuned_model:
+    required_files = ["model.pth", "config.json", "vocab.json"]
+    finetuned_model = all(
+        (trained_model_directory / file).exists() for file in required_files
+    )
+if finetuned_model:
+    print(f"[{params['branding']}Startup] \033[92mFinetuned model        :\033[93m Detected\033[0m")
+
+####################################################
+#### SET GRADIO BUTTONS BASED ON confignew.json ####
+####################################################
+
+if params["tts_method_api_tts"] == True:
+    gr_modelchoice = "API TTS"
+elif params["tts_method_api_local"] == True:
+    gr_modelchoice = "API Local"
+elif params["tts_method_xtts_local"] == True:
+    gr_modelchoice = "XTTSv2 Local"
+
+# Set the default for Narrated text without asterisk or quotes to be Narrator
+non_quoted_text_is = True
+
+######################
+#### GRADIO STUFF ####
+######################
+def remove_tts_from_history(history):
+    for i, entry in enumerate(history["internal"]):
+        history["visible"][i] = [history["visible"][i][0], entry[1]]
+    return history
+
+
+def toggle_text_in_history(history):
+    for i, entry in enumerate(history["visible"]):
+        visible_reply = entry[1]
+        if visible_reply.startswith("<audio"):
+            if params["show_text"]:
+                reply = history["internal"][i][1]
+                history["visible"][i] = [
+                    history["visible"][i][0],
+                    f"{visible_reply.split('</audio>')[0]}</audio>\n\n{reply}",
+                ]
+            else:
+                history["visible"][i] = [
+                    history["visible"][i][0],
+                    f"{visible_reply.split('</audio>')[0]}</audio>",
+                ]
+    return history
+
+
+def history_modifier(history):
+    # Remove autoplay from the last reply
+    if len(history["internal"]) > 0:
+        history["visible"][-1] = [
+            history["visible"][-1][0],
+            history["visible"][-1][1].replace("controls autoplay>", "controls>"),
+        ]
+
+    return history
+
+
+######################################
+#### SUBPROCESS/WEBSERVER STARTUP ####
+######################################
+base_url = f"http://{params['ip_address']}:{params['port_number']}"
+script_path = this_dir / "tts_server.py"
+
+
+def signal_handler(sig, frame):
+    print(f"[{params['branding']}Shutdown] \033[94mReceived Ctrl+C, terminating subprocess\033[92m")
+    if process.poll() is None:
+        process.terminate()
+        process.wait()  # Wait for the subprocess to finish
+    sys.exit(0)
+
+
+# Attach the signal handler to the SIGINT signal (Ctrl+C)
+signal.signal(signal.SIGINT, signal_handler)
+# Check if we're running in docker
+if os.path.isfile("/.dockerenv"):
+    print(
+        f"[{params['branding']}Startup] \033[94mRunning in Docker. Please wait.\033[0m"
+    )
+else:
+    # Start the subprocess
+    process = subprocess.Popen(["python", script_path])
+    # Check if the subprocess has started successfully
+    if process.poll() is None:
+        print(f"[{params['branding']}Startup] \033[92mTTS Subprocess         :\033[93m Starting up\033[0m")
+        print(f"[{params['branding']}Startup]")
+        print(
+            f"[{params['branding']}Startup] \033[94m{params['branding']}Settings & Documentation:\033[00m",
+            f"\033[92mhttp://{params['ip_address']}:{params['port_number']}\033[00m",
+        )
+        print(f"[{params['branding']}Startup]")
+    else:
+        print(f"[{params['branding']}Startup] \033[91mWarning\033[0m TTS Subprocess Webserver failing to start process")
+        print(f"[{params['branding']}Startup] \033[91mWarning\033[0m It could be that you have something on port:",params["port_number"],)
+        print(f"[{params['branding']}Startup] \033[91mWarning\033[0m Or you have not started in a Python environement with all the necesssary bits installed")
+        print(f"[{params['branding']}Startup] \033[91mWarning\033[0m Check you are starting Text-generation-webui with either the start_xxxxx file or the Python environment with cmd_xxxxx file.")
+        print(f"[{params['branding']}Startup] \033[91mWarning\033[0m xxxxx is the type of OS you are on e.g. windows, linux or mac.")
+        print(f"[{params['branding']}Startup] \033[91mWarning\033[0m Alternatively, you could check no other Python processes are running that shouldnt be e.g. Restart your computer is the simple way.")
+        # Cleanly kill off this script, but allow text-generation-webui to keep running, albeit without this alltalk_tts
+        sys.exit(1)
+
+    timeout = startup_wait_time  # Gather timeout setting from startup_wait_time
+
+    # Introduce a delay before starting the check loop
+    time.sleep(26)  # Wait 26 secs before checking if the tts_server.py has started up.
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        try:
+            response = requests.get(f"{base_url}/ready")
+            if response.status_code == 200:
+                break
+        except requests.RequestException as e:
+            # Print the exception for debugging purposes
+            print(f"[{params['branding']}Startup] \033[91mWarning\033[0m TTS Subprocess has NOT started up yet, Will keep trying for {timeout} seconds maximum. Please wait.")
+        time.sleep(5)
+    else:
+        print(f"\n[{params['branding']}Startup] Startup timed out. Full help available here \033[92mhttps://github.com/erew123/alltalk_tts#-help-with-problems\033[0m")
+        print(f"[{params['branding']}Startup] On older system you may wish to open and edit \033[94mscript.py\033[0m with a text editor and changing the")
+        print(f"[{params['branding']}Startup] \033[94mstartup_wait_time = 120\033[0m setting to something like \033[94mstartup_wait_time = 240\033[0m as this will allow")
+        print(f"[{params['branding']}Startup] AllTalk more time to try load the model into your VRAM. Otherise please visit the Github for")
+        print(f"[{params['branding']}Startup] a list of other possible troubleshooting options.")
+        # Cleanly kill off this script, but allow text-generation-webui to keep running, albeit without this alltalk_tts
+        sys.exit(1)
+
+
+#####################################
+#### MODEL LOADING AND UNLOADING ####
+#####################################
+# MODEL - Swap model based on Gradio selection API TTS, API Local, XTTSv2 Local
+def send_reload_request(tts_method):
+    global tts_method_xtts_ft
+    try:
+        params["tts_model_loaded"] = False
+        url = f"{base_url}/api/reload"
+        payload = {"tts_method": tts_method}
+        response = requests.post(url, params=payload)
+        response.raise_for_status()  # Raises an HTTPError for bad responses
+        json_response = response.json()
+        # Check if the reload operation was successful
+        if json_response.get("status") == "model-success":
+            # Update tts_tts_model_loaded to True if the reload was successful
+            params["tts_model_loaded"] = True
+            # Update local script parameters based on the tts_method
+            if tts_method == "API TTS":
+                params["tts_method_api_local"] = False
+                params["tts_method_xtts_local"] = False
+                params["tts_method_api_tts"] = True
+                params["deepspeed_activate"] = False
+                audio_path = this_dir / "system" / "at_sounds" / "apitts.wav"
+                tts_method_xtts_ft = False
+            elif tts_method == "API Local":
+                params["tts_method_api_tts"] = False
+                params["tts_method_xtts_local"] = False
+                params["tts_method_api_local"] = True
+                params["deepspeed_activate"] = False
+                audio_path = this_dir / "system" / "at_sounds" / "apilocal.wav"
+                tts_method_xtts_ft = False
+            elif tts_method == "XTTSv2 Local":
+                params["tts_method_api_tts"] = False
+                params["tts_method_api_local"] = False
+                params["tts_method_xtts_local"] = True
+                audio_path = this_dir / "system" / "at_sounds" / "xttslocal.wav"
+                tts_method_xtts_ft = False
+            elif tts_method == "XTTSv2 FT":
+                params["tts_method_api_tts"] = False
+                params["tts_method_api_local"] = False
+                params["tts_method_xtts_local"] = False
+                audio_path = this_dir / "system" / "at_sounds" / "xttsfinetuned.wav"
+                tts_method_xtts_ft = True
+        return f'<audio src="file/{audio_path}" controls autoplay></audio>'
+    except requests.exceptions.RequestException as e:
+        # Handle the HTTP request error
+        print(f"[{params['branding']}Server] \033[91mWarning\033[0m Error during request to webserver process: {e}")
+        return {"status": "error", "message": str(e)}
+
+
+##################
+#### LOW VRAM ####
+##################
+# LOW VRAM - Gradio Checkbox handling
+def send_lowvram_request(low_vram):
+    try:
+        params["tts_model_loaded"] = False
+        if low_vram:
+            audio_path = this_dir / "system" / "at_sounds" / "lowvramenabled.wav"
+        else:
+            audio_path = this_dir / "system" / "at_sounds" / "lowvramdisabled.wav"
+        url = f"{base_url}/api/lowvramsetting?new_low_vram_value={low_vram}"
+        headers = {"Content-Type": "application/json"}
+        response = requests.post(url, headers=headers)
+        response.raise_for_status()  # Raises an HTTPError for bad responses
+        json_response = response.json()
+        # Check if the low VRAM request was successful
+        if json_response.get("status") == "lowvram-success":
+            # Update any relevant variables or perform other actions on success
+            params["tts_model_loaded"] = True
+        return f'<audio src="file/{audio_path}" controls autoplay></audio>'
+    except requests.exceptions.RequestException as e:
+        # Handle the HTTP request error
+        print(f"[{params['branding']}Server] \033[91mWarning\033[0m Error during request to webserver process: {e}")
+        return {"status": "error", "message": str(e)}
+
+
+###################
+#### DeepSpeed ####
+###################
+# DEEPSPEED - Reload the model when DeepSpeed checkbox is enabled/disabled
+def send_deepspeed_request(deepspeed_param):
+    try:
+        params["tts_model_loaded"] = False
+        if deepspeed_param:
+            audio_path = this_dir / "system" / "at_sounds" / "deepspeedenabled.wav"
+        else:
+            audio_path = this_dir / "system" / "at_sounds" / "deepspeeddisabled.wav"
+        url = f"{base_url}/api/deepspeed?new_deepspeed_value={deepspeed_param}"
+        headers = {"Content-Type": "application/json"}
+        response = requests.post(url, headers=headers)
+        response.raise_for_status()  # Raises an HTTPError for bad responses
+        json_response = response.json()
+        # Check if the deepspeed request was successful
+        if json_response.get("status") == "deepspeed-success":
+            # Update any relevant variables or perform other actions on success
+            params["tts_model_loaded"] = True
+        return f'<audio src="file/{audio_path}" controls autoplay></audio>'
+    except requests.exceptions.RequestException as e:
+        # Handle the HTTP request error
+        print(f"[{params['branding']}Server] \033[91mWarning\033[0m Error during request to webserver process: {e}")
+        return {"status": "error", "message": str(e)}
+
+
+# DEEPSPEED - Display DeepSpeed Checkbox Yes or No
+deepspeed_condition = params["tts_method_xtts_local"] == "True" and deepspeed_installed
+
+
+#############################################################
+#### TTS STRING CLEANING & PROCESSING PRE SENDING TO TTS ####
+#############################################################
+def new_split_into_sentences(self, text):
+    sentences = self.seg.segment(text)
+    if params["remove_trailing_dots"]:
+        sentences_without_dots = []
+        for sentence in sentences:
+            if sentence.endswith(".") and not sentence.endswith("..."):
+                sentence = sentence[:-1]
+
+            sentences_without_dots.append(sentence)
+
+        return sentences_without_dots
+    else:
+        return sentences
+
+
+Synthesizer.split_into_sentences = new_split_into_sentences
+
+
+# Check model is loaded and string isnt empty, before sending a TTS request.
+def before_audio_generation(string, params):
+    # Check Model is loaded into cuda or cpu and error if not
+    if not params["tts_model_loaded"]:
+        print(f"[{params['branding']}Model] \033[91mWarning\033[0m Model is still loading, please wait before trying to generate TTS")
+        return
+    string = html.unescape(string) or random_sentence()
+    if string == "":
+        return "*Empty string*"
+    return string
+
+
+##################
+#### Narrator ####
+##################
+def combine(audio_files, output_folder, state):
+    audio = np.array([])
+
+    for audio_file in audio_files:
+        audio_data, sample_rate = sf.read(audio_file)
+        # Ensure all audio files have the same sample rate
+        if audio.size == 0:
+            audio = audio_data
+        else:
+            audio = np.concatenate((audio, audio_data))
+
+    # Save the combined audio to a file with a specified sample rate
+    if "character_menu" in state:
+        output_file_path = os.path.join(output_folder, f'{state["character_menu"]}_{int(time.time())}_combined.wav')
+    else:
+        output_file_path = os.path.join(output_folder, f"TTSOUT_{int(time.time())}_combined.wav")
+    sf.write(output_file_path, audio, samplerate=sample_rate)
+    # Clean up unnecessary files
+    for audio_file in audio_files:
+        os.remove(audio_file)
+
+    return output_file_path
+
+
+################################
+#### TTS PREVIEW GENERATION ####
+################################
+# PREVIEW VOICE - Generate Random Sentence if Voice Preview box is empty
+def random_sentence():
+    with open(this_dir / "system" / "config" / "harvard_sentences.txt") as f:
+        return random.choice(list(f))
+
+
+# PREVIEW VOICE- Generate TTS Function
+def voice_preview(string):
+    if not params["activate"]:
+        return string
+    # Clean the string, capture model not loaded, and move model to cuda if needed
+    cleaned_string = before_audio_generation(string, params)
+    if cleaned_string is None:
+        return
+    string = cleaned_string
+    # Setup the output file
+    output_file = Path(params["output_folder_wav"]) / "voice_preview.wav"
+    # Generate the audio
+    language_code = languages.get(params["language"])
+    temperature = params["local_temperature"]
+    repetition_penalty = params["local_repetition_penalty"]
+    # Convert the WindowsPath object to a string before using it in JSON payload
+    output_file_str = output_file.as_posix()
+    # Lock before making the generate request
+    with process_lock:
+        generate_response = send_generate_request(
+            string,
+            params["voice"],
+            language_code,
+            temperature,
+            repetition_penalty,
+            output_file_str,
+        )
+    # Check if lock is already acquired
+    if process_lock.locked():
+        print(f"[{params['branding']}Model] \033[91mWarning\033[0m Audio generation is already in progress. Please wait.")
+        return
+    if generate_response.get("status") == "generate-success":
+        # Handle Gradio and playback
+        autoplay = "autoplay" if params["autoplay"] else ""
+        return f'<audio src="file/{output_file_str}?{int(time.time())}" controls {autoplay}></audio>'
+    else:
+        # Handle the case where audio generation was not successful
+        return f"[{params['branding']}Server] Audio generation failed. Status: {generate_response.get('status')}"
+
+
+#######################
+#### TEXT CLEANING ####
+#######################
+
+def process_text(text):
+    # Normalize HTML encoded quotes
+    text = html.unescape(text)
+
+    # Replace ellipsis with a single dot
+    text = re.sub(r"\.{3,}", ".", text)
+
+    # Pattern to identify combined narrator and character speech
+    combined_pattern = r'(\*[^*"]+\*|"[^"*]+")'
+
+    # List to hold parts of speech along with their type
+    ordered_parts = []
+
+    # Track the start of the next segment
+    start = 0
+
+    # Find all matches
+    for match in re.finditer(combined_pattern, text):
+        # Add the text before the match, if any, as ambiguous
+        if start < match.start():
+            ambiguous_text = text[start : match.start()].strip()
+            if ambiguous_text:
+                ordered_parts.append(("ambiguous", ambiguous_text))
+
+        # Add the matched part as either narrator or character
+        matched_text = match.group(0)
+        if matched_text.startswith("*") and matched_text.endswith("*"):
+            ordered_parts.append(("narrator", matched_text.strip("*").strip()))
+        elif matched_text.startswith('"') and matched_text.endswith('"'):
+            ordered_parts.append(("character", matched_text.strip('"').strip()))
+        else:
+            # In case of mixed or improperly formatted parts
+            if "*" in matched_text:
+                ordered_parts.append(("narrator", matched_text.strip("*").strip('"')))
+            else:
+                ordered_parts.append(("character", matched_text.strip('"').strip("*")))
+
+        # Update the start of the next segment
+        start = match.end()
+
+    # Add any remaining text after the last match as ambiguous
+    if start < len(text):
+        ambiguous_text = text[start:].strip()
+        if ambiguous_text:
+            ordered_parts.append(("ambiguous", ambiguous_text))
+
+    return ordered_parts
+
+
+########################
+#### IMAGE CLEANING ####
+########################
+
+img_pattern = r'<img[^>]*src\s*=\s*["\'][^"\'>]+["\'][^>]*>'
+
+def extract_and_remove_images(text):
+    """
+    Extracts all image data from the text and removes it for clean TTS processing.
+    Returns the cleaned text and the extracted image data.
+    """
+    img_matches = re.findall(img_pattern, text)
+    img_info = "\n".join(img_matches)  # Store extracted image data
+    cleaned_text = re.sub(img_pattern, '', text)  # Remove images from text
+    return cleaned_text, img_info
+
+def reinsert_images(text, img_info):
+    """
+    Reinserts the previously extracted image data back into the text.
+    """
+    if img_info:  # Check if there are images to reinsert
+        text += f"\n\n{img_info}"
+    return text
+
+#################################
+#### TTS STANDARD GENERATION ####
+#################################
+# STANDARD VOICE - Generate TTS Function
+def output_modifier(string, state):
+    if not params["activate"]:
+        return string
+    img_info = ""
+    cleaned_text, img_info = extract_and_remove_images(string)
+    # print("Cleaned STRING IS:", cleaned_text)
+    cleaned_string = before_audio_generation(cleaned_text, params)
+    if cleaned_string is None:
+        return
+    language_code = languages.get(params["language"])
+    temperature = params["local_temperature"]
+    repetition_penalty = params["local_repetition_penalty"]
+    # Create a list to store generated audio paths
+    audio_files = []
+    if process_lock.acquire(blocking=False):
+        try:
+            if params["narrator_enabled"]:
+                processed_parts = process_text(cleaned_string)
+
+                audio_files_all_paragraphs = []
+                for part_type, part in processed_parts:
+                    # Skip parts that are too short
+                    if len(part.strip()) <= 3:
+                        continue
+
+                    # Determine the voice to use based on the part type
+                    if part_type == "narrator":
+                        voice_to_use = params["narrator_voice"]
+                        print(f"[{params['branding']}TTSGen] \033[92mNarrator\033[0m")  # Green
+                    elif part_type == "character":
+                        voice_to_use = params["voice"]
+                        print(f"[{params['branding']}TTSGen] \033[36mCharacter\033[0m")  # Yellow
+                    else:
+                        # Handle ambiguous parts based on user preference
+                        voice_to_use = (
+                            params["voice"]
+                            if non_quoted_text_is
+                            else params["narrator_voice"]
+                        )
+                        voice_description = (
+                            "\033[36mCharacter (Text-not-inside)\033[0m"
+                            if non_quoted_text_is
+                            else "\033[92mNarrator (Text-not-inside)\033[0m"
+                        )
+                        print(f"[{params['branding']}TTSGen] {voice_description}")
+
+                    # Replace multiple exclamation marks, question marks, or other punctuation with a single instance
+                    cleaned_part = re.sub(r"([!?.\u3002\uFF1F\uFF01\uFF0C])\1+", r"\1", part)
+                    # Replace "Chinese ellipsis" with a single dot
+                    cleaned_part = re.sub(r"\u2026{1,2}", ". ", cleaned_part)
+                    # Further clean to remove any other unwanted characters
+                    cleaned_part = re.sub(r'[^a-zA-Z0-9\s.,;:!?\-\'"$\u0400-\u04FF\u00C0-\u00FF\u0150\u0151\u0170\u0171\u0900-\u097F\u2018\u2019\u201C\u201D\u3001\u3002\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FFF\u3400-\u4DBF\uF900-\uFAFF\u0600-\u06FF\u0750-\u077F\uFB50-\uFDFF\uFE70-\uFEFF\uAC00-\uD7A3\u1100-\u11FF\u3130-\u318F\uFF01\uFF0c\uFF1A\uFF1B\uFF1F]', '', cleaned_part)
+                    # Remove all newline characters (single or multiple)
+                    cleaned_part = re.sub(r"\n+", " ", cleaned_part)
+
+                    # Generate TTS and output to a file
+                    output_filename = get_output_filename(state)
+                    generate_response = send_generate_request(
+                        cleaned_part,
+                        voice_to_use,
+                        language_code,
+                        temperature,
+                        repetition_penalty,
+                        output_filename,
+                    )
+                    audio_path = generate_response.get("data", {}).get("audio_path")
+                    audio_files_all_paragraphs.append(audio_path)
+
+                # Combine audio files across paragraphs
+                final_output_file = combine(
+                    audio_files_all_paragraphs, params["output_folder_wav"], state
+                )
+            else:
+                # Decode HTML entities first
+                cleaned_part = html.unescape(cleaned_string)
+                # Replace multiple instances of certain punctuation marks with a single instance
+                cleaned_part = re.sub(r"([!?.\u3002\uFF1F\uFF01\uFF0C])\1+", r"\1", cleaned_part)
+                # Replace "Chinese ellipsis" with a single dot
+                cleaned_part = re.sub(r"\u2026{1,2}", ". ", cleaned_part)
+                # Further clean to remove any other unwanted characters
+                cleaned_part = re.sub(r'[^a-zA-Z0-9\s.,;:!?\-\'"$\u0400-\u04FF\u00C0-\u00FF\u0150\u0151\u0170\u0171\u0900-\u097F\u2018\u2019\u201C\u201D\u3001\u3002\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FFF\u3400-\u4DBF\uF900-\uFAFF\u0600-\u06FF\u0750-\u077F\uFB50-\uFDFF\uFE70-\uFEFF\uAC00-\uD7A3\u1100-\u11FF\u3130-\u318F\uFF01\uFF0c\uFF1A\uFF1B\uFF1F]', '', cleaned_part)
+                # Remove all newline characters (single or multiple)
+                cleaned_part = re.sub(r"\n+", " ", cleaned_part)
+                # Process the part and give it a non-character name if being used vai API or standalone.
+                if "character_menu" in state:
+                    output_file = Path(
+                        f'{params["output_folder_wav"]}/{state["character_menu"]}_{int(time.time())}.wav'
+                    )
+                else:
+                    output_file = Path(
+                        f'{params["output_folder_wav"]}/TTSOUT_{int(time.time())}.wav'
+                    )
+                output_file_str = output_file.as_posix()
+                output_file = get_output_filename(state)
+                generate_response = send_generate_request(
+                    cleaned_part,
+                    params["voice"],
+                    language_code,
+                    temperature,
+                    repetition_penalty,
+                    output_file_str,
+                )
+                audio_path = generate_response.get("data", {}).get("audio_path")
+                final_output_file = audio_path
+        finally:
+            # Always release the lock, whether an exception occurs or not
+            process_lock.release()
+    else:
+        # The lock is already acquired
+        print(
+            f"[{params['branding']}Model] \033[91mWarning\033[0m Audio generation is already in progress. Please wait."
+        )
+        return
+
+    if generate_response.get("status") == "generate-success":
+        audio_path = generate_response.get("data", {}).get("audio_path")
+        if audio_path:
+            # Handle Gradio and playback
+            autoplay = "autoplay" if params["autoplay"] else ""
+            string = (f'<audio src="file/{final_output_file}" controls {autoplay}></audio>')
+            if params["show_text"]:
+                string += reinsert_images(cleaned_string, img_info)
+                shared.processing_message = "*Is typing...*"
+            return string
+        else:
+            print(f"[{params['branding']}Server] \033[91mWarning\033[0m No audio path in the response.")
+    else:
+        print(f"[{params['branding']}Server] \033[91mWarning\033[0m Audio generation failed. Status:", generate_response.get("message"),)
+
+def get_output_filename(state):
+    if "character_menu" in state:
+        return Path(
+            f'{params["output_folder_wav"]}/{state["character_menu"]}_{str(uuid.uuid4())[:8]}.wav'
+        ).as_posix()
+    else:
+        return Path(
+            f'{params["output_folder_wav"]}/TTSOUT_{str(uuid.uuid4())[:8]}.wav'
+        ).as_posix()
+
+
+###############################################
+#### SEND GENERATION REQUEST TO TTS ENGINE ####
+###############################################
+def send_generate_request(
+    text, voice, language, temperature, repetition_penalty, output_file
+):
+    url = f"{base_url}/api/generate"
+    payload = {
+        "text": text,
+        "voice": voice,
+        "language": language,
+        "temperature": temperature,
+        "repetition_penalty": repetition_penalty,
+        "output_file": output_file,
+    }
+    headers = {"Content-Type": "application/json"}
+    response = requests.post(url, json=payload, headers=headers)
+    return response.json()
+
+
+################################
+#### SUBPORCESS TERMINATION ####
+################################
+# Register the termination code to be executed at exit
+atexit.register(lambda: process.terminate() if process.poll() is None else None)
+
+
+######################
+#### GRADIO STUFF ####
+######################
+def state_modifier(state):
+    if not params["activate"]:
+        return state
+
+    state["stream"] = False
+    return state
+
+
+def update_narrator_enabled(value):
+    if value == "Enabled":
+        params["narrator_enabled"] = True
+    elif value == "Disabled":
+        params["narrator_enabled"] = False
+
+
+def update_non_quoted_text_is(value):
+    global non_quoted_text_is
+    if value == "Narrator":
+        non_quoted_text_is = False
+    elif value == "Char":
+        non_quoted_text_is = True
+
+
+def input_modifier(string, state):
+    if not params["activate"]:
+        return string
+
+    shared.processing_message = "*Is recording a voice message...*"
+    return string
+
+
+def ui():
+    with gr.Accordion(params["branding"] + " TTS (XTTSv2)"):
+        # Activate alltalk_tts, Enable autoplay, Show text
+        with gr.Row():
+            activate = gr.Checkbox(value=params["activate"], label="Enable TTS")
+            autoplay = gr.Checkbox(value=params["autoplay"], label="Autoplay TTS")
+            show_text = gr.Checkbox(value=params["show_text"], label="Show Text")
+
+        # Low vram enable, Deepspeed enable, Remove trailing dots
+        with gr.Row():
+            low_vram = gr.Checkbox(
+                value=params["low_vram"], label="Enable Low VRAM Mode"
+            )
+            low_vram_play = gr.HTML(visible=False)
+            deepspeed_checkbox = gr.Checkbox(
+                value=params["deepspeed_activate"],
+                label="Enable DeepSpeed",
+                visible=deepspeed_installed,
+            )
+            deepspeed_checkbox_play = gr.HTML(visible=False)
+            remove_trailing_dots = gr.Checkbox(
+                value=params["remove_trailing_dots"], label='Remove trailing "."'
+            )
+
+        # TTS method, Character voice selection
+        with gr.Row():
+            model_loader_choices = ["API TTS", "API Local", "XTTSv2 Local"]
+            if finetuned_model:
+                model_loader_choices.append("XTTSv2 FT")
+            tts_radio_buttons = gr.Radio(
+                choices=model_loader_choices,
+                label="TTS Method (Each method sounds slightly different)",
+                value=gr_modelchoice,  # Set the default value
+            )
+            tts_radio_buttons_play = gr.HTML(visible=False)
+            with gr.Row():
+                available_voices = get_available_voices()
+                default_voice = params[
+                    "voice"
+                ]  # Check if the default voice is in the list of available voices
+
+                if default_voice not in available_voices:
+                    default_voice = available_voices[
+                        0
+                    ]  # Choose the first available voice as the default
+                # Add allow_custom_value=True to the Dropdown
+                voice = gr.Dropdown(
+                    available_voices,
+                    label="Character Voice",
+                    value=default_voice,
+                    allow_custom_value=True,
+                )
+                create_refresh_button(
+                    voice,
+                    lambda: None,
+                    lambda: {
+                        "choices": get_available_voices(),
+                        "value": params["voice"],
+                    },
+                    "refresh-button",
+                )
+
+        # Language, Narrator voice
+        with gr.Row():
+            language = gr.Dropdown(
+                languages.keys(), label="Language", value=params["language"]
+            )
+            with gr.Row():
+                narrator_voice_gr = gr.Dropdown(
+                    get_available_voices(),
+                    label="Narrator Voice",
+                    allow_custom_value=True,
+                    value=params["narrator_voice"],
+                )
+                create_refresh_button(
+                    narrator_voice_gr,
+                    lambda: None,
+                    lambda: {
+                        "choices": get_available_voices(),
+                        "value": params["narrator_voice"],
+                    },
+                    "refresh-button",
+                )
+
+        # Temperature, Repetition Penalty
+        with gr.Row():
+            local_temperature_gr = gr.Slider(
+                minimum=0.05,
+                maximum=1,
+                step=0.05,
+                label="Temperature",
+                value=params["local_temperature"],
+            )
+            local_repetition_penalty_gr = gr.Slider(
+                minimum=0.5,
+                maximum=20,
+                step=0.5,
+                label="Repetition Penalty",
+                value=params["local_repetition_penalty"],
+            )
+
+        # Narrator enable, Non quoted text, Explanation text
+        with gr.Row():
+            with gr.Row():
+                narrator_enabled_gr = gr.Radio(
+                    choices={"Enabled": "true", "Disabled": "false"},
+                    label="Narrator",
+                    value="Enabled" if params.get("narrator_enabled") else "Disabled",
+                )
+                non_quoted_text_is_gr = gr.Radio(
+                    choices={"Character": "true", "Narrator": "false"},
+                    label='Unmarked text NOT inside of * or " is',
+                    value="Character" if non_quoted_text_is else "Narrator",
+                )
+                explanation_text = gr.HTML(
+                    f"<p>⚙️ <a href='http://{params['ip_address']}:{params['port_number']}'>Settings and Documentation Page</a><a href='http://{params['ip_address']}:{params['port_number']}'></a>⚙️<br>- Low VRAM Mode and Deepspeed take 15 seconds to be enabled or disabled.<br>- The DeepSpeed checkbox is only visible if DeepSpeed is present.</p>"
+                )
+
+        # Preview speech
+        with gr.Row():
+            preview_text = gr.Text(
+                show_label=False,
+                placeholder="Preview text",
+                elem_id="silero_preview_text",
+            )
+            preview_play = gr.Button("Preview")
+            preview_audio = gr.HTML(visible=False)
+
+        with gr.Row():
+            convert = gr.Button("Permanently replace audios with the message texts")
+            convert_cancel = gr.Button("Cancel", visible=False)
+            convert_confirm = gr.Button(
+                "Confirm (cannot be undone)", variant="stop", visible=False
+            )
+
+    # Convert history with confirmation
+    convert_arr = [convert_confirm, convert, convert_cancel]
+    convert.click(
+        lambda: [
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=True),
+        ],
+        None,
+        convert_arr,
+    )
+    convert_confirm.click(
+        lambda: [
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+        ],
+        None,
+        convert_arr,
+    ).then(remove_tts_from_history, gradio("history"), gradio("history")).then(
+        chat.save_history,
+        gradio("history", "unique_id", "character_menu", "mode"),
+        None,
+    ).then(
+        chat.redraw_html, gradio(ui_chat.reload_arr), gradio("display")
+    )
+
+    convert_cancel.click(
+        lambda: [
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+        ],
+        None,
+        convert_arr,
+    )
+
+    # Toggle message text in history
+    show_text.change(lambda x: params.update({"show_text": x}), show_text, None).then(
+        toggle_text_in_history, gradio("history"), gradio("history")
+    ).then(
+        chat.save_history,
+        gradio("history", "unique_id", "character_menu", "mode"),
+        None,
+    ).then(
+        chat.redraw_html, gradio(ui_chat.reload_arr), gradio("display")
+    )
+
+    # Event functions to update the parameters in the backend
+    activate.change(lambda x: params.update({"activate": x}), activate, None)
+    autoplay.change(lambda x: params.update({"autoplay": x}), autoplay, None)
+    low_vram.change(lambda x: params.update({"low_vram": x}), low_vram, None)
+    low_vram.change(lambda x: send_lowvram_request(x), low_vram, low_vram_play, None)
+    tts_radio_buttons.change(
+        send_reload_request, tts_radio_buttons, tts_radio_buttons_play, None
+    )
+    deepspeed_checkbox.change(
+        send_deepspeed_request, deepspeed_checkbox, deepspeed_checkbox_play, None
+    )
+    remove_trailing_dots.change(
+        lambda x: params.update({"remove_trailing_dots": x}), remove_trailing_dots, None
+    )
+    voice.change(lambda x: params.update({"voice": x}), voice, None)
+    language.change(lambda x: params.update({"language": x}), language, None)
+
+    # TSS Settings
+    local_temperature_gr.change(
+        lambda x: params.update({"local_temperature": x}), local_temperature_gr, None
+    )
+    local_repetition_penalty_gr.change(
+        lambda x: params.update({"local_repetition_penalty": x}),
+        local_repetition_penalty_gr,
+        None,
+    )
+
+    # Narrator selection actions
+    narrator_enabled_gr.change(update_narrator_enabled, narrator_enabled_gr, None)
+    non_quoted_text_is_gr.change(update_non_quoted_text_is, non_quoted_text_is_gr, None)
+    narrator_voice_gr.change(
+        lambda x: params.update({"narrator_voice": x}), narrator_voice_gr, None
+    )
+
+    # Play preview
+    preview_text.submit(voice_preview, preview_text, preview_audio)
+    preview_play.click(voice_preview, preview_text, preview_audio)
+
+
+##########################################
+#### STANDALONE MODE LOOP TERMINATION ####
+##########################################
+## Loop to keep the script from exiting out if its being run as a standalone script and not part of text-generation-webui
+if running_in_standalone:
+    while True:
+        try:
+            time.sleep(1)  # Add a small delay to avoid high CPU usage
+        except KeyboardInterrupt:
+            break  # Allow graceful exit on Ctrl+C

alltalk_tts/system/at_admin/at_settings.html

@@ -0,0 +1,261 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AllTalk Startup Settings</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 5px;
+            padding: 5px;
+            background-color: #f4f4f4;
+        }
+
+        h1 {
+            color: #333;
+            margin-bottom: 10px;
+        }
+
+        h1,
+        h2,
+        h3 {
+            text-decoration: underline;
+            margin-bottom: 10px;
+        }
+
+        form {
+            max-width: 975px;
+            margin: 0 auto;
+            display: grid;
+            grid-template-columns: repeat(4, 1fr);
+            gap: 5px;
+            /* Adjusted the gap to create more space */
+            justify-content: start;
+        }
+
+        .radio-group {
+            grid-column: span 2;
+            /* Span both columns */
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 10px;
+        }
+
+        label {
+            display: block;
+            margin-top: 2px;
+            color: #555;
+        }
+
+        select,
+        input,
+        button {
+            width: 100%;
+            padding: 3px;
+            margin-top: 1px;
+            margin-bottom: 3px;
+            box-sizing: border-box;
+            font-size: 11px;
+        }
+
+        button {
+            background-color: #4caf50;
+            color: white;
+            border: none;
+            padding: 5px;
+            cursor: pointer;
+            font-size: 12px;
+            grid-column: span 4;
+        }
+
+        .warning {
+            grid-column: span 4;
+            /* Span all 4 columns */
+            text-align: center;
+            /* Center-align the text */
+            color: red;
+            /* Adjusted color for emphasis */
+            font-weight: bold;
+            /* Make the text bold */
+            margin-top: 10px;
+            /* Add some space between the button and the warning */
+        }
+    </style>
+</head>
+
+<body>
+    <h3>AllTalk Startup Settings</h3><br>
+    <form action="/update-settings" method="post">
+
+        <label for="activate" style="color: #b273fa;">TG-webui Activate TTS:</label>
+        <select id="activate" name="activate" required="">
+            <option {% if data.activate %}selected{% endif %} value="true">True</option>
+            <option {% if not data.activate %}selected{% endif %} value="false">False</option>
+        </select>
+
+        <label for="autoplay" style="color: #b273fa;">&nbsp; &nbsp; TG-webui Autoplay TTS:</label>
+        <select id="autoplay" name="autoplay" required="">
+            <option {% if data.autoplay %}selected{% endif %} value="true">True</option>
+            <option {% if not data.autoplay %}selected{% endif %} value="false">False</option>
+        </select>
+
+        <label for="show_text" style="color: #b273fa;">TG-webui Show Text:</label>
+        <select id="show_text" name="show_text" required="">
+            <option {% if data.show_text %}selected{% endif %} value="true">True</option>
+            <option {% if not data.show_text %}selected{% endif %} value="false">False</option>
+        </select>
+
+        <label for="voice" style="color: #b273fa;">&nbsp; &nbsp;  TG-webui Default voice:</label>
+        <select id="voice" name="voice" required="">
+            {% for file in wav_files %}
+            <option value="{{ file }}" {% if data.voice==file %}selected{% endif %}>{{ file }}</option>
+            {% endfor %}
+        </select>
+
+
+        <label for="language" style="color: #b273fa;">TG-webui Default Language:</label>
+        <select id="language" name="language" required="">
+            <option value="Arabic" {% if data.language=='Arabic' %}selected{% endif %}>Arabic</option>
+            <option value="Chinese" {% if data.language=='Chinese' %}selected{% endif %}>Chinese</option>
+            <option value="Czech" {% if data.language=='Czech' %}selected{% endif %}>Czech</option>
+            <option value="Dutch" {% if data.language=='Dutch' %}selected{% endif %}>Dutch</option>
+            <option value="English" {% if data.language=='English' %}selected{% endif %}>English</option>
+            <option value="French" {% if data.language=='French' %}selected{% endif %}>French</option>
+            <option value="German" {% if data.language=='German' %}selected{% endif %}>German</option>
+            <option value="Hindi" {% if data.language=='Hindi' %}selected{% endif %}>Hindi</option>
+            <option value="Hungarian" {% if data.language=='Hungarian' %}selected{% endif %}>Hungarian</option>
+            <option value="Italian" {% if data.language=='Italian' %}selected{% endif %}>Italian</option>
+            <option value="Japanese" {% if data.language=='Japanese' %}selected{% endif %}>Japanese</option>
+            <option value="Korean" {% if data.language=='Korean' %}selected{% endif %}>Korean</option>
+            <option value="Polish" {% if data.language=='Polish' %}selected{% endif %}>Polish</option>
+            <option value="Portuguese" {% if data.language=='Portuguese' %}selected{% endif %}>Portuguese</option>
+            <option value="Russian" {% if data.language=='Russian' %}selected{% endif %}>Russian</option>
+            <option value="Spanish" {% if data.language=='Spanish' %}selected{% endif %}>Spanish</option>
+            <option value="Turkish" {% if data.language=='Turkish' %}selected{% endif %}>Turkish</option>
+        </select>
+
+        <label for="narrator_voice" style="color: #b273fa;">&nbsp; &nbsp; TG-webui Narrator voice:</label>
+        <select id="narrator_voice" name="narrator_voice" required="">
+            {% for file in wav_files %}
+            <option value="{{ file }}" {% if data.narrator_voice==file %}selected{% endif %}>{{ file }}</option>
+            {% endfor %}
+        </select>
+
+        <label for="remove_trailing_dots" style="color: #b273fa;">TG-webui Remove Trailing Dots:</label>
+        <select id="remove_trailing_dots" name="remove_trailing_dots" required="">
+            <option {% if data.remove_trailing_dots %}selected{% endif %} value="true">True</option>
+            <option {% if not data.remove_trailing_dots %}selected{% endif %} value="false">False</option>
+        </select>
+
+        <label for="narrator_enabled" style="color: #b273fa;">&nbsp; &nbsp; TG-webui Narrator enabled:</label>
+        <select id="narrator_enabled" name="narrator_enabled" required="">
+            <option {% if data.narrator_enabled %}selected{% endif %} value="true">True</option>
+            <option {% if not data.narrator_enabled %}selected{% endif %} value="false">False</option>
+        </select>
+
+        <label for="delete_output_wavs" style="color: #33cc33;">Del WAV's older than:</label>
+        <select id="delete_output_wavs" name="delete_output_wavs" required="">
+            <option value="Disabled" {% if data.delete_output_wavs=='Disabled' %}selected{% endif %}>Disabled</option>
+            <option value="1 Day" {% if data.delete_output_wavs=='1 Day' %}selected{% endif %}>1 Day</option>
+            <option value="2 Days" {% if data.delete_output_wavs=='2 Days' %}selected{% endif %}>2 Days</option>
+            <option value="3 Days" {% if data.delete_output_wavs=='3 Days' %}selected{% endif %}>3 Days</option>
+            <option value="4 Day" {% if data.delete_output_wavs=='4 Days' %}selected{% endif %}>4 Days</option>
+            <option value="5 Day" {% if data.delete_output_wavs=='5 Days' %}selected{% endif %}>5 Days</option>
+            <option value="6 Day" {% if data.delete_output_wavs=='6 Days' %}selected{% endif %}>6 Days</option>
+            <option value="7 Days" {% if data.delete_output_wavs=='7 Days' %}selected{% endif %}>7 Days</option>
+            <option value="14 Days" {% if data.delete_output_wavs=='14 Days' %}selected{% endif %}>14 Days</option>
+            <option value="21 Days" {% if data.delete_output_wavs=='21 Days' %}selected{% endif %}>21 Days</option>
+            <option value="28 Days" {% if data.delete_output_wavs=='28 Days' %}selected{% endif %}>28 Days</option>
+        </select>
+
+
+        <label for="low_vram" style="color: #33cc33;">&nbsp; &nbsp; Low VRAM:</label>
+        <select id="low_vram" name="low_vram" required="">
+            <option {% if data.low_vram %}selected{% endif %} value="true">True</option>
+            <option {% if not data.low_vram %}selected{% endif %} value="false">False</option>
+        </select>
+
+        <label for="local_temperature" style="color: red;">Local Model temperature:</label>
+        <select id="local_temperature" name="local_temperature" required="">
+            {% for temp in range(0, 101, 5) %}
+            <option value="{{ temp/100 }}" {% if data.local_temperature|float == temp/100 %}selected{% endif %}>{{ "{:.2f}".format(temp/100) }}</option>
+            {% endfor %}
+        </select>
+        
+        <label for="local_repetition_penalty" style="color: red;">&nbsp; &nbsp; Local Model repetition penalty:</label>
+        <select id="local_repetition_penalty" name="local_repetition_penalty" required="">
+            {% for repetition in range(10, 210, 10) %}
+            <option value="{{ repetition/10 }}" {% if data.local_repetition_penalty|float == repetition/10 %}selected{% endif %}>{{ repetition/10 }}</option>
+            {% endfor %}
+        </select>
+
+        <label for="deepspeed_activate" style="color: red;">DeepSpeed Activate:</label>
+        <select id="deepspeed_activate" name="deepspeed_activate" required="">
+            <option {% if data.deepspeed_activate %}selected{% endif %} value="true">True</option>
+            <option {% if not data.deepspeed_activate %}selected{% endif %} value="false">False</option>
+        </select>
+
+        <label for="output_folder_wav" style="color: red;">&nbsp; &nbsp; WAV Output Folder:</label>
+        <input id="output_folder_wav" name="output_folder_wav" required="" type="text"
+            value="{{ data.output_folder_wav }}" />
+
+
+        <input type="hidden" id="tts_model_loaded" name="tts_model_loaded" value="{{ data.tts_model_loaded }}" />
+
+        <!-- Continue updating other dropdowns and inputs in a similar manner -->
+
+        <label for="tts_model_name" style="color: red;"> API TTS Model Name:</label>
+        <input id="tts_model_name" name="tts_model_name" required="" type="text" value="{{ data.tts_model_name }}" />
+
+        <label for="model_version"
+            style="color: red; font-size: 16px; line-height: 1; vertical-align: bottom; margin-bottom: 0;">&nbsp;
+            &nbsp;&nbsp;API Local Model Folder:</label>
+        <span style="font-size: 14px; vertical-align: bottom; margin-bottom: 0; margin-top: 2px;">{{
+            modeldownload_model_path }}</span>
+
+
+
+
+
+
+
+
+
+
+
+        <label for="ip_address" style="color: red;"> IP Address:</label>
+        <input id="ip_address" name="ip_address" required="" type="text" value="{{ data.ip_address }}" />
+
+        <label for="port_number" style="color: red;"> &nbsp; &nbsp; Port Number:</label>
+        <input id="port_number" name="port_number" required="" type="text" value="{{ data.port_number }}" />
+
+        <div class="radio-group">
+            <label for="tts_method_api_local" style="color: #33cc33;">Model: <span
+                    style="color: black; font-weight: normal;">API Local</span>:</label>
+            <input id="tts_method_api_local_true" {% if data.tts_method_api_local %}checked{% endif %} name="tts_method"
+                type="radio" value="api_local" />
+        </div>
+
+        <div class="radio-group">
+            <label for="tts_method_api_tts" style="color: #33cc33;">&nbsp; &nbsp;&nbsp;Model: <span
+                    style="color: black; font-weight: normal;">API TTS</span>:</label>
+            <input id="tts_method_api_tts_true" {% if data.tts_method_api_tts %}checked{% endif %} name="tts_method"
+                type="radio" value="api_tts" />
+        </div>
+
+        <div class="radio-group">
+            <label for="tts_method_xtts_local" style="color: #33cc33;">Model: <span
+                    style="color: black; font-weight: normal;">XTTS Local</span>:</label>
+            <input id="tts_method_xtts_local_true" {% if data.tts_method_xtts_local %}checked{% endif %}
+                name="tts_method" type="radio" value="xtts_local" />
+        </div>
+        <button type="submit">Update Settings</button>
+    </form>
+    <p class="warning">WARNING: Changing RED items or setting DeepSpeed to True on a system without DeepSpeed installed,
+        may cause errors.</p>
+
+</body>
+
+</html>

alltalk_tts/system/at_sounds/apilocal.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c2ab70ebabb0d4c335435723f9a0380b31fb907dd213f833d6b0c5f75079126
+size 169040

alltalk_tts/system/at_sounds/apitts.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d3886158dbb19769d4992828f3c8af65cfc844cf7d42b866239adb80ab4b346
+size 218192

alltalk_tts/system/at_sounds/changingmodel.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68c0081645657f9ca40f6fa834d03d7fcea321f038472e1171d01d0e2e9eea9c
+size 182352

alltalk_tts/system/at_sounds/deepspeeddisabled.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba5623f2fe0b5b729e61e35a601b725dbad5b5b78e79ab221417b0dcf3cfe866
+size 119888

alltalk_tts/system/at_sounds/deepspeedenabled.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e2d93dcd95c559cbbd839f6c3392b9b29c513d0e3aae44a1906588f86718ec5
+size 102480

alltalk_tts/system/at_sounds/lowvramdisabled.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:040baf99d290c163a3ebbcfa711a1e40e38f57110b11136f08493bea7988f441
+size 151632

alltalk_tts/system/at_sounds/lowvramenabled.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:842c9f53f6dda611e775f8f8a0357ee6d5c43571a9ba9dc096f585d1020f2ebd
+size 106576

alltalk_tts/system/at_sounds/xttsfinetuned.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d769ad94ac7690082d6cf6b88a69394021d926026635882022ce167cc0c2b1f8
+size 204880

alltalk_tts/system/at_sounds/xttslocal.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:635d9727a3821acb8cb5297f1451ee3c17e050decd12cefbedafdabfa1d64b30
+size 204880

alltalk_tts/system/config/at_configdowngrade.json

@@ -0,0 +1,2 @@
+{
+}

alltalk_tts/system/config/at_configupdate.json

@@ -0,0 +1,2 @@
+{
+}