Added a new Lexicon feature.

Author: CoffeeMethod

gui.py

@@ -187,7 +187,8 @@ def load_settings(self):
             "combine": True,
             "export_subtitles": False,
             "normalize": False,
-            "trim": False
+            "trim": False,
+            "lexicon": {}
         }
         if os.path.exists(CONFIG_FILE):
             try:
@@ -677,6 +678,75 @@ def on_lang_ui_change(choice):
 
         ctk.CTkLabel(thread_frame, text="(More threads = High RAM usage)", text_color="orange").pack(side="left", padx=10)
 
+    def build_lexicon_tab(self, parent):
+        parent.grid_columnconfigure(0, weight=1)
+        parent.grid_rowconfigure(1, weight=1) # List area expands
+
+        # 1. Add New Entry
+        add_frame = ctk.CTkFrame(parent)
+        add_frame.grid(row=0, column=0, sticky="ew", padx=10, pady=10)
+        
+        ctk.CTkLabel(add_frame, text="Original Text:").pack(side="left", padx=5)
+        self.lex_orig_var = ctk.StringVar()
+        ctk.CTkEntry(add_frame, textvariable=self.lex_orig_var, width=150).pack(side="left", padx=5)
+        
+        ctk.CTkLabel(add_frame, text="Replacement:").pack(side="left", padx=5)
+        self.lex_replace_var = ctk.StringVar()
+        ctk.CTkEntry(add_frame, textvariable=self.lex_replace_var, width=150).pack(side="left", padx=5)
+        
+        ctk.CTkButton(add_frame, text="Add Rule", command=self.add_lexicon_rule).pack(side="left", padx=10)
+
+        # 2. List
+        self.lex_list_frame = ctk.CTkScrollableFrame(parent)
+        self.lex_list_frame.grid(row=1, column=0, sticky="nsew", padx=10, pady=5)
+        
+        self.refresh_lexicon_list()
+        
+        # 3. Help Text
+        ctk.CTkLabel(parent, text="Note: Replacements are case-insensitive. Applied before generation.", text_color="gray").grid(row=2, column=0, pady=5)
+
+    def add_lexicon_rule(self):
+        orig = self.lex_orig_var.get().strip()
+        rep = self.lex_replace_var.get().strip()
+        
+        if not orig:
+            messagebox.showwarning("Error", "Original text cannot be empty.")
+            return
+            
+        if "lexicon" not in self.settings:
+            self.settings["lexicon"] = {}
+            
+        self.settings["lexicon"][orig] = rep
+        self.lex_orig_var.set("")
+        self.lex_replace_var.set("")
+        self.save_settings()
+        self.refresh_lexicon_list()
+
+    def delete_lexicon_rule(self, key):
+        if key in self.settings.get("lexicon", {}):
+            del self.settings["lexicon"][key]
+            self.save_settings()
+            self.refresh_lexicon_list()
+
+    def refresh_lexicon_list(self):
+        for widget in self.lex_list_frame.winfo_children():
+            widget.destroy()
+            
+        lexicon = self.settings.get("lexicon", {})
+        if not lexicon:
+            ctk.CTkLabel(self.lex_list_frame, text="No rules defined.", text_color="gray").pack(pady=10)
+            return
+
+        for i, (orig, rep) in enumerate(lexicon.items()):
+            row = ctk.CTkFrame(self.lex_list_frame)
+            row.pack(fill="x", pady=2)
+            
+            ctk.CTkLabel(row, text=orig, width=150, anchor="w", font=("Consolas", 12)).pack(side="left", padx=10)
+            ctk.CTkLabel(row, text="->", width=30).pack(side="left")
+            ctk.CTkLabel(row, text=rep, width=150, anchor="w", font=("Consolas", 12)).pack(side="left", padx=10)
+            
+            ctk.CTkButton(row, text="X", width=30, fg_color="#c42b1c", command=lambda k=orig: self.delete_lexicon_rule(k)).pack(side="right", padx=5)
+
     def create_widgets(self):
         # Header
         self.grid_columnconfigure(0, weight=1)
@@ -699,6 +769,9 @@ def create_widgets(self):
         mix_tab = self.main_tabs.add("Custom Voice")
         self.build_mixing_tab(mix_tab)
 
+        lex_tab = self.main_tabs.add("Lexicon")
+        self.build_lexicon_tab(lex_tab)
+
         # Actions (Global)
         action_frame = ctk.CTkFrame(self)
         action_frame.grid(row=2, column=0, sticky="ew", padx=10, pady=10)
@@ -864,7 +937,8 @@ def preview_conversion(self):
             'volume': self.volume_var.get(),
             'pitch': self.pitch_var.get(),
             'normalize': self.normalize_audio.get(),
-            'trim_silence': self.trim_silence.get()
+            'trim_silence': self.trim_silence.get(),
+            'lexicon': self.settings.get('lexicon', {})
         }
 
         # Temp file
@@ -941,7 +1015,8 @@ def start_conversion(self):
             'volume': self.volume_var.get(),
             'pitch': self.pitch_var.get(),
             'normalize': self.normalize_audio.get(),
-            'trim_silence': self.trim_silence.get()
+            'trim_silence': self.trim_silence.get(),
+            'lexicon': self.settings.get('lexicon', {})
         }
 
         # 3. Start

kokoro_engine.py

@@ -68,6 +68,25 @@ def __init__(self):
         self.on_status = None   # func(msg, is_error)
         self.on_finish = None   # func()
 
+    def apply_lexicon(self, text, lexicon):
+        """
+        Applies a dictionary of replacements to the text.
+        Case-insensitive finding, preserves case of replacement.
+        """
+        if not lexicon:
+            return text
+        
+        for src, dest in lexicon.items():
+            if not src: continue
+            try:
+                # Escape the search term to treat it as literal text
+                pattern = re.compile(re.escape(src), re.IGNORECASE)
+                text = pattern.sub(dest, text)
+            except Exception as e:
+                print(f"Lexicon error for '{src}': {e}")
+                
+        return text
+
     def resolve_voice_path(self, voice_name):
         """
         Returns the absolute path if it's a custom voice, 
@@ -206,6 +225,10 @@ def _gen():
                 all_pieces = []
 
                 for speaker_name, segment_text in ms_segments:
+                    # Apply Lexicon if provided in extra_config
+                    if extra_config and 'lexicon' in extra_config:
+                        segment_text = self.apply_lexicon(segment_text, extra_config['lexicon'])
+
                     # Truncate segment text if too long for preview
                     if len(segment_text) > 500:
                         segment_text = segment_text[:500]
@@ -457,7 +480,12 @@ async def _process_text_async(self, text, config):
             ms_segments = self.parse_multispeaker_text(text)
             tasks_data = []
 
+            lexicon = config.get('lexicon', {})
+
             for speaker_name, segment_text in ms_segments:
+                # Apply Lexicon
+                segment_text = self.apply_lexicon(segment_text, lexicon)
+
                 seg_config = config.copy()
                 if speaker_name:
                     preset = self.load_preset(speaker_name)