1872 lines
70 KiB
Python
1872 lines
70 KiB
Python
"""
|
|
TGWUI Integration Script
|
|
|
|
This script manages the Text-Gen-webui interface for AllTalk's TTS capabilities.
|
|
It provides:
|
|
|
|
- Mode management to detect local or remote operation.
|
|
- Configuration loading and saving for TTS-related settings.
|
|
- Integration with AllTalk server APIs for TTS generation and model updates.
|
|
- A Gradio-based user interface for controlling TTS settings and previewing voices.
|
|
- Centralized logging and debugging functions.
|
|
|
|
Modules:
|
|
- TGWUIModeManager: Handles configuration and mode detection.
|
|
- AllTalkServerSettings: Manages server-side settings and capabilities.
|
|
- Various utility functions for TTS generation, history management, and UI updates.
|
|
|
|
Usage:
|
|
Run this script as part of the AllTalk or TGWUI environment for managing TTS capabilities.
|
|
Ensure the required dependencies and configurations are properly installed.
|
|
|
|
Dependencies:
|
|
- Python 3.7+
|
|
- Gradio, requests, threading, and additional libraries.
|
|
"""
|
|
import re
|
|
import json
|
|
import time
|
|
import inspect
|
|
import random
|
|
import logging
|
|
import threading
|
|
from pathlib import Path
|
|
import requests
|
|
import gradio as gr
|
|
from modules import chat, shared, ui_chat
|
|
from modules.utils import gradio
|
|
from requests.exceptions import RequestException, ConnectionError
|
|
|
|
# Store the current disable level
|
|
current_disable_level = logging.getLogger().manager.disable
|
|
this_dir = Path(__file__).parent.resolve()
|
|
|
|
|
|
class TGWUIModeManager:
|
|
"""Manages TGWUI mode, configuration, and server connection setup."""
|
|
|
|
def __init__(self):
|
|
self.debug_tgwui = False # General Debugging setting. Default is `False`
|
|
self.debug_func = False # Print function name as its used. Default is `False`
|
|
self.is_local = self._detect_mode()
|
|
self._setup_config()
|
|
self._setup_server_connection()
|
|
|
|
def _detect_mode(self):
|
|
"""Detects if running as part of an AllTalk installation."""
|
|
try:
|
|
current_dir = Path(__file__).parent
|
|
alltalk_root = current_dir.parent.parent
|
|
|
|
# Just check if we're in the right place, don't import
|
|
required_files = [
|
|
alltalk_root / "confignew.json",
|
|
alltalk_root / "script.py",
|
|
]
|
|
required_folders = [
|
|
alltalk_root / "system",
|
|
alltalk_root / "models",
|
|
alltalk_root / "outputs",
|
|
alltalk_root / "voices",
|
|
]
|
|
|
|
files_exist = all(f.exists() for f in required_files)
|
|
folders_exist = all(f.is_dir() for f in required_folders)
|
|
|
|
return files_exist and folders_exist
|
|
|
|
except (ImportError, FileNotFoundError) as e:
|
|
# Don't try to use mode_manager here since it doesn't exist yet
|
|
print(f"Error detecting mode: {str(e)}")
|
|
return False
|
|
|
|
def _setup_config(self):
|
|
"""Loads configuration based on the detected mode (local or remote)."""
|
|
if self.is_local:
|
|
# We're in TGWUI mode, use default settings
|
|
self.branding = "AllTalk "
|
|
self.server = {
|
|
"protocol": "http://",
|
|
"address": "127.0.0.1:7851", # Default port
|
|
"timeout": 5,
|
|
}
|
|
# Set complete default config structure
|
|
self.config = {
|
|
"api_def": {"api_port_number": 7851, "api_use_legacy_api": False},
|
|
"tgwui": {
|
|
"tgwui_activate_tts": True,
|
|
"tgwui_autoplay_tts": True,
|
|
"tgwui_narrator_enabled": "false",
|
|
"tgwui_non_quoted_text_is": "narrator",
|
|
"tgwui_deepspeed_enabled": False,
|
|
"tgwui_language": "English",
|
|
"tgwui_lowvram_enabled": False,
|
|
"tgwui_pitch_set": 0,
|
|
"tgwui_temperature_set": 0.75,
|
|
"tgwui_repetitionpenalty_set": 10,
|
|
"tgwui_generationspeed_set": 1,
|
|
"tgwui_narrator_voice": "Please Refresh Settings",
|
|
"tgwui_show_text": True,
|
|
"tgwui_character_voice": "Please Refresh Settings",
|
|
"tgwui_rvc_char_voice": "Disabled",
|
|
"tgwui_rvc_char_pitch": 0,
|
|
"tgwui_rvc_narr_voice": "Disabled",
|
|
"tgwui_rvc_narr_pitch": 0,
|
|
},
|
|
"remote_connection": { # Add this section for local mode too
|
|
"use_legacy_api": False,
|
|
"server_protocol": "http://",
|
|
"server_address": "127.0.0.1:7851",
|
|
"connection_timeout": 5,
|
|
},
|
|
}
|
|
else:
|
|
config_path = Path(__file__).parent / "tgwui_remote_config.json"
|
|
try:
|
|
with open(config_path, "r", encoding="utf8") as config_f:
|
|
self.config = json.load(config_f)
|
|
except (FileNotFoundError, json.JSONDecodeError) as e:
|
|
print(f"Error loading remote config ({str(e)}), using defaults")
|
|
self.config = {
|
|
"branding": "AllTalk ",
|
|
"tgwui": {
|
|
"tgwui_activate_tts": True,
|
|
"tgwui_autoplay_tts": False,
|
|
"tgwui_show_text": True,
|
|
"tgwui_narrator_enabled": "false",
|
|
"tgwui_non_quoted_text_is": "narrator",
|
|
"tgwui_deepspeed_enabled": False,
|
|
"tgwui_language": "English",
|
|
"tgwui_lowvram_enabled": False,
|
|
"tgwui_pitch_set": 0,
|
|
"tgwui_temperature_set": 0.75,
|
|
"tgwui_repetitionpenalty_set": 10,
|
|
"tgwui_generationspeed_set": 1.0,
|
|
"tgwui_narrator_voice": "Please Refresh Settings",
|
|
"tgwui_character_voice": "Please Refresh Settings",
|
|
"tgwui_rvc_char_voice": "Disabled",
|
|
"tgwui_rvc_char_pitch": 0,
|
|
"tgwui_rvc_narr_voice": "Disabled",
|
|
"tgwui_rvc_narr_pitch": 0,
|
|
},
|
|
"remote_connection": {
|
|
"server_protocol": "http://",
|
|
"server_address": "127.0.0.1:7851",
|
|
"connection_timeout": 5,
|
|
"use_legacy_api": False,
|
|
},
|
|
}
|
|
|
|
self.branding = self.config["branding"]
|
|
self.server = {
|
|
"protocol": self.config["remote_connection"]["server_protocol"],
|
|
"address": self.config["remote_connection"]["server_address"],
|
|
"timeout": self.config["remote_connection"]["connection_timeout"],
|
|
}
|
|
|
|
def _setup_server_connection(self):
|
|
"""Sets up the server connection URL."""
|
|
self.server_url = f"{self.server['protocol']}{self.server['address']}"
|
|
|
|
def get_api_url(self, endpoint):
|
|
"""Returns the full API URL for the given endpoint."""
|
|
return f"{self.server_url}/api/{endpoint}"
|
|
|
|
def save_settings(self):
|
|
"""Save current settings to appropriate location"""
|
|
if self.is_local:
|
|
# We're in TGWUI mode, we don't need to save to AllTalk's config
|
|
# The settings are maintained by TGWUI
|
|
pass
|
|
else:
|
|
# In remote mode, save to local config file
|
|
settings = {
|
|
"branding": self.branding,
|
|
"tgwui": self.config["tgwui"],
|
|
"remote_connection": {
|
|
"server_protocol": self.server["protocol"],
|
|
"server_address": self.server["address"],
|
|
"connection_timeout": self.server["timeout"],
|
|
"use_legacy_api": self.config["remote_connection"][
|
|
"use_legacy_api"
|
|
],
|
|
},
|
|
}
|
|
config_path = Path(__file__).parent / "tgwui_remote_config.json"
|
|
with open(config_path, "w", encoding="utf8") as save_f:
|
|
json.dump(settings, save_f, indent=4)
|
|
|
|
|
|
# Initialize mode manager at startup
|
|
mode_manager = TGWUIModeManager()
|
|
|
|
##########################
|
|
# Central print function #
|
|
##########################
|
|
|
|
|
|
def print_func(message, message_type="standard", component="TTS", debug_type=None):
|
|
"""Centralized print function for AllTalk messages
|
|
|
|
Args:
|
|
message (str): The message to print
|
|
message_type (str): Type of message ("standard", "warning", "error", "debug")
|
|
component (str): Component identifier ("TTS", "ENG", "Server", etc.)
|
|
debug_type (str, optional): Can be supplied on the call to specify things like:
|
|
- The function that is sending the debug request.
|
|
- The operation taking place
|
|
"""
|
|
prefix = f"[{mode_manager.branding}{component}] "
|
|
|
|
if message_type == "warning":
|
|
print(f"{prefix}\033[91mWarning\033[0m {message}")
|
|
elif message_type == "error":
|
|
print(f"{prefix}\033[91mError\033[0m {message}")
|
|
elif message_type == "debug":
|
|
if debug_type is None:
|
|
debug_type = ""
|
|
color = "\033[92m" if "Function entry" in message else "\033[93m"
|
|
print(f"{prefix}\033[94mDebug\033[0m {color}{debug_type}\033[0m {message}")
|
|
else: # standard message
|
|
print(f"{prefix}{message}")
|
|
|
|
|
|
def debug_func_entry():
|
|
"""Print debug message for function entry if debug_func is enabled/true"""
|
|
if mode_manager.debug_func:
|
|
print_func(
|
|
"Function entry",
|
|
"debug",
|
|
debug_type=inspect.currentframe().f_back.f_code.co_name,
|
|
)
|
|
|
|
|
|
# Load languages
|
|
with open(Path(__file__).parent / "languages.json", encoding="utf8") as f:
|
|
languages = json.load(f)
|
|
|
|
# Setup other globals
|
|
process_lock = threading.Lock()
|
|
models_available = None
|
|
alltalk_settings = None
|
|
current_model_loaded = None
|
|
tts_model_loaded = None
|
|
|
|
|
|
def get_alltalk_settings():
|
|
"""Fetches current AllTalk settings and updates global configurations."""
|
|
if mode_manager.debug_func:
|
|
print_func(
|
|
"Function entry", "debug", debug_type=inspect.currentframe().f_code.co_name
|
|
)
|
|
global current_model_loaded, models_available
|
|
|
|
def log_error(message, status_code=None):
|
|
"""Helper function for consistent error logging"""
|
|
if status_code:
|
|
print_func(f"{message} Status code:\n{status_code}", message_type="warning")
|
|
else:
|
|
print_func(f"{message}", message_type="warning")
|
|
|
|
try:
|
|
# Make all API requests
|
|
api_calls = {
|
|
"voices": requests.get(
|
|
mode_manager.get_api_url("voices"),
|
|
timeout=mode_manager.server["timeout"],
|
|
),
|
|
"rvc": requests.get(
|
|
mode_manager.get_api_url("rvcvoices"),
|
|
timeout=mode_manager.server["timeout"],
|
|
),
|
|
"settings": requests.get(
|
|
mode_manager.get_api_url("currentsettings"),
|
|
timeout=mode_manager.server["timeout"],
|
|
),
|
|
}
|
|
|
|
# Check if all responses are successful
|
|
if all(response.status_code == 200 for response in api_calls.values()):
|
|
try:
|
|
voices_data = api_calls["voices"].json()
|
|
rvcvoices_data = api_calls["rvc"].json()
|
|
settings_data = api_calls["settings"].json()
|
|
|
|
# Update global variables
|
|
models_available = [
|
|
model["name"] for model in settings_data["models_available"]
|
|
]
|
|
current_model_loaded = settings_data["current_model_loaded"]
|
|
|
|
# Update our local config with received values
|
|
if mode_manager.is_local:
|
|
mode_manager.config["tgwui"].update(
|
|
{
|
|
"tgwui_character_voice": (
|
|
voices_data["voices"][0]
|
|
if voices_data["voices"]
|
|
else "Please Refresh Settings"
|
|
),
|
|
"tgwui_narrator_voice": (
|
|
voices_data["voices"][0]
|
|
if voices_data["voices"]
|
|
else "Please Refresh Settings"
|
|
),
|
|
"tgwui_rvc_char_voice": (
|
|
rvcvoices_data["rvcvoices"][0]
|
|
if rvcvoices_data["rvcvoices"]
|
|
else "Disabled"
|
|
),
|
|
"tgwui_rvc_narr_voice": (
|
|
rvcvoices_data["rvcvoices"][0]
|
|
if rvcvoices_data["rvcvoices"]
|
|
else "Disabled"
|
|
),
|
|
}
|
|
)
|
|
|
|
return AllTalkServerSettings.from_api_response(
|
|
voices_data, rvcvoices_data, settings_data
|
|
)
|
|
except json.JSONDecodeError as e:
|
|
log_error(f"Failed to decode JSON response: {e}")
|
|
return AllTalkServerSettings()
|
|
else:
|
|
# Log specific failures
|
|
log_error(f"Failed to retrieve {mode_manager.branding}settings from API.")
|
|
for name, response in api_calls.items():
|
|
if response.status_code != 200:
|
|
log_error(
|
|
f"Failed to retrieve {name} from API", response.status_code
|
|
)
|
|
return AllTalkServerSettings()
|
|
|
|
except (RequestException, ConnectionError) as e:
|
|
log_error(f"Unable to connect to the {mode_manager.branding}server", str(e))
|
|
return AllTalkServerSettings()
|
|
|
|
|
|
class AllTalkServerSettings:
|
|
"""Represents and manages settings for the AllTalk server."""
|
|
|
|
def __init__(self):
|
|
"""Initializes the TGWUIModeManager with default settings and server connection."""
|
|
self.voices = ["Please Refresh Settings"]
|
|
self.rvcvoices = ["Please Refresh Settings"]
|
|
self.models_available = ["Please Refresh Settings"]
|
|
self.current_model_loaded = "Please Refresh Settings"
|
|
self.manufacturer_name = ""
|
|
|
|
# Engine capabilities
|
|
self.deepspeed_capable = False
|
|
self.deepspeed_available = False
|
|
self.deepspeed_enabled = False
|
|
self.languages_capable = False
|
|
self.multivoice_capable = False
|
|
self.multimodel_capable = False
|
|
self.streaming_capable = False
|
|
self.ttsengines_installed = False
|
|
|
|
# Generation settings
|
|
self.generationspeed_capable = False
|
|
self.generationspeed_set = 1.0
|
|
self.lowvram_capable = False
|
|
self.lowvram_enabled = False
|
|
self.pitch_capable = False
|
|
self.pitch_set = 0
|
|
self.repetitionpenalty_capable = False
|
|
self.repetitionpenalty_set = 10.0
|
|
self.temperature_capable = False
|
|
self.temperature_set = 0.75
|
|
|
|
@classmethod
|
|
def from_api_response(cls, voices_data, rvcvoices_data, settings_data):
|
|
"""Creates an AllTalkServerSettings instance from API response data."""
|
|
debug_func_entry()
|
|
if mode_manager.debug_func:
|
|
print_func(
|
|
"Function entry",
|
|
"debug",
|
|
debug_type=inspect.currentframe().f_code.co_name,
|
|
)
|
|
settings = cls()
|
|
|
|
# Update voice and model information
|
|
settings.voices = sorted(voices_data["voices"])
|
|
settings.rvcvoices = rvcvoices_data["rvcvoices"]
|
|
settings.models_available = [
|
|
model["name"] for model in settings_data["models_available"]
|
|
]
|
|
settings.current_model_loaded = settings_data["current_model_loaded"]
|
|
settings.manufacturer_name = settings_data.get("manufacturer_name", "")
|
|
|
|
# Update capabilities and settings
|
|
settings_mapping = {
|
|
# Capabilities
|
|
"deepspeed_capable": ("deepspeed_capable", False),
|
|
"deepspeed_available": ("deepspeed_available", False),
|
|
"deepspeed_enabled": ("deepspeed_enabled", False),
|
|
"languages_capable": ("languages_capable", False),
|
|
"multivoice_capable": ("multivoice_capable", False),
|
|
"multimodel_capable": ("multimodel_capable", False),
|
|
"streaming_capable": ("streaming_capable", False),
|
|
"ttsengines_installed": ("ttsengines_installed", False),
|
|
# Generation settings
|
|
"generationspeed_capable": ("generationspeed_capable", False),
|
|
"generationspeed_set": ("generationspeed_set", 1.0),
|
|
"lowvram_capable": ("lowvram_capable", False),
|
|
"lowvram_enabled": ("lowvram_enabled", False),
|
|
"pitch_capable": ("pitch_capable", False),
|
|
"pitch_set": ("pitch_enabled", 0),
|
|
"repetitionpenalty_capable": ("repetitionpenalty_capable", False),
|
|
"repetitionpenalty_set": ("repetitionpenalty_set", 10.0),
|
|
"temperature_capable": ("temperature_capable", False),
|
|
"temperature_set": ("temperature_set", 0.75),
|
|
}
|
|
|
|
# Update all settings from the mapping
|
|
for attr, (key, default) in settings_mapping.items():
|
|
setattr(settings, attr, settings_data.get(key, default))
|
|
|
|
return settings
|
|
|
|
|
|
# Print Spashscreen to console if running as Remote Extension
|
|
# pylint: disable=line-too-long,anomalous-backslash-in-string
|
|
if not mode_manager.is_local:
|
|
print_func(
|
|
"\033[94m _ _ _ \033[1;35m_____ _ _ \033[0m _____ _____ ____ "
|
|
) # pylint: disable=line-too-long anomalous-backslash-in-string
|
|
print_func(
|
|
"\033[94m / \ | | |\033[1;35m_ _|_ _| | | __ \033[0m |_ _|_ _/ ___| "
|
|
) # pylint: disable=line-too-long anomalous-backslash-in-string
|
|
print_func(
|
|
"\033[94m / _ \ | | |\033[1;35m | |/ _` | | |/ / \033[0m | | | | \___ \ "
|
|
) # pylint: disable=line-too-long anomalous-backslash-in-string
|
|
print_func(
|
|
"\033[94m / ___ \| | |\033[1;35m | | (_| | | < \033[0m | | | | ___) |"
|
|
) # pylint: disable=line-too-long anomalous-backslash-in-string
|
|
print_func(
|
|
"\033[94m /_/ \_\_|_|\033[1;35m |_|\__,_|_|_|\_\ \033[0m |_| |_| |____/ "
|
|
) # pylint: disable=line-too-long anomalous-backslash-in-string
|
|
print_func("")
|
|
print_func(
|
|
f"\033[92m{mode_manager.branding}startup Mode : \033[93mText-Gen-webui Remote\033[0m"
|
|
)
|
|
print_func("")
|
|
# pylint: enable=line-too-long,anomalous-backslash-in-string
|
|
|
|
def stop_generate_tts():
|
|
"""Sends request to stop current TTS generation"""
|
|
debug_func_entry()
|
|
api_url = mode_manager.get_api_url("stop-generation")
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
"Attempting to stop TTS generation",
|
|
message_type="debug",
|
|
debug_type="stop_generate_tts",
|
|
)
|
|
|
|
try:
|
|
response = requests.put(api_url, timeout=mode_manager.server["timeout"])
|
|
if response.status_code == 200:
|
|
return response.json()["message"]
|
|
else:
|
|
print_func(
|
|
f"Failed to stop generation. Status code:\n{response.status_code}",
|
|
message_type="warning",
|
|
)
|
|
return {"message": "Failed to stop generation"}
|
|
except (RequestException, ConnectionError) as e:
|
|
print_func(
|
|
f"Unable to connect to the {mode_manager.branding}server. Status code:\n{str(e)}",
|
|
message_type="warning",
|
|
)
|
|
return {"message": "Failed to stop generation"}
|
|
|
|
|
|
def send_reload_request(value_sent):
|
|
"""Requests AllTalk server to load a different TTS model"""
|
|
debug_func_entry()
|
|
global tts_model_loaded
|
|
if not process_lock.acquire(blocking=False):
|
|
return {
|
|
"status": "error",
|
|
"message": "Server is currently busy. Try again in a few seconds.",
|
|
}
|
|
try:
|
|
tts_model_loaded = False
|
|
url = mode_manager.get_api_url("reload")
|
|
payload = {"tts_method": value_sent}
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Requesting model reload to: {value_sent}",
|
|
message_type="debug",
|
|
debug_type="send_reload_request",
|
|
)
|
|
|
|
response = requests.post(url, params=payload)
|
|
response.raise_for_status()
|
|
tts_model_loaded = True
|
|
except requests.exceptions.RequestException as e:
|
|
print_func(
|
|
f"Error during request to webserver process: Status code:\n{e}",
|
|
message_type="warning",
|
|
)
|
|
tts_model_loaded = True
|
|
return {"status": "error", "message": str(e)}
|
|
finally:
|
|
process_lock.release()
|
|
|
|
|
|
def send_lowvram_request(value_sent):
|
|
"""Toggles low VRAM mode in AllTalk server"""
|
|
debug_func_entry()
|
|
global tts_model_loaded
|
|
if not process_lock.acquire(blocking=False):
|
|
return {
|
|
"status": "error",
|
|
"message": "Server is currently busy. Try again in a few seconds.",
|
|
}
|
|
try:
|
|
tts_model_loaded = False
|
|
audio_path = this_dir / (
|
|
"lowvramenabled.wav" if value_sent else "lowvramdisabled.wav"
|
|
)
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Setting low VRAM mode to: {value_sent}",
|
|
message_type="debug",
|
|
debug_type="send_lowvram_request",
|
|
)
|
|
|
|
url = mode_manager.get_api_url(
|
|
f"lowvramsetting?new_low_vram_value={value_sent}"
|
|
)
|
|
response = requests.post(url, headers={"Content-Type": "application/json"})
|
|
response.raise_for_status()
|
|
|
|
json_response = response.json()
|
|
if json_response.get("status") == "lowvram-success":
|
|
tts_model_loaded = True
|
|
|
|
return f'<audio src="file/{audio_path}" controls autoplay></audio>'
|
|
except requests.exceptions.RequestException as e:
|
|
print_func(
|
|
f"Error during request to webserver process: Status code:\n{e}",
|
|
message_type="warning",
|
|
)
|
|
return {"status": "error", "message": str(e)}
|
|
finally:
|
|
process_lock.release()
|
|
|
|
|
|
def send_deepspeed_request(value_sent):
|
|
"""Toggles DeepSpeed acceleration in AllTalk server"""
|
|
debug_func_entry()
|
|
global tts_model_loaded
|
|
if not process_lock.acquire(blocking=False):
|
|
return {
|
|
"status": "error",
|
|
"message": "Server is currently busy. Try again in a few seconds.",
|
|
}
|
|
try:
|
|
tts_model_loaded = False
|
|
audio_path = this_dir / (
|
|
"deepspeedenabled.wav" if value_sent else "deepspeeddisabled.wav"
|
|
)
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Setting DeepSpeed to: {value_sent}",
|
|
message_type="debug",
|
|
debug_type="send_deepspeed_request",
|
|
)
|
|
|
|
url = mode_manager.get_api_url(f"deepspeed?new_deepspeed_value={value_sent}")
|
|
response = requests.post(url, headers={"Content-Type": "application/json"})
|
|
response.raise_for_status()
|
|
|
|
json_response = response.json()
|
|
if json_response.get("status") == "deepspeed-success":
|
|
tts_model_loaded = True
|
|
|
|
process_lock.release()
|
|
return f'<audio src="file/{audio_path}" controls autoplay></audio>'
|
|
except requests.exceptions.RequestException as e:
|
|
print_func(
|
|
f"Error during request to webserver process: Status code:\n{e}",
|
|
message_type="warning",
|
|
)
|
|
return {"status": "error", "message": str(e)}
|
|
finally:
|
|
process_lock.release()
|
|
|
|
|
|
def send_and_generate(
|
|
gen_text,
|
|
gen_character_voice,
|
|
gen_rvccharacter_voice,
|
|
gen_rvccharacter_pitch,
|
|
gen_narrator_voice,
|
|
gen_rvcnarrator_voice,
|
|
gen_rvcnarrator_pitch,
|
|
gen_narrator_activated,
|
|
gen_textnotinisde,
|
|
gen_repetition,
|
|
gen_language,
|
|
gen_filter,
|
|
gen_speed,
|
|
gen_pitch,
|
|
gen_autoplay,
|
|
gen_autoplay_vol,
|
|
gen_file_name,
|
|
gen_temperature,
|
|
gen_filetimestamp,
|
|
gen_stream,
|
|
gen_stopcurrentgen,
|
|
):
|
|
"""Sends text to AllTalk server for TTS generation"""
|
|
debug_func_entry()
|
|
api_url = mode_manager.get_api_url("tts-generate")
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
"Starting TTS generation request",
|
|
message_type="debug",
|
|
debug_type="send_and_generate",
|
|
)
|
|
|
|
if gen_stopcurrentgen:
|
|
stop_generate_tts()
|
|
|
|
mode_manager.save_settings()
|
|
|
|
if gen_stream == "true":
|
|
api_url = mode_manager.get_api_url("tts-generate-streaming")
|
|
encoded_text = requests.utils.quote(gen_text)
|
|
streaming_url = f"{api_url}?text={encoded_text}&voice={gen_character_voice}&language={gen_language}&output_file={gen_file_name}"
|
|
return streaming_url, str("TTS Streaming Audio Generated")
|
|
|
|
data = {
|
|
"text_input": gen_text[0] if isinstance(gen_text, tuple) else gen_text,
|
|
"text_filtering": gen_filter,
|
|
"character_voice_gen": gen_character_voice,
|
|
"rvccharacter_voice_gen": gen_rvccharacter_voice,
|
|
"rvccharacter_pitch": gen_rvccharacter_pitch,
|
|
"narrator_enabled": str(gen_narrator_activated).lower(),
|
|
"narrator_voice_gen": gen_narrator_voice,
|
|
"rvcnarrator_voice_gen": gen_rvcnarrator_voice,
|
|
"rvcnarrator_pitch": gen_rvcnarrator_pitch,
|
|
"text_not_inside": gen_textnotinisde,
|
|
"language": gen_language,
|
|
"output_file_name": str(gen_file_name),
|
|
"output_file_timestamp": str(gen_filetimestamp).lower(),
|
|
"autoplay": str(gen_autoplay).lower(),
|
|
"autoplay_volume": str(gen_autoplay_vol),
|
|
"speed": str(gen_speed),
|
|
"pitch": str(gen_pitch),
|
|
"temperature": str(gen_temperature),
|
|
"repetition_penalty": str(gen_repetition),
|
|
}
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
"Generation request parameters:",
|
|
message_type="debug",
|
|
debug_type="send_and_generate",
|
|
)
|
|
for key, value in data.items():
|
|
print_func(
|
|
f"{key}: {value}", message_type="debug", debug_type="send_and_generate"
|
|
)
|
|
|
|
try:
|
|
response = requests.post(api_url, data=data)
|
|
response.raise_for_status()
|
|
result = response.json()
|
|
|
|
if gen_autoplay == "true":
|
|
return None, str("TTS Audio Generated (Played remotely)")
|
|
|
|
if mode_manager.config["remote_connection"]["use_legacy_api"]:
|
|
return result["output_file_url"], str("TTS Audio Generated")
|
|
else:
|
|
output_file_url = f"{mode_manager.server_url}{result['output_file_url']}"
|
|
return output_file_url, str("TTS Audio Generated")
|
|
except (RequestException, ConnectionError) as e:
|
|
print_func(
|
|
f"Error occurred during the API request: Status code:\n{str(e)}",
|
|
message_type="warning",
|
|
)
|
|
return None, str("Error occurred during the API request")
|
|
|
|
|
|
def output_modifier(string, state):
|
|
"""Modifies TGWUI output to include TTS audio"""
|
|
debug_func_entry()
|
|
|
|
# Input validation
|
|
if string is None:
|
|
print_func("Error: Received no text input from TGWUI so cannot generate TTS.", message_type="error")
|
|
print_func(f"Input text first 100 char's: {string[:100]}...", message_type="error")
|
|
return string
|
|
|
|
if not mode_manager.config["tgwui"]["tgwui_activate_tts"]:
|
|
return string
|
|
|
|
# Store original string before any processing
|
|
original_string = string
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
"Processing text for TTS generation",
|
|
message_type="debug",
|
|
debug_type="output_modifier",
|
|
)
|
|
|
|
# Strip out Images so only TTS is sent to the TTS engine
|
|
cleaned_text = tgwui_extract_and_remove_images(string)
|
|
if cleaned_text is None:
|
|
print_func("Error: Image processing resulted in no text to generate TTS", message_type="error")
|
|
print_func(f"Input text first 100 char's: {cleaned_text[:100]}...", message_type="error")
|
|
return string
|
|
|
|
# Get current settings
|
|
language_code = languages.get(mode_manager.config["tgwui"]["tgwui_language"])
|
|
character_voice = mode_manager.config["tgwui"]["tgwui_character_voice"]
|
|
rvc_character_voice = mode_manager.config["tgwui"]["tgwui_rvc_char_voice"]
|
|
rvc_character_pitch = mode_manager.config["tgwui"]["tgwui_rvc_char_pitch"]
|
|
narrator_voice = mode_manager.config["tgwui"]["tgwui_narrator_voice"]
|
|
rvc_narrator_voice = mode_manager.config["tgwui"]["tgwui_rvc_narr_voice"]
|
|
rvc_narrator_pitch = mode_manager.config["tgwui"]["tgwui_rvc_narr_pitch"]
|
|
narrator_enabled = mode_manager.config["tgwui"]["tgwui_narrator_enabled"]
|
|
text_not_inside = mode_manager.config["tgwui"]["tgwui_non_quoted_text_is"]
|
|
repetition_policy = mode_manager.config["tgwui"]["tgwui_repetitionpenalty_set"]
|
|
speed = mode_manager.config["tgwui"]["tgwui_generationspeed_set"]
|
|
pitch = mode_manager.config["tgwui"]["tgwui_pitch_set"]
|
|
temperature = mode_manager.config["tgwui"]["tgwui_temperature_set"]
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Using character voice: {character_voice}, narrator voice: {narrator_voice}",
|
|
message_type="debug",
|
|
debug_type="output_modifier",
|
|
)
|
|
print_func(
|
|
f"Text length: {len(cleaned_text)} characters",
|
|
message_type="debug",
|
|
debug_type="output_modifier",
|
|
)
|
|
|
|
# Lock and process TTS request
|
|
if process_lock.acquire(blocking=False):
|
|
try:
|
|
output_file = (state["character_menu"] if "character_menu" in state else str("TTSOUT_"))
|
|
output_file = (state["character_menu"] if "character_menu" in state and state["character_menu"] is not None else "TTSOUT_")
|
|
output_file = sanitize_windows_filename(output_file) # Ensure filenames dont hit any Windows file name limits
|
|
|
|
generate_response, status_message = send_and_generate(
|
|
cleaned_text,
|
|
character_voice,
|
|
rvc_character_voice,
|
|
rvc_character_pitch,
|
|
narrator_voice,
|
|
rvc_narrator_voice,
|
|
rvc_narrator_pitch,
|
|
narrator_enabled,
|
|
text_not_inside,
|
|
repetition_policy,
|
|
language_code,
|
|
"html",
|
|
speed,
|
|
pitch,
|
|
False,
|
|
0.8,
|
|
output_file,
|
|
temperature,
|
|
True,
|
|
False,
|
|
False,
|
|
)
|
|
|
|
if status_message == "TTS Audio Generated":
|
|
autoplay = (
|
|
"autoplay"
|
|
if mode_manager.config["tgwui"]["tgwui_autoplay_tts"]
|
|
else ""
|
|
)
|
|
string = (
|
|
f'<audio src="{generate_response}" controls {autoplay}></audio>'
|
|
)
|
|
|
|
if mode_manager.config["tgwui"]["tgwui_show_text"]:
|
|
string += f'\n\n{original_string}' # Use original_string
|
|
|
|
if string is None:
|
|
print_func("Error: Final processed text is None after image reinsertion", message_type="error")
|
|
print_func(f"Input text first 100 char's: {string[:100]}...", message_type="error")
|
|
return string
|
|
|
|
shared.processing_message = "*Is typing...*"
|
|
return string
|
|
else:
|
|
print_func(
|
|
f"Audio generation failed. Status code:\n{status_message}",
|
|
message_type="warning",
|
|
)
|
|
finally:
|
|
process_lock.release()
|
|
else:
|
|
print_func(
|
|
"Audio generation is already in progress. Please wait.",
|
|
message_type="warning",
|
|
)
|
|
return
|
|
|
|
img_pattern = r'<img[^>]*src\s*=\s*["\'][^"\'>]+["\'][^>]*>'
|
|
|
|
def tgwui_extract_and_remove_images(text):
|
|
"""Extracts and removes image tags from text for clean TTS processing"""
|
|
debug_func_entry()
|
|
cleaned_text = re.sub(img_pattern, "", text)
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Found {len(re.findall(img_pattern, text))} images in text",
|
|
message_type="debug",
|
|
debug_type="extract_images",
|
|
)
|
|
|
|
return cleaned_text # Just return the cleaned text
|
|
|
|
def sanitize_windows_filename(original_name):
|
|
# First conversion
|
|
filename = original_name.replace(" ", "_")
|
|
# Remove invalid characters
|
|
filename = re.sub(r'[^a-zA-Z0-9_]', '', filename)
|
|
|
|
# Check for Windows reserved names
|
|
reserved = ['CON', 'PRN', 'AUX', 'NUL', 'COM1', 'COM2', 'COM3', 'COM4',
|
|
'COM5', 'COM6', 'COM7', 'COM8', 'COM9', 'LPT1', 'LPT2',
|
|
'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9']
|
|
|
|
if filename.upper() in reserved:
|
|
filename = f"_{filename}"
|
|
|
|
# Use TTSOUT_ if empty
|
|
filename = filename or "TTSOUT_"
|
|
|
|
# Print if changes were made
|
|
if original_name != filename:
|
|
print_func(f"Character name '{original_name}' contained special characters - sanitized to '{filename}'", message_type="warning")
|
|
|
|
return filename
|
|
|
|
def voice_preview(string):
|
|
"""Generates a preview of the selected voice settings"""
|
|
# debug_func_entry()
|
|
print("in voice preview function")
|
|
if not mode_manager.config["tgwui"]["tgwui_activate_tts"]:
|
|
return string
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
"Generating voice preview", message_type="debug", debug_type="voice_preview"
|
|
)
|
|
|
|
language_code = languages.get(mode_manager.config["tgwui"]["tgwui_language"])
|
|
if not string:
|
|
string = random_sentence()
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Preview text: {string}", message_type="debug", debug_type="voice_preview"
|
|
)
|
|
|
|
generate_response, status_message = send_and_generate(
|
|
string,
|
|
mode_manager.config["tgwui"]["tgwui_character_voice"],
|
|
mode_manager.config["tgwui"]["tgwui_rvc_char_voice"],
|
|
mode_manager.config["tgwui"]["tgwui_rvc_char_pitch"],
|
|
mode_manager.config["tgwui"]["tgwui_narrator_voice"],
|
|
mode_manager.config["tgwui"]["tgwui_rvc_narr_voice"],
|
|
mode_manager.config["tgwui"]["tgwui_rvc_narr_pitch"],
|
|
False,
|
|
"character",
|
|
mode_manager.config["tgwui"]["tgwui_repetitionpenalty_set"],
|
|
language_code,
|
|
"standard",
|
|
mode_manager.config["tgwui"]["tgwui_generationspeed_set"],
|
|
mode_manager.config["tgwui"]["tgwui_pitch_set"],
|
|
False,
|
|
0.8,
|
|
"previewvoice",
|
|
mode_manager.config["tgwui"]["tgwui_temperature_set"],
|
|
False,
|
|
False,
|
|
False,
|
|
)
|
|
|
|
if status_message == "TTS Audio Generated":
|
|
autoplay = (
|
|
"autoplay" if mode_manager.config["tgwui"]["tgwui_autoplay_tts"] else ""
|
|
)
|
|
return f'<audio src="{generate_response}?{int(time.time())}" controls {autoplay}></audio>'
|
|
else:
|
|
return f"[{mode_manager.branding}Server] Audio generation failed. Status code:\n{status_message}"
|
|
|
|
|
|
################################################################
|
|
# TGWUI # Used to generate a preview voice sample within TGWUI #
|
|
################################################################
|
|
|
|
|
|
def random_sentence():
|
|
"""Returns a random sentence from Harvard sentences file for voice preview"""
|
|
debug_func_entry()
|
|
with open(this_dir / "harvard_sentences.txt") as f:
|
|
return random.choice(list(f)).rstrip()
|
|
|
|
|
|
###################################################################
|
|
# TGWUI # Used to inform TGWUI that TTS is disabled/not activated #
|
|
###################################################################
|
|
|
|
|
|
def state_modifier(state):
|
|
"""Modifies TGWUI state to disable streaming when TTS is active"""
|
|
debug_func_entry()
|
|
if not mode_manager.config["tgwui"]["tgwui_activate_tts"]:
|
|
return state
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
"Disabling streaming for TTS",
|
|
message_type="debug",
|
|
debug_type="state_modifier",
|
|
)
|
|
|
|
state["stream"] = False
|
|
return state
|
|
|
|
|
|
###################################################################
|
|
# TGWUI # Sends message to TGWUI interface during TTS generation #
|
|
###################################################################
|
|
|
|
|
|
def input_modifier(string, state):
|
|
"""Updates TGWUI interface message during TTS processing"""
|
|
debug_func_entry()
|
|
if not mode_manager.config["tgwui"]["tgwui_activate_tts"]:
|
|
return string
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
"Setting processing message for TTS",
|
|
message_type="debug",
|
|
debug_type="input_modifier",
|
|
)
|
|
|
|
shared.processing_message = "*Is recording a voice message...*"
|
|
return string
|
|
|
|
|
|
########################################################################
|
|
# TGWUI # Used to delete historic TTS audios from TGWUI chat interface #
|
|
########################################################################
|
|
|
|
|
|
def remove_tts_from_history(history):
|
|
"""Removes audio from the chat with TGWUI's chat interface"""
|
|
debug_func_entry()
|
|
for i, entry in enumerate(history["internal"]):
|
|
history["visible"][i] = [history["visible"][i][0], entry[1]]
|
|
return history
|
|
|
|
|
|
def toggle_text_in_history(history):
|
|
"""Hides text from the chat with TGWUI's chat interface"""
|
|
debug_func_entry()
|
|
for i, entry in enumerate(history["visible"]):
|
|
visible_reply = entry[1]
|
|
if visible_reply.startswith("<audio"):
|
|
if mode_manager.config["tgwui"]["tgwui_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):
|
|
"""Controls/Enables autoplay of TTS in TGWUI interface"""
|
|
debug_func_entry()
|
|
# 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
|
|
|
|
|
|
def tgwui_update_alltalk_protocol(value_sent):
|
|
"""Updates the server protocol setting"""
|
|
debug_func_entry()
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Updating server protocol to: {value_sent}",
|
|
message_type="debug",
|
|
debug_type="update_protocol",
|
|
)
|
|
mode_manager.server["protocol"] = value_sent
|
|
|
|
|
|
def tgwui_update_alltalk_ip_port(value_sent):
|
|
"""Updates the server address settings"""
|
|
debug_func_entry()
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Updating server address to: {value_sent}",
|
|
message_type="debug",
|
|
debug_type="update_ip_port",
|
|
)
|
|
mode_manager.server["address"] = value_sent
|
|
|
|
|
|
def tgwui_handle_ttsmodel_dropdown_change(model_name):
|
|
"""Handles model changes from Gradio dropdown, with debounce protection"""
|
|
debug_func_entry()
|
|
if not getattr(tgwui_handle_ttsmodel_dropdown_change, "skip_reload", False):
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Switching model to: {model_name}",
|
|
message_type="debug",
|
|
debug_type="model_change",
|
|
)
|
|
send_reload_request(model_name)
|
|
else:
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
"Skipping model reload (debounced)",
|
|
message_type="debug",
|
|
debug_type="model_change",
|
|
)
|
|
tgwui_handle_ttsmodel_dropdown_change.skip_reload = False
|
|
|
|
|
|
def tgwui_update_dropdowns():
|
|
"""Updates all Gradio dropdowns with current server settings"""
|
|
debug_func_entry()
|
|
global at_settings
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
"Refreshing server settings",
|
|
message_type="debug",
|
|
debug_type="update_dropdowns",
|
|
)
|
|
|
|
at_settings = get_alltalk_settings()
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Retrieved {len(at_settings.voices)} voices",
|
|
message_type="debug",
|
|
debug_type="update_dropdowns",
|
|
)
|
|
print_func(
|
|
f"Retrieved {len(at_settings.rvcvoices)} RVC voices",
|
|
message_type="debug",
|
|
debug_type="update_dropdowns",
|
|
)
|
|
print_func(
|
|
f"Current model: {at_settings.current_model_loaded}",
|
|
message_type="debug",
|
|
debug_type="update_dropdowns",
|
|
)
|
|
|
|
current_voices = at_settings.voices
|
|
rvccurrent_voices = at_settings.rvcvoices
|
|
rvccurrent_character_voice = mode_manager.config["tgwui"]["tgwui_rvc_char_voice"]
|
|
rvccurrent_character_pitch = mode_manager.config["tgwui"]["tgwui_rvc_char_pitch"]
|
|
rvccurrent_narrator_voice = mode_manager.config["tgwui"]["tgwui_rvc_char_voice"]
|
|
rvccurrent_narrator_pitch = mode_manager.config["tgwui"]["tgwui_rvc_char_pitch"]
|
|
current_models_available = sorted(at_settings.models_available)
|
|
current_model_loaded = at_settings.current_model_loaded
|
|
current_character_voice = mode_manager.config["tgwui"]["tgwui_character_voice"]
|
|
current_narrator_voice = mode_manager.config["tgwui"]["tgwui_narrator_voice"]
|
|
|
|
# Capability checks
|
|
current_lowvram_capable = at_settings.lowvram_capable
|
|
current_lowvram_enabled = at_settings.lowvram_enabled
|
|
current_temperature_capable = at_settings.temperature_capable
|
|
current_repetitionpenalty_capable = at_settings.repetitionpenalty_capable
|
|
current_generationspeed_capable = at_settings.generationspeed_capable
|
|
current_pitch_capable = at_settings.pitch_capable
|
|
current_deepspeed_capable = at_settings.deepspeed_capable
|
|
current_deepspeed_enabled = at_settings.deepspeed_enabled
|
|
current_non_quoted_text_is = mode_manager.config["tgwui"][
|
|
"tgwui_non_quoted_text_is"
|
|
]
|
|
current_languages_capable = at_settings.languages_capable
|
|
|
|
# Set appropriate labels based on capabilities
|
|
language_label = (
|
|
"Languages" if at_settings.languages_capable else "Model not multi language"
|
|
)
|
|
|
|
# Update voice selections if needed
|
|
if current_character_voice not in current_voices:
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Character voice {current_character_voice} not found, resetting",
|
|
message_type="debug",
|
|
debug_type="update_dropdowns",
|
|
)
|
|
current_character_voice = current_voices[0] if current_voices else ""
|
|
mode_manager.config["tgwui"]["tgwui_character_voice"] = current_character_voice
|
|
|
|
if current_narrator_voice not in current_voices:
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"Narrator voice {current_narrator_voice} not found, resetting",
|
|
message_type="debug",
|
|
debug_type="update_dropdowns",
|
|
)
|
|
current_narrator_voice = current_voices[0] if current_voices else ""
|
|
mode_manager.config["tgwui"]["tgwui_narrator_voice"] = current_narrator_voice
|
|
|
|
# Update RVC voice selections if needed
|
|
if rvccurrent_character_voice not in rvccurrent_voices:
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"RVC character voice {rvccurrent_character_voice} not found, resetting",
|
|
message_type="debug",
|
|
debug_type="update_dropdowns",
|
|
)
|
|
rvccurrent_character_voice = rvccurrent_voices[0] if rvccurrent_voices else ""
|
|
mode_manager.config["tgwui"][
|
|
"tgwui_rvc_char_voice"
|
|
] = rvccurrent_character_voice
|
|
|
|
if rvccurrent_narrator_voice not in rvccurrent_voices:
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
f"RVC narrator voice {rvccurrent_narrator_voice} not found, resetting",
|
|
message_type="debug",
|
|
debug_type="update_dropdowns",
|
|
)
|
|
rvccurrent_narrator_voice = rvccurrent_voices[0] if rvccurrent_voices else ""
|
|
mode_manager.config["tgwui"]["tgwui_rvc_char_voice"] = rvccurrent_narrator_voice
|
|
|
|
rvccurrent_character_pitch = (
|
|
rvccurrent_character_pitch if rvccurrent_character_pitch else 0
|
|
)
|
|
rvccurrent_narrator_pitch = (
|
|
rvccurrent_narrator_pitch if rvccurrent_narrator_pitch else 0
|
|
)
|
|
|
|
# Prevent model reload during update
|
|
tgwui_handle_ttsmodel_dropdown_change.skip_reload = True
|
|
|
|
# Return updated Gradio components
|
|
return_values = [
|
|
gr.Checkbox(interactive=current_lowvram_capable, value=current_lowvram_enabled),
|
|
gr.Checkbox(
|
|
interactive=current_deepspeed_capable, value=current_deepspeed_enabled
|
|
),
|
|
gr.Dropdown(choices=current_voices, value=current_character_voice),
|
|
gr.Dropdown(
|
|
choices=rvccurrent_voices,
|
|
value=rvccurrent_character_voice,
|
|
interactive=True,
|
|
),
|
|
gr.Slider(value=rvccurrent_character_pitch),
|
|
gr.Dropdown(choices=current_voices, value=current_narrator_voice),
|
|
gr.Dropdown(
|
|
choices=rvccurrent_voices, value=rvccurrent_narrator_voice, interactive=True
|
|
),
|
|
gr.Slider(value=rvccurrent_narrator_pitch),
|
|
gr.Dropdown(choices=current_models_available, value=current_model_loaded),
|
|
gr.Dropdown(interactive=current_temperature_capable),
|
|
gr.Dropdown(interactive=current_repetitionpenalty_capable),
|
|
gr.Dropdown(interactive=current_languages_capable, label=language_label),
|
|
gr.Dropdown(interactive=current_generationspeed_capable),
|
|
gr.Dropdown(interactive=current_pitch_capable),
|
|
gr.Dropdown(value=current_non_quoted_text_is),
|
|
]
|
|
|
|
def reset_skip_reload():
|
|
tgwui_handle_ttsmodel_dropdown_change.skip_reload = False
|
|
|
|
threading.Timer(0.5, reset_skip_reload).start()
|
|
|
|
return return_values
|
|
|
|
|
|
def ui():
|
|
"""Creates the TGWUI Gradio interface"""
|
|
global alltalk_settings
|
|
|
|
if mode_manager.debug_tgwui:
|
|
print_func(
|
|
"Initializing TGWUI interface", message_type="debug", debug_type="ui"
|
|
)
|
|
|
|
alltalk_settings = get_alltalk_settings()
|
|
|
|
with gr.Accordion(mode_manager.branding + " TTS (Text-gen-webui Remote)"):
|
|
tgwui_available_voices_gr = alltalk_settings.voices
|
|
tgwui_rvc_available_voices_gr = alltalk_settings.rvcvoices
|
|
|
|
# Activate alltalk_tts, Enable autoplay, Show text
|
|
with gr.Row():
|
|
tgwui_activate_tts_gr = gr.Checkbox(
|
|
value=mode_manager.config["tgwui"]["tgwui_activate_tts"],
|
|
label="Enable TGWUI TTS",
|
|
)
|
|
tgwui_autoplay_gr = gr.Checkbox(
|
|
value=mode_manager.config["tgwui"]["tgwui_autoplay_tts"],
|
|
label="Autoplay TTS Generated",
|
|
)
|
|
tgwui_show_text_gr = gr.Checkbox(
|
|
value=mode_manager.config["tgwui"]["tgwui_show_text"],
|
|
label="Show Text in chat",
|
|
)
|
|
|
|
# Low vram enable, Deepspeed enable, Link
|
|
with gr.Row():
|
|
tgwui_lowvram_enabled_gr = gr.Checkbox(
|
|
value=(
|
|
alltalk_settings.lowvram_enabled
|
|
if alltalk_settings.lowvram_capable
|
|
else False
|
|
),
|
|
label="Enable Low VRAM Mode",
|
|
interactive=alltalk_settings.lowvram_capable,
|
|
)
|
|
tgwui_lowvram_enabled_play_gr = gr.HTML(visible=False)
|
|
|
|
tgwui_deepspeed_enabled_gr = gr.Checkbox(
|
|
value=mode_manager.config["tgwui"]["tgwui_deepspeed_enabled"],
|
|
label="Enable DeepSpeed",
|
|
interactive=alltalk_settings.deepspeed_capable,
|
|
)
|
|
tgwui_deepspeed_enabled_play_gr = gr.HTML(visible=False)
|
|
|
|
_tgwui_empty_space_gr = gr.HTML(
|
|
f"<p><a href='{mode_manager.server_url}'>AllTalk Server & Documentation Link</a></p>"
|
|
)
|
|
|
|
# Model, Language, Character voice
|
|
with gr.Row():
|
|
tgwui_tts_dropdown_gr = gr.Dropdown(
|
|
choices=models_available,
|
|
label="TTS Engine/Model",
|
|
value=current_model_loaded,
|
|
)
|
|
tgwui_language_gr = gr.Dropdown(
|
|
choices=languages.keys(),
|
|
label=(
|
|
"Languages"
|
|
if alltalk_settings.languages_capable
|
|
else "Model not multi language"
|
|
),
|
|
interactive=alltalk_settings.languages_capable,
|
|
value=mode_manager.config["tgwui"]["tgwui_language"],
|
|
)
|
|
tgwui_narrator_enabled_gr = gr.Dropdown(
|
|
choices=[
|
|
("Enabled", "true"),
|
|
("Disabled", "false"),
|
|
("Silent", "silent"),
|
|
],
|
|
label="Narrator Enable",
|
|
value=(
|
|
"true"
|
|
if mode_manager.config.get("tgwui_narrator_enabled") == "true"
|
|
else (
|
|
"silent"
|
|
if mode_manager.config.get("tgwui_narrator_enabled") == "silent"
|
|
else "false"
|
|
)
|
|
),
|
|
)
|
|
|
|
# Narrator voice settings
|
|
with gr.Row():
|
|
tgwui_default_voice_gr = mode_manager.config["tgwui"][
|
|
"tgwui_character_voice"
|
|
]
|
|
if tgwui_default_voice_gr not in tgwui_available_voices_gr:
|
|
tgwui_default_voice_gr = (
|
|
tgwui_available_voices_gr[0] if tgwui_available_voices_gr else ""
|
|
)
|
|
|
|
tgwui_character_voice_gr = gr.Dropdown(
|
|
choices=tgwui_available_voices_gr,
|
|
label="Character Voice",
|
|
value=tgwui_default_voice_gr,
|
|
allow_custom_value=True,
|
|
)
|
|
|
|
tgwui_narr_voice_gr = mode_manager.config["tgwui"]["tgwui_narrator_voice"]
|
|
if tgwui_narr_voice_gr not in tgwui_available_voices_gr:
|
|
tgwui_narr_voice_gr = (
|
|
tgwui_available_voices_gr[0] if tgwui_available_voices_gr else ""
|
|
)
|
|
|
|
tgwui_narrator_voice_gr = gr.Dropdown(
|
|
choices=tgwui_available_voices_gr,
|
|
label="Narrator Voice",
|
|
value=tgwui_narr_voice_gr,
|
|
allow_custom_value=True,
|
|
)
|
|
|
|
tgwui_non_quoted_text_is_gr = gr.Dropdown(
|
|
choices=[
|
|
("Character", "character"),
|
|
("Narrator", "narrator"),
|
|
("Silent", "silent"),
|
|
],
|
|
label="Narrator unmarked text is",
|
|
value=mode_manager.config.get("tgwui_non_quoted_text_is", "character"),
|
|
)
|
|
|
|
# RVC voices
|
|
with gr.Row():
|
|
tgwui_rvc_default_voice_gr = mode_manager.config["tgwui"][
|
|
"tgwui_rvc_char_voice"
|
|
]
|
|
tgwui_rvc_narrator_voice_gr = mode_manager.config["tgwui"][
|
|
"tgwui_rvc_narr_voice"
|
|
]
|
|
|
|
if tgwui_rvc_default_voice_gr not in tgwui_rvc_available_voices_gr:
|
|
tgwui_rvc_default_voice_gr = (
|
|
tgwui_rvc_available_voices_gr[0]
|
|
if tgwui_rvc_available_voices_gr
|
|
else ""
|
|
)
|
|
|
|
tgwui_rvc_char_voice_gr = gr.Dropdown(
|
|
choices=tgwui_rvc_available_voices_gr,
|
|
label="RVC Character Voice",
|
|
value=tgwui_rvc_default_voice_gr,
|
|
allow_custom_value=True,
|
|
)
|
|
|
|
if tgwui_rvc_narrator_voice_gr not in tgwui_rvc_available_voices_gr:
|
|
tgwui_rvc_narrator_voice_gr = (
|
|
tgwui_rvc_available_voices_gr[0]
|
|
if tgwui_rvc_available_voices_gr
|
|
else ""
|
|
)
|
|
|
|
tgwui_rvc_narr_voice_gr = gr.Dropdown(
|
|
choices=tgwui_rvc_available_voices_gr,
|
|
label="RVC Narrator Voice",
|
|
value=tgwui_rvc_narrator_voice_gr,
|
|
allow_custom_value=True,
|
|
)
|
|
|
|
# RVC pitch control
|
|
with gr.Row():
|
|
tgwui_rvc_char_pitch_gr = gr.Slider(
|
|
minimum=-24,
|
|
maximum=+24,
|
|
step=1,
|
|
label="RVC Character Pitch",
|
|
value=mode_manager.config["tgwui"]["tgwui_rvc_char_pitch"],
|
|
)
|
|
tgwui_rvc_narr_pitch_gr = gr.Slider(
|
|
minimum=-24,
|
|
maximum=+24,
|
|
step=1,
|
|
label="RVC Narrator Pitch",
|
|
value=mode_manager.config["tgwui"]["tgwui_rvc_narr_pitch"],
|
|
)
|
|
|
|
# Generation settings
|
|
with gr.Row():
|
|
tgwui_temperature_set_gr = gr.Slider(
|
|
minimum=0.05,
|
|
maximum=1,
|
|
step=0.05,
|
|
label="Temperature",
|
|
value=mode_manager.config["tgwui"]["tgwui_temperature_set"],
|
|
interactive=alltalk_settings.temperature_capable,
|
|
)
|
|
tgwui_repetitionpenalty_set_gr = gr.Slider(
|
|
minimum=0.5,
|
|
maximum=20,
|
|
step=0.5,
|
|
label="Repetition Penalty",
|
|
value=mode_manager.config["tgwui"]["tgwui_repetitionpenalty_set"],
|
|
interactive=alltalk_settings.repetitionpenalty_capable,
|
|
)
|
|
with gr.Row():
|
|
tgwui_generationspeed_set_gr = gr.Slider(
|
|
minimum=0.30,
|
|
maximum=2.00,
|
|
step=0.10,
|
|
label="TTS Speed",
|
|
value=mode_manager.config["tgwui"]["tgwui_generationspeed_set"],
|
|
interactive=alltalk_settings.generationspeed_capable,
|
|
)
|
|
tgwui_pitch_set_gr = gr.Slider(
|
|
minimum=-10,
|
|
maximum=10,
|
|
step=1,
|
|
label="Pitch",
|
|
value=mode_manager.config["tgwui"]["tgwui_pitch_set"],
|
|
interactive=alltalk_settings.pitch_capable,
|
|
)
|
|
|
|
# Preview section
|
|
with gr.Row():
|
|
tgwui_preview_text_gr = gr.Text(
|
|
show_label=False,
|
|
placeholder="Preview text",
|
|
elem_id="silero_preview_text",
|
|
scale=2,
|
|
)
|
|
tgwui_preview_play_gr = gr.Button("Generate Preview", scale=1)
|
|
tgwui_preview_audio_gr = gr.HTML(visible=False)
|
|
|
|
# Server connection settings (only shown in remote mode)
|
|
if not mode_manager.is_local:
|
|
with gr.Row():
|
|
tgwui_protocol_gr = gr.Dropdown(
|
|
choices=["http://", "https://"],
|
|
label="AllTalk Server Protocol",
|
|
value=mode_manager.server["protocol"],
|
|
)
|
|
tgwui_ip_address_port_gr = gr.Textbox(
|
|
label="AllTalk Server IP:Port", value=mode_manager.server["address"]
|
|
)
|
|
tgwui_refresh_settings_gr = gr.Button("Refresh settings & voices")
|
|
|
|
# Refresh settings button (only shown in local mode)
|
|
if mode_manager.is_local:
|
|
tgwui_refresh_settings_gr = gr.Button("Refresh settings & voices")
|
|
|
|
# Control buttons
|
|
with gr.Row():
|
|
tgwui_convert_gr = gr.Button(
|
|
"Remove old TTS audio and leave only message texts"
|
|
)
|
|
tgwui_convert_cancel_gr = gr.Button("Cancel", visible=False)
|
|
tgwui_convert_confirm_gr = gr.Button(
|
|
"Confirm (cannot be undone)", variant="stop", visible=False
|
|
)
|
|
tgwui_stop_generation_gr = gr.Button("Stop current TTS generation")
|
|
|
|
# Convert history with confirmation
|
|
convert_arr = [
|
|
tgwui_convert_confirm_gr,
|
|
tgwui_convert_gr,
|
|
tgwui_convert_cancel_gr,
|
|
]
|
|
|
|
tgwui_convert_gr.click(
|
|
lambda: [
|
|
gr.update(visible=True),
|
|
gr.update(visible=False),
|
|
gr.update(visible=True),
|
|
],
|
|
None,
|
|
convert_arr,
|
|
)
|
|
|
|
tgwui_convert_confirm_gr.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")
|
|
)
|
|
|
|
tgwui_convert_cancel_gr.click(
|
|
lambda: [
|
|
gr.update(visible=False),
|
|
gr.update(visible=True),
|
|
gr.update(visible=False),
|
|
],
|
|
None,
|
|
convert_arr,
|
|
)
|
|
|
|
# Toggle message text in history
|
|
tgwui_show_text_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_show_text": x}),
|
|
tgwui_show_text_gr,
|
|
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
|
|
tgwui_activate_tts_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_activate_tts": x}),
|
|
tgwui_activate_tts_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_autoplay_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_autoplay_tts": x}),
|
|
tgwui_autoplay_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_lowvram_enabled_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_lowvram_enabled": x}),
|
|
tgwui_lowvram_enabled_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_lowvram_enabled_gr.change(
|
|
lambda x: send_lowvram_request(x),
|
|
tgwui_lowvram_enabled_gr,
|
|
tgwui_lowvram_enabled_play_gr,
|
|
None,
|
|
)
|
|
|
|
# Model change handling
|
|
tgwui_tts_dropdown_gr.change(
|
|
tgwui_handle_ttsmodel_dropdown_change, tgwui_tts_dropdown_gr, None
|
|
)
|
|
|
|
# DeepSpeed settings
|
|
tgwui_deepspeed_enabled_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update(
|
|
{"tgwui_deepspeed_enabled": x}
|
|
),
|
|
tgwui_deepspeed_enabled_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_deepspeed_enabled_gr.change(
|
|
send_deepspeed_request,
|
|
tgwui_deepspeed_enabled_gr,
|
|
tgwui_deepspeed_enabled_play_gr,
|
|
None,
|
|
)
|
|
|
|
# Voice and language settings
|
|
tgwui_character_voice_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_character_voice": x}),
|
|
tgwui_character_voice_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_language_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_language": x}),
|
|
tgwui_language_gr,
|
|
None,
|
|
)
|
|
|
|
# TTS Settings
|
|
tgwui_temperature_set_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_temperature_set": x}),
|
|
tgwui_temperature_set_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_repetitionpenalty_set_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update(
|
|
{"tgwui_repetitionpenalty_set": x}
|
|
),
|
|
tgwui_repetitionpenalty_set_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_generationspeed_set_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update(
|
|
{"tgwui_generationspeed_set": x}
|
|
),
|
|
tgwui_generationspeed_set_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_pitch_set_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_pitch_set": x}),
|
|
tgwui_pitch_set_gr,
|
|
None,
|
|
)
|
|
|
|
# Narrator settings
|
|
tgwui_narrator_enabled_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update(
|
|
{"tgwui_narrator_enabled": x}
|
|
),
|
|
tgwui_narrator_enabled_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_non_quoted_text_is_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update(
|
|
{"tgwui_non_quoted_text_is": x}
|
|
),
|
|
tgwui_non_quoted_text_is_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_narrator_voice_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_narrator_voice": x}),
|
|
tgwui_narrator_voice_gr,
|
|
None,
|
|
)
|
|
|
|
# RVC selection actions
|
|
tgwui_rvc_char_voice_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_rvc_char_voice": x}),
|
|
tgwui_rvc_char_voice_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_rvc_narr_voice_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_rvc_narr_voice": x}),
|
|
tgwui_rvc_narr_voice_gr,
|
|
None,
|
|
)
|
|
tgwui_rvc_char_pitch_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_rvc_char_pitch": x}),
|
|
tgwui_rvc_char_pitch_gr,
|
|
None,
|
|
)
|
|
|
|
tgwui_rvc_narr_pitch_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_rvc_narr_pitch": x}),
|
|
tgwui_rvc_narr_pitch_gr,
|
|
None,
|
|
)
|
|
|
|
# Preview functionality
|
|
tgwui_preview_play_gr.click(
|
|
voice_preview,
|
|
tgwui_preview_text_gr,
|
|
tgwui_preview_audio_gr,
|
|
)
|
|
|
|
# Stop generation button
|
|
tgwui_stop_generation_gr.click(stop_generate_tts, None, None)
|
|
|
|
if not mode_manager.is_local:
|
|
# Remote-only handlers
|
|
tgwui_protocol_gr.change(
|
|
tgwui_update_alltalk_protocol, tgwui_protocol_gr, None
|
|
)
|
|
|
|
tgwui_ip_address_port_gr.change(
|
|
tgwui_update_alltalk_ip_port, tgwui_ip_address_port_gr, None
|
|
)
|
|
|
|
tgwui_refresh_settings_gr.click(
|
|
tgwui_update_dropdowns,
|
|
None,
|
|
[
|
|
tgwui_lowvram_enabled_gr,
|
|
tgwui_deepspeed_enabled_gr,
|
|
tgwui_character_voice_gr,
|
|
tgwui_rvc_char_voice_gr,
|
|
tgwui_rvc_char_pitch_gr,
|
|
tgwui_narrator_voice_gr,
|
|
tgwui_rvc_narr_voice_gr,
|
|
tgwui_rvc_narr_pitch_gr,
|
|
tgwui_tts_dropdown_gr,
|
|
tgwui_temperature_set_gr,
|
|
tgwui_repetitionpenalty_set_gr,
|
|
tgwui_language_gr,
|
|
tgwui_generationspeed_set_gr,
|
|
tgwui_pitch_set_gr,
|
|
tgwui_non_quoted_text_is_gr,
|
|
],
|
|
)
|
|
|
|
# Convert history with confirmation
|
|
convert_arr = [tgwui_convert_confirm_gr, tgwui_convert_gr, tgwui_convert_cancel_gr]
|
|
tgwui_convert_gr.click(
|
|
lambda: [
|
|
gr.update(visible=True),
|
|
gr.update(visible=False),
|
|
gr.update(visible=True),
|
|
],
|
|
None,
|
|
convert_arr,
|
|
)
|
|
tgwui_convert_confirm_gr.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")
|
|
)
|
|
tgwui_convert_cancel_gr.click(
|
|
lambda: [
|
|
gr.update(visible=False),
|
|
gr.update(visible=True),
|
|
gr.update(visible=False),
|
|
],
|
|
None,
|
|
convert_arr,
|
|
)
|
|
|
|
# Toggle message text in history
|
|
tgwui_show_text_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_show_text": x}),
|
|
tgwui_show_text_gr,
|
|
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
|
|
tgwui_activate_tts_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_activate_tts": x}),
|
|
tgwui_activate_tts_gr,
|
|
None,
|
|
)
|
|
tgwui_autoplay_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_autoplay_tts": x}),
|
|
tgwui_autoplay_gr,
|
|
None,
|
|
)
|
|
tgwui_lowvram_enabled_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_lowvram_enabled": x}),
|
|
tgwui_lowvram_enabled_gr,
|
|
None,
|
|
)
|
|
tgwui_lowvram_enabled_gr.change(
|
|
lambda x: send_lowvram_request(x),
|
|
tgwui_lowvram_enabled_gr,
|
|
tgwui_lowvram_enabled_play_gr,
|
|
None,
|
|
)
|
|
|
|
# Trigger the send_reload_request function when the dropdown value changes
|
|
tgwui_tts_dropdown_gr.change(
|
|
tgwui_handle_ttsmodel_dropdown_change, tgwui_tts_dropdown_gr, None
|
|
)
|
|
|
|
tgwui_deepspeed_enabled_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_deepspeed_enabled": x}),
|
|
tgwui_deepspeed_enabled_gr,
|
|
None,
|
|
)
|
|
tgwui_deepspeed_enabled_gr.change(
|
|
send_deepspeed_request,
|
|
tgwui_deepspeed_enabled_gr,
|
|
tgwui_deepspeed_enabled_play_gr,
|
|
None,
|
|
)
|
|
tgwui_character_voice_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_character_voice": x}),
|
|
tgwui_character_voice_gr,
|
|
None,
|
|
)
|
|
tgwui_language_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_language": x}),
|
|
tgwui_language_gr,
|
|
None,
|
|
)
|
|
|
|
# TSS Settings
|
|
tgwui_temperature_set_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_temperature_set": x}),
|
|
tgwui_temperature_set_gr,
|
|
None,
|
|
)
|
|
tgwui_repetitionpenalty_set_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update(
|
|
{"tgwui_repetitionpenalty_set": x}
|
|
),
|
|
tgwui_repetitionpenalty_set_gr,
|
|
None,
|
|
)
|
|
tgwui_generationspeed_set_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_generationspeed_set": x}),
|
|
tgwui_generationspeed_set_gr,
|
|
None,
|
|
)
|
|
tgwui_pitch_set_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_pitch_set": x}),
|
|
tgwui_pitch_set_gr,
|
|
None,
|
|
)
|
|
|
|
# Narrator selection actions
|
|
tgwui_narrator_enabled_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_narrator_enabled": x}),
|
|
tgwui_narrator_enabled_gr,
|
|
None,
|
|
)
|
|
tgwui_non_quoted_text_is_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_non_quoted_text_is": x}),
|
|
tgwui_non_quoted_text_is_gr,
|
|
None,
|
|
)
|
|
tgwui_narrator_voice_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_narrator_voice": x}),
|
|
tgwui_narrator_voice_gr,
|
|
None,
|
|
)
|
|
|
|
# RVC selection actions
|
|
tgwui_rvc_char_voice_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_rvc_char_voice": x}),
|
|
tgwui_rvc_char_voice_gr,
|
|
None,
|
|
)
|
|
tgwui_rvc_char_pitch_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_rvc_char_pitch": x}),
|
|
tgwui_rvc_char_pitch_gr,
|
|
None,
|
|
)
|
|
tgwui_rvc_narr_voice_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_rvc_narr_voice": x}),
|
|
tgwui_rvc_narr_voice_gr,
|
|
None,
|
|
)
|
|
tgwui_rvc_narr_pitch_gr.change(
|
|
lambda x: mode_manager.config["tgwui"].update({"tgwui_rvc_narr_pitch": x}),
|
|
tgwui_rvc_narr_pitch_gr,
|
|
None,
|
|
)
|