1033 lines
45 KiB
Python
1033 lines
45 KiB
Python
import sys
|
|
import copy
|
|
from os import path as os_path, makedirs as os_makedirs
|
|
from json import load as json_load
|
|
from json import dump as json_dump
|
|
import threading
|
|
from typing import Optional, Dict, Any
|
|
import torch
|
|
|
|
# Guard optional, potentially heavy or platform-specific imports so importing
|
|
# config.py doesn't raise in environments missing those packages.
|
|
try:
|
|
from device_manager import device_manager
|
|
except Exception: # pragma: no cover - optional runtime
|
|
device_manager = None # type: ignore
|
|
|
|
try:
|
|
from models.translation.translation_languages import translation_lang, loadTranslationLanguages
|
|
except Exception: # pragma: no cover - optional runtime
|
|
translation_lang = {} # type: ignore
|
|
def loadTranslationLanguages(path: str, force: bool = False) -> Dict[str, Any]:
|
|
return {}
|
|
|
|
try:
|
|
from models.translation.translation_utils import ctranslate2_weights
|
|
except Exception: # pragma: no cover - optional runtime
|
|
ctranslate2_weights = {} # type: ignore
|
|
|
|
try:
|
|
from models.transcription.transcription_languages import transcription_lang
|
|
except Exception: # pragma: no cover - optional runtime
|
|
transcription_lang = {} # type: ignore
|
|
|
|
try:
|
|
from models.transcription.transcription_whisper import _MODELS as whisper_models
|
|
except Exception: # pragma: no cover - optional runtime
|
|
whisper_models = {} # type: ignore
|
|
|
|
from utils import errorLogging, validateDictStructure, getComputeDeviceList
|
|
|
|
json_serializable_vars = {}
|
|
def json_serializable(var_name):
|
|
def decorator(func):
|
|
json_serializable_vars[var_name] = func
|
|
return func
|
|
return decorator
|
|
|
|
# Auto-register descriptors for serialization
|
|
def _auto_register_descriptors():
|
|
"""Automatically register ManagedProperty and ValidatedProperty descriptors
|
|
for JSON serialization, reducing boilerplate _json_XXX methods.
|
|
"""
|
|
for name, obj in Config.__dict__.items():
|
|
if isinstance(obj, (ManagedProperty, ValidatedProperty)):
|
|
# Only register if serialize=True and not already manually registered
|
|
if obj.serialize and name not in json_serializable_vars:
|
|
# Create closure to capture current name
|
|
def make_serializer(attr_name):
|
|
@json_serializable(attr_name)
|
|
def _auto_serialize(self):
|
|
return getattr(self, attr_name)
|
|
return _auto_serialize
|
|
make_serializer(name)
|
|
|
|
|
|
# Wrapper classes for mutable types that auto-save on modification
|
|
class ManagedDict(dict):
|
|
"""Dict wrapper that saves changes back to config."""
|
|
def __init__(self, instance, property_name, immediate_save):
|
|
self._instance = instance
|
|
self._property_name = property_name
|
|
self._immediate_save = immediate_save
|
|
self._internal_name = f"_{property_name}"
|
|
# Initialize from internal storage
|
|
super().__init__(getattr(instance, self._internal_name))
|
|
|
|
def _get_internal(self):
|
|
"""Get reference to internal storage."""
|
|
return getattr(self._instance, self._internal_name)
|
|
|
|
def _save(self):
|
|
"""Save current state back to config and sync internal storage."""
|
|
try:
|
|
# Update internal storage directly
|
|
internal_dict = self._get_internal()
|
|
internal_dict.clear()
|
|
internal_dict.update(dict.items(self))
|
|
# Trigger config save only if the corresponding property is serializable
|
|
descriptor = getattr(type(self._instance), self._property_name, None)
|
|
if getattr(descriptor, "serialize", True):
|
|
self._instance.saveConfig(self._property_name, dict(self), immediate_save=self._immediate_save)
|
|
except Exception:
|
|
pass
|
|
|
|
def __getitem__(self, key):
|
|
# Always read from internal storage to get latest value
|
|
return self._get_internal()[key]
|
|
|
|
def __setitem__(self, key, value):
|
|
super().__setitem__(key, value)
|
|
self._save()
|
|
|
|
def __delitem__(self, key):
|
|
super().__delitem__(key)
|
|
self._save()
|
|
|
|
def __contains__(self, key):
|
|
return key in self._get_internal()
|
|
|
|
def get(self, key, default=None):
|
|
return self._get_internal().get(key, default)
|
|
|
|
def keys(self):
|
|
return self._get_internal().keys()
|
|
|
|
def values(self):
|
|
return self._get_internal().values()
|
|
|
|
def items(self):
|
|
return self._get_internal().items()
|
|
|
|
def update(self, *args, **kwargs):
|
|
super().update(*args, **kwargs)
|
|
self._save()
|
|
|
|
def pop(self, *args):
|
|
result = super().pop(*args)
|
|
self._save()
|
|
return result
|
|
|
|
def popitem(self):
|
|
result = super().popitem()
|
|
self._save()
|
|
return result
|
|
|
|
def clear(self):
|
|
super().clear()
|
|
self._save()
|
|
|
|
def setdefault(self, key, default=None):
|
|
result = super().setdefault(key, default)
|
|
self._save()
|
|
return result
|
|
|
|
|
|
class ManagedList(list):
|
|
"""List wrapper that saves changes back to config."""
|
|
def __init__(self, instance, property_name, immediate_save):
|
|
self._instance = instance
|
|
self._property_name = property_name
|
|
self._immediate_save = immediate_save
|
|
self._internal_name = f"_{property_name}"
|
|
# Initialize from internal storage
|
|
super().__init__(getattr(instance, self._internal_name))
|
|
|
|
def _get_internal(self):
|
|
"""Get reference to internal storage."""
|
|
return getattr(self._instance, self._internal_name)
|
|
|
|
def _save(self):
|
|
"""Save current state back to config and sync internal storage."""
|
|
try:
|
|
# Update internal storage directly
|
|
internal_list = self._get_internal()
|
|
internal_list.clear()
|
|
internal_list.extend(list.__iter__(self))
|
|
# Trigger config save only if the corresponding property is serializable
|
|
descriptor = getattr(type(self._instance), self._property_name, None)
|
|
if getattr(descriptor, "serialize", True):
|
|
self._instance.saveConfig(self._property_name, list(self), immediate_save=self._immediate_save)
|
|
except Exception:
|
|
pass
|
|
|
|
def __getitem__(self, index):
|
|
# Always read from internal storage to get latest value
|
|
return self._get_internal()[index]
|
|
|
|
def __setitem__(self, index, value):
|
|
super().__setitem__(index, value)
|
|
self._save()
|
|
|
|
def __delitem__(self, index):
|
|
super().__delitem__(index)
|
|
self._save()
|
|
|
|
def __len__(self):
|
|
return len(self._get_internal())
|
|
|
|
def __contains__(self, value):
|
|
return value in self._get_internal()
|
|
|
|
def __iter__(self):
|
|
return iter(self._get_internal())
|
|
|
|
def append(self, value):
|
|
super().append(value)
|
|
self._save()
|
|
|
|
def extend(self, iterable):
|
|
super().extend(iterable)
|
|
self._save()
|
|
|
|
def insert(self, index, value):
|
|
super().insert(index, value)
|
|
self._save()
|
|
|
|
def remove(self, value):
|
|
super().remove(value)
|
|
self._save()
|
|
|
|
def pop(self, index=-1):
|
|
result = super().pop(index)
|
|
self._save()
|
|
return result
|
|
|
|
def clear(self):
|
|
super().clear()
|
|
self._save()
|
|
|
|
def sort(self, *args, **kwargs):
|
|
super().sort(*args, **kwargs)
|
|
self._save()
|
|
|
|
def reverse(self):
|
|
super().reverse()
|
|
self._save()
|
|
|
|
|
|
# Descriptor for simple managed config properties to reduce repetitive getters/setters.
|
|
# It performs optional type validation, optional allowed-values check, and calls
|
|
# instance.saveConfig(...) on successful set.
|
|
class ManagedProperty:
|
|
def __init__(self, name: str, type_: type = None, allowed=None, immediate_save: bool = False, serialize: bool = True, readonly: bool = False, mutable_tracking: bool = False):
|
|
self.name = name
|
|
self.type_ = type_
|
|
self.allowed = allowed
|
|
self.immediate_save = immediate_save
|
|
self.serialize = serialize
|
|
self.readonly = readonly
|
|
self.mutable_tracking = mutable_tracking
|
|
self.private_name = f"_{name}"
|
|
self.wrapper_cache_name = f"_wrapper_{name}"
|
|
|
|
def __get__(self, instance, owner):
|
|
if instance is None:
|
|
return self
|
|
stored = getattr(instance, self.private_name)
|
|
|
|
# If mutable_tracking is enabled, return cached wrapper or create new one
|
|
if self.mutable_tracking and isinstance(stored, dict):
|
|
wrapper = getattr(instance, self.wrapper_cache_name, None)
|
|
if wrapper is None or not isinstance(wrapper, ManagedDict):
|
|
wrapper = ManagedDict(instance, self.name, self.immediate_save)
|
|
setattr(instance, self.wrapper_cache_name, wrapper)
|
|
# Wrapper automatically syncs with internal storage on access
|
|
return wrapper
|
|
elif self.mutable_tracking and isinstance(stored, list):
|
|
wrapper = getattr(instance, self.wrapper_cache_name, None)
|
|
if wrapper is None or not isinstance(wrapper, ManagedList):
|
|
wrapper = ManagedList(instance, self.name, self.immediate_save)
|
|
setattr(instance, self.wrapper_cache_name, wrapper)
|
|
# Wrapper automatically syncs with internal storage on access
|
|
return wrapper
|
|
|
|
# Return deep copy for mutable types to prevent external modification
|
|
if isinstance(stored, (dict, list)):
|
|
return copy.deepcopy(stored)
|
|
return stored
|
|
|
|
def __set__(self, instance, value):
|
|
# Prevent modification of read-only properties
|
|
if self.readonly:
|
|
raise AttributeError(f"Cannot set read-only property '{self.name}'")
|
|
|
|
# Type check if requested
|
|
if self.type_ is not None and not isinstance(value, self.type_):
|
|
return
|
|
|
|
# Allowed-values check: can be an iterable or a callable
|
|
if self.allowed is not None:
|
|
if callable(self.allowed):
|
|
try:
|
|
ok = self.allowed(value, instance)
|
|
except Exception:
|
|
ok = False
|
|
if not ok:
|
|
return
|
|
else:
|
|
if value not in self.allowed:
|
|
return
|
|
|
|
# Deep copy mutable types to prevent external reference issues
|
|
if isinstance(value, (dict, list)):
|
|
value = copy.deepcopy(value)
|
|
|
|
setattr(instance, self.private_name, value)
|
|
# Persist change
|
|
try:
|
|
if self.serialize:
|
|
instance.saveConfig(self.name, value, immediate_save=self.immediate_save)
|
|
except Exception:
|
|
# Keep setter robust during import-time initialization
|
|
pass
|
|
|
|
class ValidatedProperty:
|
|
"""Descriptor for complex validated properties.
|
|
|
|
validator(value, instance) -> normalized_value | None
|
|
If returns None (or raises), value is ignored.
|
|
"""
|
|
def __init__(self, name: str, validator, immediate_save: bool = False, serialize: bool = True):
|
|
self.name = name
|
|
self.validator = validator
|
|
self.immediate_save = immediate_save
|
|
self.serialize = serialize
|
|
self.private_name = f"_{name}"
|
|
|
|
def __get__(self, instance, owner):
|
|
if instance is None:
|
|
return self
|
|
return getattr(instance, self.private_name)
|
|
|
|
def __set__(self, instance, value):
|
|
try:
|
|
normalized = self.validator(value, instance)
|
|
except Exception:
|
|
return
|
|
if normalized is None:
|
|
return
|
|
setattr(instance, self.private_name, normalized)
|
|
try:
|
|
if self.serialize:
|
|
instance.saveConfig(self.name, normalized, immediate_save=self.immediate_save)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
# ============================================================================
|
|
# Validator Functions for ValidatedProperty
|
|
# ============================================================================
|
|
|
|
def _main_window_geometry_validator(val, inst):
|
|
if not (isinstance(val, dict) and set(val.keys()) == set(inst.MAIN_WINDOW_GEOMETRY.keys())):
|
|
return None
|
|
new = {}
|
|
for key, value in val.items():
|
|
if isinstance(value, int):
|
|
new[key] = value
|
|
else:
|
|
new[key] = inst.MAIN_WINDOW_GEOMETRY[key]
|
|
return new
|
|
|
|
def _selected_transcription_compute_type_validator(val, inst):
|
|
if not isinstance(val, str):
|
|
return None
|
|
compute_types = inst.SELECTED_TRANSCRIPTION_COMPUTE_DEVICE.get("compute_types", [])
|
|
if val in compute_types:
|
|
return val
|
|
return None
|
|
|
|
def _overlay_small_validator(val, inst):
|
|
if not (isinstance(val, dict) and set(val.keys()) == set(inst.OVERLAY_SMALL_LOG_SETTINGS.keys())):
|
|
return None
|
|
base = inst.OVERLAY_SMALL_LOG_SETTINGS
|
|
new = dict(base)
|
|
for key, v in val.items():
|
|
if key == 'tracker' and isinstance(v, str) and v in ['HMD', 'LeftHand', 'RightHand']:
|
|
new[key] = v
|
|
elif key in ['x_pos','y_pos','z_pos','x_rotation','y_rotation','z_rotation'] and isinstance(v,(int,float)):
|
|
new[key] = float(v)
|
|
elif key in ['display_duration','fadeout_duration'] and isinstance(v,int):
|
|
new[key] = v
|
|
elif key in ['opacity','ui_scaling'] and isinstance(v,(int,float)):
|
|
new[key] = float(v)
|
|
return new
|
|
|
|
def _overlay_large_validator(val, inst):
|
|
if not (isinstance(val, dict) and set(val.keys()) == set(inst.OVERLAY_LARGE_LOG_SETTINGS.keys())):
|
|
return None
|
|
base = inst.OVERLAY_LARGE_LOG_SETTINGS
|
|
new = dict(base)
|
|
for key, v in val.items():
|
|
if key == 'tracker' and isinstance(v, str) and v in ['HMD', 'LeftHand', 'RightHand']:
|
|
new[key] = v
|
|
elif key in ['x_pos','y_pos','z_pos','x_rotation','y_rotation','z_rotation'] and isinstance(v,(int,float)):
|
|
new[key] = float(v)
|
|
elif key in ['display_duration','fadeout_duration'] and isinstance(v,int):
|
|
new[key] = v
|
|
elif key in ['opacity','ui_scaling'] and isinstance(v,(int,float)):
|
|
new[key] = float(v)
|
|
return new
|
|
|
|
def _format_validator_send(val, inst):
|
|
valid_parts = {
|
|
"message": {"prefix": str, "suffix": str},
|
|
"separator": str,
|
|
"translation": {"prefix": str, "separator": str, "suffix": str},
|
|
"translation_first": bool
|
|
}
|
|
if not isinstance(val, dict):
|
|
return None
|
|
return val if validateDictStructure(val, valid_parts) else None
|
|
|
|
def _format_validator_received(val, inst):
|
|
valid_parts = {
|
|
"message": {"prefix": str, "suffix": str},
|
|
"separator": str,
|
|
"translation": {"prefix": str, "separator": str, "suffix": str},
|
|
"translation_first": bool
|
|
}
|
|
if not isinstance(val, dict):
|
|
return None
|
|
return val if validateDictStructure(val, valid_parts) else None
|
|
|
|
def _mic_word_filter_validator(val, inst):
|
|
if not isinstance(val, list):
|
|
return None
|
|
seen = set()
|
|
result = []
|
|
for item in val:
|
|
if isinstance(item, str) and item not in seen:
|
|
seen.add(item)
|
|
result.append(item)
|
|
return result
|
|
|
|
def _plugins_status_validator(val, inst):
|
|
if not isinstance(val, list):
|
|
return None
|
|
if not all(isinstance(item, dict) for item in val):
|
|
return None
|
|
return [dict(item) for item in val]
|
|
|
|
def _selected_translation_engines_validator(val, inst):
|
|
if not isinstance(val, dict):
|
|
return None
|
|
old_value = inst.SELECTED_TRANSLATION_ENGINES
|
|
new = {}
|
|
for k, v in val.items():
|
|
if v in inst.SELECTABLE_TRANSLATION_ENGINE_LIST:
|
|
new[k] = v
|
|
else:
|
|
new[k] = old_value.get(k)
|
|
return new
|
|
|
|
def _selected_your_languages_validator(val, inst):
|
|
if not isinstance(val, dict):
|
|
return None
|
|
old = inst.SELECTED_YOUR_LANGUAGES
|
|
new = {}
|
|
for k0, v0 in val.items():
|
|
new[k0] = {}
|
|
for k1, v1 in v0.items():
|
|
language = v1.get("language")
|
|
country = v1.get("country")
|
|
enable = v1.get("enable")
|
|
if (language not in list(transcription_lang.keys()) or
|
|
country not in list(transcription_lang.get(language, {}).keys()) or
|
|
not isinstance(enable, bool)):
|
|
new[k0][k1] = old.get(k0, {}).get(k1)
|
|
else:
|
|
new[k0][k1] = {"language": language, "country": country, "enable": enable}
|
|
return new
|
|
|
|
def _selected_target_languages_validator(val, inst):
|
|
if not isinstance(val, dict):
|
|
return None
|
|
old = inst.SELECTED_TARGET_LANGUAGES
|
|
new = {}
|
|
for k0, v0 in val.items():
|
|
new[k0] = {}
|
|
for k1, v1 in v0.items():
|
|
language = v1.get("language")
|
|
country = v1.get("country")
|
|
enable = v1.get("enable")
|
|
if (language not in list(transcription_lang.keys()) or
|
|
country not in list(transcription_lang.get(language, {}).keys()) or
|
|
not isinstance(enable, bool)):
|
|
new[k0][k1] = old.get(k0, {}).get(k1)
|
|
else:
|
|
new[k0][k1] = {"language": language, "country": country, "enable": enable}
|
|
return new
|
|
|
|
def _selected_translation_compute_type_validator(val, inst):
|
|
if not isinstance(val, str):
|
|
return None
|
|
compute_types = inst.SELECTED_TRANSLATION_COMPUTE_DEVICE.get("compute_types", [])
|
|
if val in compute_types:
|
|
return val
|
|
return None
|
|
|
|
def _mic_host_validator(val, inst):
|
|
if device_manager is None:
|
|
return None
|
|
if not isinstance(val, str):
|
|
return None
|
|
hosts = list(device_manager.getMicDevices().keys())
|
|
return val if val in hosts else None
|
|
|
|
def _mic_device_validator(val, inst):
|
|
if device_manager is None:
|
|
return None
|
|
if not isinstance(val, str):
|
|
return None
|
|
try:
|
|
devices = device_manager.getMicDevices().get(inst.SELECTED_MIC_HOST, [])
|
|
names = [d.get('name') for d in devices]
|
|
return val if val in names else None
|
|
except Exception:
|
|
return None
|
|
|
|
def _speaker_device_validator(val, inst):
|
|
if device_manager is None:
|
|
return None
|
|
if not isinstance(val, str):
|
|
return None
|
|
try:
|
|
names = [d.get('name') for d in device_manager.getSpeakerDevices()]
|
|
return val if val in names else None
|
|
except Exception:
|
|
return None
|
|
|
|
def _compute_device_validator(val, inst):
|
|
if not isinstance(val, dict):
|
|
return None
|
|
for dev in inst.SELECTABLE_COMPUTE_DEVICE_LIST:
|
|
if dev == val:
|
|
return copy.deepcopy(val)
|
|
return None
|
|
|
|
|
|
class Config:
|
|
"""Application configuration singleton.
|
|
|
|
Responsibilities:
|
|
- expose read-only and read-write configuration via properties
|
|
- persist selected values to JSON with debounce
|
|
Implementation notes: initialization may depend on optional subsystems; any
|
|
exceptions during init/load are captured and logged to avoid import-time
|
|
crashes.
|
|
"""
|
|
|
|
_instance = None
|
|
_config_data: Dict[str, Any] = {}
|
|
_timer: Optional[threading.Timer] = None
|
|
_debounce_time: int = 2
|
|
|
|
def __new__(cls):
|
|
if cls._instance is None:
|
|
cls._instance = super(Config, cls).__new__(cls)
|
|
try:
|
|
cls._instance.init_config()
|
|
except Exception:
|
|
errorLogging()
|
|
try:
|
|
cls._instance.load_config()
|
|
except Exception:
|
|
errorLogging()
|
|
return cls._instance
|
|
|
|
def saveConfigToFile(self) -> None:
|
|
with open(self.PATH_CONFIG, "w", encoding="utf-8") as fp:
|
|
json_dump(self._config_data, fp, indent=4, ensure_ascii=False)
|
|
|
|
def saveConfig(self, key: str, value: Any, immediate_save: bool = False) -> None:
|
|
self._config_data[key] = value
|
|
|
|
if isinstance(self._timer, threading.Timer) and self._timer.is_alive():
|
|
self._timer.cancel()
|
|
|
|
if immediate_save:
|
|
self.saveConfigToFile()
|
|
else:
|
|
self._timer = threading.Timer(self._debounce_time, self.saveConfigToFile)
|
|
self._timer.daemon = True
|
|
self._timer.start()
|
|
|
|
# Read Only
|
|
VERSION = ManagedProperty('VERSION', readonly=True, serialize=False)
|
|
PATH_LOCAL = ManagedProperty('PATH_LOCAL', readonly=True, serialize=False)
|
|
PATH_CONFIG = ManagedProperty('PATH_CONFIG', readonly=True, serialize=False)
|
|
PATH_LOGS = ManagedProperty('PATH_LOGS', readonly=True, serialize=False)
|
|
GITHUB_URL = ManagedProperty('GITHUB_URL', readonly=True, serialize=False)
|
|
UPDATER_URL = ManagedProperty('UPDATER_URL', readonly=True, serialize=False)
|
|
BOOTH_URL = ManagedProperty('BOOTH_URL', readonly=True, serialize=False)
|
|
DOCUMENTS_URL = ManagedProperty('DOCUMENTS_URL', readonly=True, serialize=False)
|
|
DEEPL_AUTH_KEY_PAGE_URL = ManagedProperty('DEEPL_AUTH_KEY_PAGE_URL', readonly=True, serialize=False)
|
|
MAX_MIC_THRESHOLD = ManagedProperty('MAX_MIC_THRESHOLD', readonly=True, serialize=False)
|
|
MAX_SPEAKER_THRESHOLD = ManagedProperty('MAX_SPEAKER_THRESHOLD', readonly=True, serialize=False)
|
|
WATCHDOG_TIMEOUT = ManagedProperty('WATCHDOG_TIMEOUT', readonly=True, serialize=False)
|
|
WATCHDOG_INTERVAL = ManagedProperty('WATCHDOG_INTERVAL', readonly=True, serialize=False)
|
|
SELECTABLE_TAB_NO_LIST = ManagedProperty('SELECTABLE_TAB_NO_LIST', readonly=True, serialize=False)
|
|
SELECTED_TAB_TARGET_LANGUAGES_NO_LIST = ManagedProperty('SELECTED_TAB_TARGET_LANGUAGES_NO_LIST', readonly=True, serialize=False)
|
|
SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_LIST = ManagedProperty('SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_LIST', readonly=True, serialize=False)
|
|
SELECTABLE_WHISPER_WEIGHT_TYPE_LIST = ManagedProperty('SELECTABLE_WHISPER_WEIGHT_TYPE_LIST', readonly=True, serialize=False)
|
|
SELECTABLE_TRANSLATION_ENGINE_LIST = ManagedProperty('SELECTABLE_TRANSLATION_ENGINE_LIST', readonly=True, serialize=False)
|
|
SELECTABLE_TRANSCRIPTION_ENGINE_LIST = ManagedProperty('SELECTABLE_TRANSCRIPTION_ENGINE_LIST', readonly=True, serialize=False)
|
|
SELECTABLE_UI_LANGUAGE_LIST = ManagedProperty('SELECTABLE_UI_LANGUAGE_LIST', readonly=True, serialize=False)
|
|
COMPUTE_MODE = ManagedProperty('COMPUTE_MODE', readonly=True, serialize=False)
|
|
SELECTABLE_COMPUTE_DEVICE_LIST = ManagedProperty('SELECTABLE_COMPUTE_DEVICE_LIST', readonly=True, serialize=False)
|
|
SEND_MESSAGE_BUTTON_TYPE_LIST = ManagedProperty('SEND_MESSAGE_BUTTON_TYPE_LIST', readonly=True, serialize=False)
|
|
|
|
# Read Write
|
|
# --- Simple boolean flags (managed by descriptor) ---
|
|
ENABLE_TRANSLATION = ManagedProperty('ENABLE_TRANSLATION', type_=bool)
|
|
ENABLE_TRANSCRIPTION_SEND = ManagedProperty('ENABLE_TRANSCRIPTION_SEND', type_=bool)
|
|
ENABLE_TRANSCRIPTION_RECEIVE = ManagedProperty('ENABLE_TRANSCRIPTION_RECEIVE', type_=bool)
|
|
ENABLE_FOREGROUND = ManagedProperty('ENABLE_FOREGROUND', type_=bool)
|
|
ENABLE_CHECK_ENERGY_SEND = ManagedProperty('ENABLE_CHECK_ENERGY_SEND', type_=bool)
|
|
ENABLE_CHECK_ENERGY_RECEIVE = ManagedProperty('ENABLE_CHECK_ENERGY_RECEIVE', type_=bool)
|
|
|
|
# --- Selectable dict/list properties (managed by descriptor, not serialized) ---
|
|
# These are dynamically generated in init_config() based on installed packages/APIs
|
|
SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT = ManagedProperty('SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT', type_=dict, serialize=False, mutable_tracking=True)
|
|
SELECTABLE_WHISPER_WEIGHT_TYPE_DICT = ManagedProperty('SELECTABLE_WHISPER_WEIGHT_TYPE_DICT', type_=dict, serialize=False, mutable_tracking=True)
|
|
SELECTABLE_TRANSLATION_ENGINE_STATUS = ManagedProperty('SELECTABLE_TRANSLATION_ENGINE_STATUS', type_=dict, serialize=False, mutable_tracking=True)
|
|
SELECTABLE_TRANSCRIPTION_ENGINE_STATUS = ManagedProperty('SELECTABLE_TRANSCRIPTION_ENGINE_STATUS', type_=dict, serialize=False, mutable_tracking=True)
|
|
SELECTABLE_PLAMO_MODEL_LIST = ManagedProperty('SELECTABLE_PLAMO_MODEL_LIST', type_=list, serialize=False, mutable_tracking=True)
|
|
SELECTABLE_GEMINI_MODEL_LIST = ManagedProperty('SELECTABLE_GEMINI_MODEL_LIST', type_=list, serialize=False, mutable_tracking=True)
|
|
SELECTABLE_OPENAI_MODEL_LIST = ManagedProperty('SELECTABLE_OPENAI_MODEL_LIST', type_=list, serialize=False, mutable_tracking=True)
|
|
SELECTABLE_LMSTUDIO_MODEL_LIST = ManagedProperty('SELECTABLE_LMSTUDIO_MODEL_LIST', type_=list, serialize=False, mutable_tracking=True)
|
|
SELECTABLE_OLLAMA_MODEL_LIST = ManagedProperty('SELECTABLE_OLLAMA_MODEL_LIST', type_=list, serialize=False, mutable_tracking=True)
|
|
|
|
# --- Save Json Data (ManagedProperty-based) ---
|
|
# More simple boolean flags replaced with ManagedProperty
|
|
CONVERT_MESSAGE_TO_ROMAJI = ManagedProperty('CONVERT_MESSAGE_TO_ROMAJI', type_=bool)
|
|
CONVERT_MESSAGE_TO_HIRAGANA = ManagedProperty('CONVERT_MESSAGE_TO_HIRAGANA', type_=bool)
|
|
MAIN_WINDOW_SIDEBAR_COMPACT_MODE = ManagedProperty('MAIN_WINDOW_SIDEBAR_COMPACT_MODE', type_=bool)
|
|
|
|
## Config Window
|
|
TRANSPARENCY = ManagedProperty('TRANSPARENCY', type_=int)
|
|
UI_SCALING = ManagedProperty('UI_SCALING', type_=int)
|
|
TEXTBOX_UI_SCALING = ManagedProperty('TEXTBOX_UI_SCALING', type_=int)
|
|
MESSAGE_BOX_RATIO = ManagedProperty('MESSAGE_BOX_RATIO', type_=(int, float), immediate_save=True)
|
|
SEND_MESSAGE_BUTTON_TYPE = ManagedProperty('SEND_MESSAGE_BUTTON_TYPE', type_=str, allowed=lambda v, inst: v in inst.SEND_MESSAGE_BUTTON_TYPE_LIST)
|
|
SHOW_RESEND_BUTTON = ManagedProperty('SHOW_RESEND_BUTTON', type_=bool)
|
|
FONT_FAMILY = ManagedProperty('FONT_FAMILY', type_=str)
|
|
UI_LANGUAGE = ManagedProperty('UI_LANGUAGE', type_=str, allowed=lambda v, inst: v in inst.SELECTABLE_UI_LANGUAGE_LIST)
|
|
MAIN_WINDOW_GEOMETRY = ValidatedProperty('MAIN_WINDOW_GEOMETRY', _main_window_geometry_validator, immediate_save=True)
|
|
|
|
# --- Mic-related simple properties ---
|
|
MIC_THRESHOLD = ManagedProperty('MIC_THRESHOLD', type_=int)
|
|
MIC_AUTOMATIC_THRESHOLD = ManagedProperty('MIC_AUTOMATIC_THRESHOLD', type_=bool)
|
|
MIC_RECORD_TIMEOUT = ManagedProperty('MIC_RECORD_TIMEOUT', type_=int)
|
|
MIC_PHRASE_TIMEOUT = ManagedProperty('MIC_PHRASE_TIMEOUT', type_=int)
|
|
MIC_MAX_PHRASES = ManagedProperty('MIC_MAX_PHRASES', type_=int)
|
|
MIC_AVG_LOGPROB = ManagedProperty('MIC_AVG_LOGPROB', type_=(int, float))
|
|
MIC_NO_SPEECH_PROB = ManagedProperty('MIC_NO_SPEECH_PROB', type_=(int, float))
|
|
MIC_NO_REPEAT_NGRAM_SIZE = ManagedProperty('MIC_NO_REPEAT_NGRAM_SIZE', type_=int)
|
|
MIC_VAD_FILTER = ManagedProperty('MIC_VAD_FILTER', type_=bool)
|
|
MIC_VAD_PARAMETERS = ManagedProperty('MIC_VAD_PARAMETERS', type_=dict, mutable_tracking=True)
|
|
HOTKEYS = ValidatedProperty('HOTKEYS',
|
|
validator=lambda val, inst: (
|
|
{k: (v if (isinstance(v, list) or v is None) else inst.HOTKEYS.get(k))
|
|
for k, v in val.items()} if isinstance(val, dict) and set(val.keys()) == set(inst.HOTKEYS.keys()) else None
|
|
),
|
|
immediate_save=True
|
|
)
|
|
|
|
# --- Speaker-related simple properties ---
|
|
SPEAKER_THRESHOLD = ManagedProperty('SPEAKER_THRESHOLD', type_=int)
|
|
SPEAKER_AUTOMATIC_THRESHOLD = ManagedProperty('SPEAKER_AUTOMATIC_THRESHOLD', type_=bool)
|
|
SPEAKER_RECORD_TIMEOUT = ManagedProperty('SPEAKER_RECORD_TIMEOUT', type_=int)
|
|
SPEAKER_PHRASE_TIMEOUT = ManagedProperty('SPEAKER_PHRASE_TIMEOUT', type_=int)
|
|
SPEAKER_MAX_PHRASES = ManagedProperty('SPEAKER_MAX_PHRASES', type_=int)
|
|
SPEAKER_AVG_LOGPROB = ManagedProperty('SPEAKER_AVG_LOGPROB', type_=(int, float))
|
|
SPEAKER_NO_SPEECH_PROB = ManagedProperty('SPEAKER_NO_SPEECH_PROB', type_=(int, float))
|
|
SPEAKER_NO_REPEAT_NGRAM_SIZE = ManagedProperty('SPEAKER_NO_REPEAT_NGRAM_SIZE', type_=int)
|
|
SPEAKER_VAD_FILTER = ManagedProperty('SPEAKER_VAD_FILTER', type_=bool)
|
|
SPEAKER_VAD_PARAMETERS = ManagedProperty('SPEAKER_VAD_PARAMETERS', type_=dict, mutable_tracking=True)
|
|
|
|
# --- Auth and API settings ---
|
|
AUTH_KEYS = ValidatedProperty('AUTH_KEYS',
|
|
validator=lambda val, inst: (
|
|
{k: (v if isinstance(v, str) else inst.AUTH_KEYS.get(k)) for k, v in val.items()}
|
|
if isinstance(val, dict) and set(val.keys()) == set(inst.AUTH_KEYS.keys()) else None
|
|
)
|
|
)
|
|
LMSTUDIO_URL = ManagedProperty('LMSTUDIO_URL', type_=str)
|
|
|
|
# --- Transcription settings ---
|
|
SELECTED_TRANSCRIPTION_COMPUTE_TYPE = ValidatedProperty('SELECTED_TRANSCRIPTION_COMPUTE_TYPE', _selected_transcription_compute_type_validator)
|
|
|
|
# --- Overlay settings ---
|
|
OVERLAY_SMALL_LOG_SETTINGS = ValidatedProperty('OVERLAY_SMALL_LOG_SETTINGS', _overlay_small_validator)
|
|
OVERLAY_LARGE_LOG_SETTINGS = ValidatedProperty('OVERLAY_LARGE_LOG_SETTINGS', _overlay_large_validator)
|
|
|
|
# --- Message format settings ---
|
|
SEND_MESSAGE_FORMAT_PARTS = ValidatedProperty('SEND_MESSAGE_FORMAT_PARTS', _format_validator_send)
|
|
RECEIVED_MESSAGE_FORMAT_PARTS = ValidatedProperty('RECEIVED_MESSAGE_FORMAT_PARTS', _format_validator_received)
|
|
|
|
# Convert remaining simple properties to ManagedProperty to reduce repetition
|
|
WEBSOCKET_SERVER = ManagedProperty('WEBSOCKET_SERVER', type_=bool)
|
|
OSC_IP_ADDRESS = ManagedProperty('OSC_IP_ADDRESS', type_=str)
|
|
OSC_PORT = ManagedProperty('OSC_PORT', type_=int)
|
|
AUTO_CLEAR_MESSAGE_BOX = ManagedProperty('AUTO_CLEAR_MESSAGE_BOX', type_=bool)
|
|
SEND_ONLY_TRANSLATED_MESSAGES = ManagedProperty('SEND_ONLY_TRANSLATED_MESSAGES', type_=bool)
|
|
OVERLAY_SMALL_LOG = ManagedProperty('OVERLAY_SMALL_LOG', type_=bool)
|
|
OVERLAY_LARGE_LOG = ManagedProperty('OVERLAY_LARGE_LOG', type_=bool)
|
|
OVERLAY_SHOW_ONLY_TRANSLATED_MESSAGES = ManagedProperty('OVERLAY_SHOW_ONLY_TRANSLATED_MESSAGES', type_=bool)
|
|
SEND_MESSAGE_TO_VRC = ManagedProperty('SEND_MESSAGE_TO_VRC', type_=bool)
|
|
SEND_RECEIVED_MESSAGE_TO_VRC = ManagedProperty('SEND_RECEIVED_MESSAGE_TO_VRC', type_=bool)
|
|
LOGGER_FEATURE = ManagedProperty('LOGGER_FEATURE', type_=bool)
|
|
VRC_MIC_MUTE_SYNC = ManagedProperty('VRC_MIC_MUTE_SYNC', type_=bool)
|
|
NOTIFICATION_VRC_SFX = ManagedProperty('NOTIFICATION_VRC_SFX', type_=bool)
|
|
WEBSOCKET_HOST = ManagedProperty('WEBSOCKET_HOST', type_=str)
|
|
WEBSOCKET_PORT = ManagedProperty('WEBSOCKET_PORT', type_=int)
|
|
|
|
# --- Selection properties with validation (ManagedProperty) ---
|
|
SELECTED_TAB_NO = ManagedProperty('SELECTED_TAB_NO', type_=str, allowed=lambda v, inst: v in inst.SELECTABLE_TAB_NO_LIST)
|
|
SELECTED_TRANSCRIPTION_ENGINE = ManagedProperty('SELECTED_TRANSCRIPTION_ENGINE', type_=str, allowed=lambda v, inst: v in inst.SELECTABLE_TRANSCRIPTION_ENGINE_LIST)
|
|
USE_EXCLUDE_WORDS = ManagedProperty('USE_EXCLUDE_WORDS', type_=bool)
|
|
CTRANSLATE2_WEIGHT_TYPE = ManagedProperty('CTRANSLATE2_WEIGHT_TYPE', type_=str, allowed=lambda v, inst: v in inst.SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_LIST)
|
|
WHISPER_WEIGHT_TYPE = ManagedProperty('WHISPER_WEIGHT_TYPE', type_=str, allowed=lambda v, inst: v in inst.SELECTABLE_WHISPER_WEIGHT_TYPE_LIST)
|
|
SELECTED_PLAMO_MODEL = ManagedProperty('SELECTED_PLAMO_MODEL', type_=str, allowed=lambda v, inst: v in inst.SELECTABLE_PLAMO_MODEL_LIST)
|
|
SELECTED_GEMINI_MODEL = ManagedProperty('SELECTED_GEMINI_MODEL', type_=str, allowed=lambda v, inst: v in inst.SELECTABLE_GEMINI_MODEL_LIST)
|
|
SELECTED_OPENAI_MODEL = ManagedProperty('SELECTED_OPENAI_MODEL', type_=str, allowed=lambda v, inst: v in inst.SELECTABLE_OPENAI_MODEL_LIST)
|
|
SELECTED_LMSTUDIO_MODEL = ManagedProperty('SELECTED_LMSTUDIO_MODEL', type_=str, allowed=lambda v, inst: v in inst.SELECTABLE_LMSTUDIO_MODEL_LIST)
|
|
SELECTED_OLLAMA_MODEL = ManagedProperty('SELECTED_OLLAMA_MODEL', type_=str, allowed=lambda v, inst: v in inst.SELECTABLE_OLLAMA_MODEL_LIST)
|
|
|
|
# --- Translation and language settings ---
|
|
MIC_WORD_FILTER = ValidatedProperty('MIC_WORD_FILTER', _mic_word_filter_validator)
|
|
PLUGINS_STATUS = ValidatedProperty('PLUGINS_STATUS', _plugins_status_validator, immediate_save=True)
|
|
SELECTED_TRANSLATION_ENGINES = ValidatedProperty('SELECTED_TRANSLATION_ENGINES', _selected_translation_engines_validator)
|
|
SELECTED_YOUR_LANGUAGES = ValidatedProperty('SELECTED_YOUR_LANGUAGES', _selected_your_languages_validator)
|
|
SELECTED_TARGET_LANGUAGES = ValidatedProperty('SELECTED_TARGET_LANGUAGES', _selected_target_languages_validator)
|
|
SELECTED_TRANSLATION_COMPUTE_TYPE = ValidatedProperty('SELECTED_TRANSLATION_COMPUTE_TYPE', _selected_translation_compute_type_validator)
|
|
|
|
# --- Device settings ---
|
|
AUTO_MIC_SELECT = ManagedProperty('AUTO_MIC_SELECT', type_=bool)
|
|
AUTO_SPEAKER_SELECT = ManagedProperty('AUTO_SPEAKER_SELECT', type_=bool)
|
|
SELECTED_MIC_HOST = ValidatedProperty('SELECTED_MIC_HOST', _mic_host_validator)
|
|
SELECTED_MIC_DEVICE = ValidatedProperty('SELECTED_MIC_DEVICE', _mic_device_validator)
|
|
SELECTED_SPEAKER_DEVICE = ValidatedProperty('SELECTED_SPEAKER_DEVICE', _speaker_device_validator)
|
|
SELECTED_TRANSLATION_COMPUTE_DEVICE = ValidatedProperty('SELECTED_TRANSLATION_COMPUTE_DEVICE', _compute_device_validator)
|
|
SELECTED_TRANSCRIPTION_COMPUTE_DEVICE = ValidatedProperty('SELECTED_TRANSCRIPTION_COMPUTE_DEVICE', _compute_device_validator)
|
|
|
|
# -- Clipboard control ---
|
|
ENABLE_COPY_TO_CLIPBOARD = ManagedProperty('ENABLE_COPY_TO_CLIPBOARD', type_=bool)
|
|
ENABLE_PASTE_FROM_CLIPBOARD = ManagedProperty('ENABLE_PASTE_FROM_CLIPBOARD', type_=bool)
|
|
|
|
def init_config(self):
|
|
# Read Only
|
|
self._VERSION = "3.3.1"
|
|
if getattr(sys, 'frozen', False):
|
|
self._PATH_LOCAL = os_path.dirname(sys.executable)
|
|
else:
|
|
self._PATH_LOCAL = os_path.dirname(os_path.abspath(__file__))
|
|
self._PATH_CONFIG = os_path.join(self._PATH_LOCAL, "config.json")
|
|
self._PATH_LOGS = os_path.join(self._PATH_LOCAL, "logs")
|
|
os_makedirs(self._PATH_LOGS, exist_ok=True)
|
|
self._GITHUB_URL = "https://api.github.com/repos/misyaguziya/VRCT/releases/latest"
|
|
self._UPDATER_URL = "https://api.github.com/repos/misyaguziya/VRCT_updater/releases/latest"
|
|
self._BOOTH_URL = "https://misyaguziya.booth.pm/"
|
|
self._DOCUMENTS_URL = "https://mzsoftware.notion.site/VRCT-Documents-be79b7a165f64442ad8f326d86c22246"
|
|
self._DEEPL_AUTH_KEY_PAGE_URL = "https://www.deepl.com/ja/account/summary"
|
|
|
|
self._MAX_MIC_THRESHOLD = 2000
|
|
self._MAX_SPEAKER_THRESHOLD = 4000
|
|
self._WATCHDOG_TIMEOUT = 60
|
|
self._WATCHDOG_INTERVAL = 20
|
|
|
|
self._SELECTABLE_TAB_NO_LIST = ["1", "2", "3"]
|
|
# these external mappings may be empty dicts if the optional modules failed to import
|
|
self._SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_LIST = getattr(ctranslate2_weights, 'keys', lambda: [])()
|
|
self._SELECTABLE_WHISPER_WEIGHT_TYPE_LIST = getattr(whisper_models, 'keys', lambda: [])()
|
|
translation_lang = loadTranslationLanguages(self.PATH_LOCAL)
|
|
self._SELECTABLE_TRANSLATION_ENGINE_LIST = getattr(translation_lang, 'keys', lambda: [])()
|
|
try:
|
|
# transcription_lang is nested dict; attempt to extract keys defensively
|
|
first_key = next(iter(transcription_lang))
|
|
self._SELECTABLE_TRANSCRIPTION_ENGINE_LIST = list(transcription_lang[first_key].values())[0].keys()
|
|
except Exception:
|
|
self._SELECTABLE_TRANSCRIPTION_ENGINE_LIST = []
|
|
self._SELECTABLE_UI_LANGUAGE_LIST = ["en", "ja", "ko", "zh-Hant", "zh-Hans"]
|
|
self._COMPUTE_MODE = "cuda" if torch.cuda.is_available() else "cpu"
|
|
self._SELECTABLE_COMPUTE_DEVICE_LIST = getComputeDeviceList()
|
|
self._SEND_MESSAGE_BUTTON_TYPE_LIST = ["show", "hide", "show_and_disable_enter_key"]
|
|
|
|
# Read Write
|
|
self._ENABLE_TRANSLATION = False
|
|
self._ENABLE_TRANSCRIPTION_SEND = False
|
|
self._ENABLE_TRANSCRIPTION_RECEIVE = False
|
|
self._ENABLE_FOREGROUND = False
|
|
self._ENABLE_CHECK_ENERGY_SEND = False
|
|
self._ENABLE_CHECK_ENERGY_RECEIVE = False
|
|
self._SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT = {}
|
|
for weight_type in self.SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_LIST:
|
|
self._SELECTABLE_CTRANSLATE2_WEIGHT_TYPE_DICT[weight_type] = False
|
|
self._SELECTABLE_WHISPER_WEIGHT_TYPE_DICT = {}
|
|
for weight_type in self.SELECTABLE_WHISPER_WEIGHT_TYPE_LIST:
|
|
self._SELECTABLE_WHISPER_WEIGHT_TYPE_DICT[weight_type] = False
|
|
self._SELECTABLE_TRANSLATION_ENGINE_STATUS = {}
|
|
for engine in self.SELECTABLE_TRANSLATION_ENGINE_LIST:
|
|
self._SELECTABLE_TRANSLATION_ENGINE_STATUS[engine] = False
|
|
self._SELECTABLE_TRANSCRIPTION_ENGINE_STATUS = {}
|
|
for engine in self.SELECTABLE_TRANSCRIPTION_ENGINE_LIST:
|
|
self._SELECTABLE_TRANSCRIPTION_ENGINE_STATUS[engine] = False
|
|
self._SELECTABLE_PLAMO_MODEL_LIST = []
|
|
self._SELECTABLE_GEMINI_MODEL_LIST = []
|
|
self._SELECTABLE_OPENAI_MODEL_LIST = []
|
|
self._SELECTABLE_LMSTUDIO_MODEL_LIST = []
|
|
self._SELECTABLE_OLLAMA_MODEL_LIST = []
|
|
|
|
# Save Json Data
|
|
## Main Window
|
|
self._SELECTED_TAB_NO = "1"
|
|
self._SELECTED_TRANSLATION_ENGINES = {}
|
|
for tab_no in self.SELECTABLE_TAB_NO_LIST:
|
|
self._SELECTED_TRANSLATION_ENGINES[tab_no] = "CTranslate2"
|
|
self._SELECTED_YOUR_LANGUAGES = {}
|
|
for tab_no in self.SELECTABLE_TAB_NO_LIST:
|
|
self._SELECTED_YOUR_LANGUAGES[tab_no] = {
|
|
"1": {
|
|
"language": "Japanese",
|
|
"country": "Japan",
|
|
"enable": True,
|
|
},
|
|
}
|
|
self._SELECTED_TARGET_LANGUAGES = {}
|
|
self._SELECTED_TAB_TARGET_LANGUAGES_NO_LIST = ["1", "2", "3"]
|
|
for tab_no in self.SELECTABLE_TAB_NO_LIST:
|
|
for tab_target_lang_no in self.SELECTED_TAB_TARGET_LANGUAGES_NO_LIST:
|
|
if tab_no not in self.SELECTED_TARGET_LANGUAGES:
|
|
self._SELECTED_TARGET_LANGUAGES[tab_no] = {}
|
|
if tab_target_lang_no not in self.SELECTED_TARGET_LANGUAGES[tab_no]:
|
|
self._SELECTED_TARGET_LANGUAGES[tab_no][tab_target_lang_no] = {
|
|
"language": "English",
|
|
"country": "United States",
|
|
"enable": True if tab_target_lang_no == self.SELECTED_TAB_TARGET_LANGUAGES_NO_LIST[0] else False,
|
|
}
|
|
self._SELECTED_TRANSCRIPTION_ENGINE = "Google"
|
|
self._CONVERT_MESSAGE_TO_ROMAJI = False
|
|
self._CONVERT_MESSAGE_TO_HIRAGANA = False
|
|
self._MAIN_WINDOW_SIDEBAR_COMPACT_MODE = False
|
|
|
|
## Config Window
|
|
self._TRANSPARENCY = 100
|
|
self._UI_SCALING = 100
|
|
self._TEXTBOX_UI_SCALING = 100
|
|
self._MESSAGE_BOX_RATIO = 10
|
|
self._SEND_MESSAGE_BUTTON_TYPE = "show"
|
|
self._SHOW_RESEND_BUTTON = False
|
|
self._FONT_FAMILY = "Yu Gothic UI"
|
|
self._UI_LANGUAGE = "en"
|
|
self._MAIN_WINDOW_GEOMETRY = {
|
|
"x_pos": 0,
|
|
"y_pos": 0,
|
|
"width": 870,
|
|
"height": 654,
|
|
}
|
|
self._AUTO_MIC_SELECT = True
|
|
# device_manager may be unavailable or not initialized; use safe defaults
|
|
try:
|
|
if device_manager is not None:
|
|
# getDefaultMicDevice performs lazy init/update if needed
|
|
dm_def = device_manager.getDefaultMicDevice()
|
|
self._SELECTED_MIC_HOST = dm_def.get("host", {}).get("name", "NoHost")
|
|
self._SELECTED_MIC_DEVICE = dm_def.get("device", {}).get("name", "NoDevice")
|
|
else:
|
|
self._SELECTED_MIC_HOST = "NoHost"
|
|
self._SELECTED_MIC_DEVICE = "NoDevice"
|
|
except Exception:
|
|
errorLogging()
|
|
self._SELECTED_MIC_HOST = "NoHost"
|
|
self._SELECTED_MIC_DEVICE = "NoDevice"
|
|
self._MIC_THRESHOLD = 300
|
|
self._MIC_AUTOMATIC_THRESHOLD = False
|
|
self._MIC_RECORD_TIMEOUT = 3
|
|
self._MIC_PHRASE_TIMEOUT = 3
|
|
self._MIC_MAX_PHRASES = 10
|
|
self._MIC_WORD_FILTER = []
|
|
self._HOTKEYS = {
|
|
"toggle_vrct_visibility": None,
|
|
"toggle_translation": None,
|
|
"toggle_transcription_send": None,
|
|
"toggle_transcription_receive": None,
|
|
}
|
|
self._PLUGINS_STATUS = []
|
|
self._MIC_AVG_LOGPROB = -0.8
|
|
self._MIC_NO_SPEECH_PROB = 0.6
|
|
self._MIC_NO_REPEAT_NGRAM_SIZE = 0
|
|
self._MIC_VAD_FILTER = False
|
|
self._MIC_VAD_PARAMETERS = {
|
|
"threshold": 0.5,
|
|
"neg_threshold": None,
|
|
"min_speech_duration_ms": 0,
|
|
"max_speech_duration_s": float("inf"),
|
|
"min_silence_duration_ms": 2000,
|
|
"speech_pad_ms": 400,
|
|
}
|
|
self._AUTO_SPEAKER_SELECT = True
|
|
try:
|
|
if device_manager is not None:
|
|
sp_def = device_manager.getDefaultSpeakerDevice()
|
|
self._SELECTED_SPEAKER_DEVICE = sp_def.get("device", {}).get("name", "NoDevice")
|
|
else:
|
|
self._SELECTED_SPEAKER_DEVICE = "NoDevice"
|
|
except Exception:
|
|
errorLogging()
|
|
self._SELECTED_SPEAKER_DEVICE = "NoDevice"
|
|
self._SPEAKER_THRESHOLD = 300
|
|
self._SPEAKER_AUTOMATIC_THRESHOLD = False
|
|
self._SPEAKER_RECORD_TIMEOUT = 3
|
|
self._SPEAKER_PHRASE_TIMEOUT = 3
|
|
self._SPEAKER_MAX_PHRASES = 10
|
|
self._SPEAKER_AVG_LOGPROB = -0.8
|
|
self._SPEAKER_NO_SPEECH_PROB = 0.6
|
|
self._SPEAKER_NO_REPEAT_NGRAM_SIZE = 0
|
|
self._SPEAKER_VAD_FILTER = False
|
|
self._SPEAKER_VAD_PARAMETERS = {
|
|
"threshold": 0.5,
|
|
"neg_threshold": None,
|
|
"min_speech_duration_ms": 0,
|
|
"max_speech_duration_s": float("inf"),
|
|
"min_silence_duration_ms": 2000,
|
|
"speech_pad_ms": 400,
|
|
}
|
|
self._OSC_IP_ADDRESS = "127.0.0.1"
|
|
self._OSC_PORT = 9000
|
|
self._AUTH_KEYS = {
|
|
"DeepL_API": None,
|
|
"Plamo_API": None,
|
|
"Gemini_API": None,
|
|
"OpenAI_API": None,
|
|
}
|
|
self._USE_EXCLUDE_WORDS = True
|
|
self._SELECTED_TRANSLATION_COMPUTE_DEVICE = copy.deepcopy(self.SELECTABLE_COMPUTE_DEVICE_LIST[0])
|
|
self._SELECTED_TRANSCRIPTION_COMPUTE_DEVICE = copy.deepcopy(self.SELECTABLE_COMPUTE_DEVICE_LIST[0])
|
|
self._CTRANSLATE2_WEIGHT_TYPE = "m2m100_418M-ct2-int8"
|
|
self._SELECTED_PLAMO_MODEL = None
|
|
self._SELECTED_GEMINI_MODEL = None
|
|
self._SELECTED_OPENAI_MODEL = None
|
|
self._LMSTUDIO_URL = "http://127.0.0.1:1234/v1"
|
|
self._SELECTED_LMSTUDIO_MODEL = None
|
|
self._SELECTED_OLLAMA_MODEL = None
|
|
self._SELECTED_TRANSLATION_COMPUTE_TYPE = "auto"
|
|
self._WHISPER_WEIGHT_TYPE = "base"
|
|
self._SELECTED_TRANSCRIPTION_COMPUTE_TYPE = "auto"
|
|
self._AUTO_CLEAR_MESSAGE_BOX = True
|
|
self._SEND_ONLY_TRANSLATED_MESSAGES = False
|
|
self._OVERLAY_SMALL_LOG = False
|
|
self._OVERLAY_SMALL_LOG_SETTINGS = {
|
|
"x_pos": 0.0,
|
|
"y_pos": 0.0,
|
|
"z_pos": 0.0,
|
|
"x_rotation": 0.0,
|
|
"y_rotation": 0.0,
|
|
"z_rotation": 0.0,
|
|
"display_duration": 5,
|
|
"fadeout_duration": 2,
|
|
"opacity": 1.0,
|
|
"ui_scaling": 1.0,
|
|
"tracker": "HMD",
|
|
}
|
|
self._OVERLAY_LARGE_LOG = False
|
|
self._OVERLAY_LARGE_LOG_SETTINGS = {
|
|
"x_pos": 0.0,
|
|
"y_pos": 0.0,
|
|
"z_pos": 0.0,
|
|
"x_rotation": 0.0,
|
|
"y_rotation": 0.0,
|
|
"z_rotation": 0.0,
|
|
"display_duration": 5,
|
|
"fadeout_duration": 2,
|
|
"opacity": 1.0,
|
|
"ui_scaling": 1.0,
|
|
"tracker": "LeftHand",
|
|
}
|
|
self._OVERLAY_SHOW_ONLY_TRANSLATED_MESSAGES = False
|
|
self._SEND_MESSAGE_TO_VRC = True
|
|
self._SEND_RECEIVED_MESSAGE_TO_VRC = False
|
|
self._LOGGER_FEATURE = False
|
|
self._VRC_MIC_MUTE_SYNC = False
|
|
self._NOTIFICATION_VRC_SFX = True
|
|
self._SEND_MESSAGE_FORMAT_PARTS = {
|
|
"message": {
|
|
"prefix": "",
|
|
"suffix": ""
|
|
},
|
|
"separator": "\n",
|
|
"translation": {
|
|
"prefix": "",
|
|
"separator": "\n",
|
|
"suffix": ""
|
|
},
|
|
"translation_first": False,
|
|
}
|
|
self._RECEIVED_MESSAGE_FORMAT_PARTS = {
|
|
"message": {
|
|
"prefix": "",
|
|
"suffix": ""
|
|
},
|
|
"separator": "\n",
|
|
"translation": {
|
|
"prefix": "",
|
|
"separator": "\n",
|
|
"suffix": ""
|
|
},
|
|
"translation_first": False,
|
|
}
|
|
self._WEBSOCKET_SERVER = False
|
|
self._WEBSOCKET_HOST = "127.0.0.1"
|
|
self._WEBSOCKET_PORT = 2231
|
|
self._ENABLE_COPY_TO_CLIPBOARD = False
|
|
self._ENABLE_PASTE_FROM_CLIPBOARD = False
|
|
|
|
def load_config(self):
|
|
if os_path.isfile(self.PATH_CONFIG) is not False:
|
|
with open(self.PATH_CONFIG, 'r', encoding="utf-8") as fp:
|
|
if fp.readable() and fp.seek(0, 2) > 0:
|
|
fp.seek(0)
|
|
self._config_data = json_load(fp)
|
|
|
|
for key, value in self._config_data.items():
|
|
try:
|
|
setattr(self, key, value)
|
|
except Exception:
|
|
errorLogging()
|
|
|
|
with open(self.PATH_CONFIG, 'w', encoding="utf-8") as fp:
|
|
for var_name, var_func in json_serializable_vars.items():
|
|
self._config_data[var_name] = var_func(self)
|
|
json_dump(self._config_data, fp, indent=4, ensure_ascii=False)
|
|
|
|
# Auto-register all descriptors after Config class definition
|
|
_auto_register_descriptors()
|
|
|
|
config = Config()
|
|
|
|
if __name__ == "__main__":
|
|
print("Test config.py")
|
|
for key, value in config._config_data.items():
|
|
print(f"{key}: {value}") |