pomera-ai-commander 1.1.1 → 1.2.2

package/tools/translator_tools.py

@@ -1,523 +1,523 @@
-"""
-Translator Tools Module - Binary and Morse code translation utilities
-
-This module provides comprehensive translation functionality with a tabbed UI interface
-for the Promera AI Commander application.
-"""
-
-import tkinter as tk
-from tkinter import ttk, messagebox
-import base64
-import threading
-import time
-
-# Try to import NumPy for Morse code audio generation
-try:
-    import numpy as np
-    NUMPY_AVAILABLE = True
-except ImportError:
-    NUMPY_AVAILABLE = False
-
-# Try to import PyAudio for Morse code audio
-try:
-    import pyaudio
-    PYAUDIO_AVAILABLE = True
-except ImportError:
-    PYAUDIO_AVAILABLE = False
-
-
-class TranslatorToolsProcessor:
-    """Translator tools processor with binary and Morse code translation capabilities."""
-    
-    # Morse code dictionary
-    MORSE_CODE_DICT = {
-        'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.', 'H': '....',
-        'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.', 'O': '---', 'P': '.--.',
-        'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-',
-        'Y': '-.--', 'Z': '--..', '1': '.----', '2': '..---', '3': '...--', '4': '....-', '5': '.....',
-        '6': '-....', '7': '--...', '8': '---..', '9': '----.', '0': '-----', ' ': '/',
-        ',': '--..--', '.': '.-.-.-', '?': '..--..', '/': '-..-.', '-': '-....-', '(': '-.--.', ')': '-.--.-'
-    }
-    
-    REVERSED_MORSE_DICT = {v: k for k, v in MORSE_CODE_DICT.items()}
-    
-    # Audio constants
-    MORSE_DOT_DURATION = 0.080
-    MORSE_DASH_DURATION = 0.080 * 3
-    SAMPLE_RATE = 44100
-    TONE_FREQUENCY = 700
-
-    @staticmethod
-    def morse_translator(text, mode):
-        """Translates text to or from Morse code."""
-        if mode == "morse":
-            return ' '.join(TranslatorToolsProcessor.MORSE_CODE_DICT.get(char.upper(), '') for char in text)
-        else:  # mode == "text"
-            return ''.join(TranslatorToolsProcessor.REVERSED_MORSE_DICT.get(code, '') for code in text.split(' '))
-
-    @staticmethod
-    def binary_translator(text):
-        """Translates text to or from binary."""
-        # Detect if input is binary or text
-        if all(c in ' 01' for c in text):  # Binary to Text
-            try:
-                return ''.join(chr(int(b, 2)) for b in text.split())
-            except (ValueError, TypeError):
-                return "Error: Invalid binary sequence."
-        else:  # Text to Binary
-            return ' '.join(format(ord(char), '08b') for char in text)
-
-    @staticmethod
-    def process_text(input_text, tool_type, settings):
-        """Process text using the specified translator tool and settings."""
-        if tool_type == "Morse Code Translator":
-            return TranslatorToolsProcessor.morse_translator(
-                input_text, 
-                settings.get("mode", "morse")
-            )
-        elif tool_type == "Binary Code Translator":
-            return TranslatorToolsProcessor.binary_translator(input_text)
-        else:
-            return f"Unknown translator tool: {tool_type}"
-
-
-class TranslatorToolsWidget(ttk.Frame):
-    """Tabbed interface widget for translator tools, similar to Sorter Tools."""
-    
-    def __init__(self, parent, app, dialog_manager=None):
-        super().__init__(parent)
-        self.app = app
-        self.dialog_manager = dialog_manager
-        self.processor = TranslatorToolsProcessor()
-        
-        # Initialize UI variables for Morse Code Translator
-        self.morse_mode = tk.StringVar(value="morse")
-        
-        # Audio-related variables
-        self.morse_thread = None
-        self.stop_morse_playback = threading.Event()
-        self.audio_stream = None
-        self.pyaudio_instance = None
-        
-        # Initialize PyAudio if available
-        self.setup_audio()
-        
-        self.create_widgets()
-        self.load_settings()
-    
-    def _show_error(self, title, message):
-        """Show error dialog using DialogManager if available, otherwise use messagebox."""
-        if self.dialog_manager:
-            return self.dialog_manager.show_error(title, message, parent=self.winfo_toplevel())
-        else:
-            from tkinter import messagebox
-            messagebox.showerror(title, message, parent=self.winfo_toplevel())
-            return True
-    
-    def _show_audio_setup_instructions(self, missing_library):
-        """Show detailed instructions for setting up audio features."""
-        title = "Audio Feature Setup Required"
-        
-        if missing_library == "NumPy":
-            message = """Morse Code Audio is not available in this optimized build.
-
-To enable audio features, you have two options:
-
-OPTION 1: Run from Source (Recommended)
-1. Download Python 3.8+ from python.org
-2. Install required libraries:
-   pip install numpy pyaudio
-3. Download source code from GitHub
-4. Run: python pomera.py
-
-OPTION 2: Use Text-Only Mode
-• Morse code text translation works perfectly
-• Copy the Morse code and use external audio tools
-• This keeps the executable small (40MB vs 400MB+)
-
-The current executable was optimized for size by excluding
-audio libraries. Text-based Morse code works fully!"""
-        
-        else:  # PyAudio
-            message = """Audio playback is not available.
-
-To enable Morse code audio:
-
-OPTION 1: Install Audio Libraries
-1. Install Python 3.8+ from python.org
-2. Install audio libraries:
-   pip install pyaudio numpy
-3. Run from source: python pomera.py
-
-OPTION 2: Use Text-Only Mode
-• All Morse code translation features work
-• Copy output to external audio tools if needed
-
-Note: Audio libraries were excluded to keep the
-executable small and portable."""
-        
-        if self.dialog_manager:
-            return self.dialog_manager.show_info(title, message, parent=self.winfo_toplevel())
-        else:
-            from tkinter import messagebox
-            messagebox.showinfo(title, message, parent=self.winfo_toplevel())
-            return True
-
-    def setup_audio(self):
-        """Initialize PyAudio for Morse code audio playback."""
-        if not PYAUDIO_AVAILABLE:
-            return
-            
-        try:
-            self.pyaudio_instance = pyaudio.PyAudio()
-            self.audio_stream = self.pyaudio_instance.open(
-                format=pyaudio.paFloat32,
-                channels=1,
-                rate=TranslatorToolsProcessor.SAMPLE_RATE,
-                output=True
-            )
-        except Exception as e:
-            print(f"Failed to initialize PyAudio: {e}")
-            self.pyaudio_instance = None
-            self.audio_stream = None
-
-    def create_widgets(self):
-        """Creates the tabbed interface for translator tools."""
-        # Create notebook for tabs
-        self.notebook = ttk.Notebook(self)
-        self.notebook.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
-        
-        # Create Morse Code Translator tab
-        self.morse_frame = ttk.Frame(self.notebook)
-        self.notebook.add(self.morse_frame, text="Morse Code Translator")
-        self.create_morse_translator_widgets()
-        
-        # Create Binary Code Translator tab
-        self.binary_frame = ttk.Frame(self.notebook)
-        self.notebook.add(self.binary_frame, text="Binary Code Translator")
-        self.create_binary_translator_widgets()
-
-    def create_morse_translator_widgets(self):
-        """Creates widgets for the Morse Code Translator tab."""
-        # Mode selection
-        mode_frame = ttk.LabelFrame(self.morse_frame, text="Translation Mode", padding=10)
-        mode_frame.pack(fill=tk.X, padx=5, pady=5)
-        
-        ttk.Radiobutton(
-            mode_frame, 
-            text="Text to Morse", 
-            variable=self.morse_mode, 
-            value="morse", 
-            command=self._on_setting_change
-        ).pack(side=tk.LEFT, padx=5)
-        
-        ttk.Radiobutton(
-            mode_frame, 
-            text="Morse to Text", 
-            variable=self.morse_mode, 
-            value="text", 
-            command=self._on_setting_change
-        ).pack(side=tk.LEFT, padx=5)
-        
-        # Buttons
-        button_frame = ttk.Frame(self.morse_frame)
-        button_frame.pack(fill=tk.X, padx=5, pady=5)
-        
-        ttk.Button(
-            button_frame, 
-            text="Translate", 
-            command=self._apply_morse_translator
-        ).pack(side=tk.LEFT, padx=5)
-        
-        # Audio button (only if PyAudio is available)
-        if PYAUDIO_AVAILABLE and self.audio_stream:
-            self.play_morse_button = ttk.Button(
-                button_frame, 
-                text="Play Morse Audio", 
-                command=self._play_morse_audio
-            )
-            self.play_morse_button.pack(side=tk.LEFT, padx=5)
-
-    def create_binary_translator_widgets(self):
-        """Creates widgets for the Binary Code Translator tab."""
-        # Info label
-        info_frame = ttk.LabelFrame(self.binary_frame, text="Information", padding=10)
-        info_frame.pack(fill=tk.X, padx=5, pady=5)
-        
-        info_label = ttk.Label(
-            info_frame, 
-            text="Automatically detects input type:\n• Text → Binary (8-bit per character)\n• Binary → Text (space-separated binary)"
-        )
-        info_label.pack()
-        
-        # Button
-        button_frame = ttk.Frame(self.binary_frame)
-        button_frame.pack(fill=tk.X, padx=5, pady=5)
-        
-        ttk.Button(
-            button_frame, 
-            text="Translate", 
-            command=self._apply_binary_translator
-        ).pack(side=tk.LEFT, padx=5)
-
-    def _on_setting_change(self):
-        """Handle setting changes."""
-        self.save_settings()
-        if hasattr(self.app, 'on_tool_setting_change'):
-            self.app.on_tool_setting_change()
-
-    def _apply_morse_translator(self):
-        """Apply the Morse Code Translator tool."""
-        self._apply_tool("Morse Code Translator")
-
-    def _apply_binary_translator(self):
-        """Apply the Binary Code Translator tool."""
-        self._apply_tool("Binary Code Translator")
-
-    def _apply_tool(self, tool_type):
-        """Apply the specified translator tool."""
-        try:
-            # Get input text from the active input tab
-            active_input_tab = self.app.input_tabs[self.app.input_notebook.index(self.app.input_notebook.select())]
-            input_text = active_input_tab.text.get("1.0", tk.END).strip()
-            
-            if not input_text:
-                # Show a message if no input text
-                active_output_tab = self.app.output_tabs[self.app.output_notebook.index(self.app.output_notebook.select())]
-                active_output_tab.text.config(state="normal")
-                active_output_tab.text.delete("1.0", tk.END)
-                active_output_tab.text.insert("1.0", f"Please enter text to translate in the input area.\n\nFor {tool_type}:\n" + 
-                    ("- Enter text to convert to Morse code, or Morse code to convert to text" if tool_type == "Morse Code Translator" 
-                     else "- Enter text to convert to binary, or binary code to convert to text"))
-                active_output_tab.text.config(state="disabled")
-                return
-            
-            # Get settings for the tool
-            settings = self.get_tool_settings(tool_type)
-            
-            # Process the text
-            result = self.processor.process_text(input_text, tool_type, settings)
-            
-            # Update output
-            active_output_tab = self.app.output_tabs[self.app.output_notebook.index(self.app.output_notebook.select())]
-            active_output_tab.text.config(state="normal")
-            active_output_tab.text.delete("1.0", tk.END)
-            active_output_tab.text.insert("1.0", result)
-            active_output_tab.text.config(state="disabled")
-            
-            # Update statistics
-            if hasattr(self.app, 'update_all_stats'):
-                self.app.after(10, self.app.update_all_stats)
-                
-        except Exception as e:
-            # Show error in output if something goes wrong
-            try:
-                active_output_tab = self.app.output_tabs[self.app.output_notebook.index(self.app.output_notebook.select())]
-                active_output_tab.text.config(state="normal")
-                active_output_tab.text.delete("1.0", tk.END)
-                active_output_tab.text.insert("1.0", f"Error: {str(e)}")
-                active_output_tab.text.config(state="disabled")
-            except:
-                print(f"Translator Tools Error: {str(e)}")  # Fallback to console
-
-    def _play_morse_audio(self):
-        """Play Morse code audio from the output area."""
-        if self.morse_thread and self.morse_thread.is_alive():
-            print("Morse playback is already in progress.")
-            return
-            
-        if not PYAUDIO_AVAILABLE or not self.audio_stream:
-            self._show_audio_setup_instructions("PyAudio")
-            return
-            
-        if not NUMPY_AVAILABLE:
-            self._show_audio_setup_instructions("NumPy")
-            return
-
-        active_output_tab = self.app.output_tabs[self.app.output_notebook.index(self.app.output_notebook.select())]
-        morse_code = active_output_tab.text.get("1.0", tk.END).strip()
-        if not morse_code:
-            print("No Morse code to play.")
-            return
-            
-        self.stop_morse_playback.clear()
-        self.morse_thread = threading.Thread(target=self._play_morse_thread, args=(morse_code,), daemon=True)
-        self.morse_thread.start()
-
-    def _stop_morse_audio(self):
-        """Stop the currently playing Morse code audio."""
-        self.stop_morse_playback.set()
-
-    def _play_morse_thread(self, morse_code):
-        """The actual playback logic that runs in a thread."""
-        if hasattr(self, 'play_morse_button'):
-            self.play_morse_button.config(text="Stop Playing", command=self._stop_morse_audio)
-        print("Starting Morse code playback.")
-
-        try:
-            for char in morse_code:
-                if self.stop_morse_playback.is_set():
-                    print("Morse playback stopped by user.")
-                    break
-                if char == '.':
-                    tone = self._generate_morse_tone(TranslatorToolsProcessor.MORSE_DOT_DURATION)
-                    self.audio_stream.write(tone.tobytes())
-                    time.sleep(TranslatorToolsProcessor.MORSE_DOT_DURATION)
-                elif char == '-':
-                    tone = self._generate_morse_tone(TranslatorToolsProcessor.MORSE_DASH_DURATION)
-                    self.audio_stream.write(tone.tobytes())
-                    time.sleep(TranslatorToolsProcessor.MORSE_DOT_DURATION)
-                elif char == ' ':
-                    time.sleep(TranslatorToolsProcessor.MORSE_DOT_DURATION * 3 - TranslatorToolsProcessor.MORSE_DOT_DURATION)
-                elif char == '/':
-                    time.sleep(TranslatorToolsProcessor.MORSE_DOT_DURATION * 7 - TranslatorToolsProcessor.MORSE_DOT_DURATION)
-        except Exception as e:
-            print(f"Error during morse playback: {e}")
-        finally:
-            if hasattr(self, 'play_morse_button'):
-                self.play_morse_button.config(text="Play Morse Audio", command=self._play_morse_audio)
-            print("Morse code playback finished.")
-            self.stop_morse_playback.clear()
-
-    def _generate_morse_tone(self, duration):
-        """Generate a sine wave for a given duration for Morse code."""
-        if not NUMPY_AVAILABLE:
-            # Return silence if numpy is not available
-            import array
-            sample_count = int(TranslatorToolsProcessor.SAMPLE_RATE * duration)
-            return array.array('f', [0.0] * sample_count)
-        
-        tone_freq = TranslatorToolsProcessor.TONE_FREQUENCY
-        t = np.linspace(0, duration, int(TranslatorToolsProcessor.SAMPLE_RATE * duration), False)
-        tone = np.sin(tone_freq * t * 2 * np.pi)
-        return (0.5 * tone).astype(np.float32)
-
-    def get_tool_settings(self, tool_type):
-        """Get settings for the specified tool."""
-        if tool_type == "Morse Code Translator":
-            return {
-                "mode": self.morse_mode.get()
-            }
-        elif tool_type == "Binary Code Translator":
-            return {}  # Binary translator doesn't have settings
-        return {}
-
-    def get_all_settings(self):
-        """Get all settings for both translator tools."""
-        return {
-            "Morse Code Translator": self.get_tool_settings("Morse Code Translator"),
-            "Binary Code Translator": self.get_tool_settings("Binary Code Translator")
-        }
-
-    def load_settings(self):
-        """Load settings from the main application."""
-        if not hasattr(self.app, 'settings'):
-            return
-            
-        # Load Morse Code Translator settings
-        morse_settings = self.app.settings.get("tool_settings", {}).get("Morse Code Translator", {})
-        self.morse_mode.set(morse_settings.get("mode", "morse"))
-
-    def save_settings(self):
-        """Save settings to the main application."""
-        if not hasattr(self.app, 'settings'):
-            return
-            
-        # Save Morse Code Translator settings
-        if "Morse Code Translator" not in self.app.settings["tool_settings"]:
-            self.app.settings["tool_settings"]["Morse Code Translator"] = {}
-        self.app.settings["tool_settings"]["Morse Code Translator"]["mode"] = self.morse_mode.get()
-
-    def __del__(self):
-        """Cleanup audio resources when widget is destroyed."""
-        if self.audio_stream:
-            try:
-                self.audio_stream.stop_stream()
-                self.audio_stream.close()
-            except:
-                pass
-        if self.pyaudio_instance:
-            try:
-                self.pyaudio_instance.terminate()
-            except:
-                pass
-
-
-class TranslatorTools:
-    """Main Translator Tools class that provides the interface for the main application."""
-    
-    def __init__(self):
-        self.processor = TranslatorToolsProcessor()
-        self.widget = None
-        
-    def create_widget(self, parent, app, dialog_manager=None):
-        """Create and return the tabbed widget component."""
-        self.widget = TranslatorToolsWidget(parent, app, dialog_manager)
-        return self.widget
-        
-    def process_text(self, input_text, tool_type, settings):
-        """Process text using the specified translator tool and settings."""
-        return self.processor.process_text(input_text, tool_type, settings)
-        
-    def get_default_settings(self):
-        """Get default settings for both translator tools."""
-        return {
-            "Morse Code Translator": {"mode": "morse", "tone": TranslatorToolsProcessor.TONE_FREQUENCY},
-            "Binary Code Translator": {}
-        }
-
-
-# Convenience functions for backward compatibility
-def morse_translator(text, mode, morse_dict=None, reversed_morse_dict=None):
-    """Translate text to/from Morse code."""
-    return TranslatorToolsProcessor.morse_translator(text, mode)
-
-
-def binary_translator(text):
-    """Translate text to/from binary code."""
-    return TranslatorToolsProcessor.binary_translator(text)
-
-
-# BaseTool-compatible wrapper
-try:
-    from tools.base_tool import ToolWithOptions
-    from typing import Dict, Any
-    
-    class TranslatorToolsV2(ToolWithOptions):
-        """
-        BaseTool-compatible version of TranslatorTools.
-        """
-        
-        TOOL_NAME = "Translator Tools"
-        TOOL_DESCRIPTION = "Translate text to/from Morse code and binary"
-        TOOL_VERSION = "2.0.0"
-        
-        OPTIONS = [
-            ("Text to Morse", "to_morse"),
-            ("Morse to Text", "from_morse"),
-            ("Text to Binary", "to_binary"),
-            ("Binary to Text", "from_binary"),
-        ]
-        OPTIONS_LABEL = "Translation"
-        USE_DROPDOWN = True
-        DEFAULT_OPTION = "to_morse"
-        
-        def __init__(self):
-            super().__init__()
-            self._processor = TranslatorToolsProcessor()
-        
-        def process_text(self, input_text: str, settings: Dict[str, Any]) -> str:
-            """Process text using the specified translation mode."""
-            mode = settings.get("mode", "to_morse")
-            
-            if mode == "to_morse":
-                return TranslatorToolsProcessor.morse_translator(input_text, "morse")
-            elif mode == "from_morse":
-                return TranslatorToolsProcessor.morse_translator(input_text, "text")
-            elif mode in ("to_binary", "from_binary"):
-                return TranslatorToolsProcessor.binary_translator(input_text)
-            else:
-                return input_text
-
-except ImportError:
+"""
+Translator Tools Module - Binary and Morse code translation utilities
+
+This module provides comprehensive translation functionality with a tabbed UI interface
+for the Promera AI Commander application.
+"""
+
+import tkinter as tk
+from tkinter import ttk, messagebox
+import base64
+import threading
+import time
+
+# Try to import NumPy for Morse code audio generation
+try:
+    import numpy as np
+    NUMPY_AVAILABLE = True
+except ImportError:
+    NUMPY_AVAILABLE = False
+
+# Try to import PyAudio for Morse code audio
+try:
+    import pyaudio
+    PYAUDIO_AVAILABLE = True
+except ImportError:
+    PYAUDIO_AVAILABLE = False
+
+
+class TranslatorToolsProcessor:
+    """Translator tools processor with binary and Morse code translation capabilities."""
+    
+    # Morse code dictionary
+    MORSE_CODE_DICT = {
+        'A': '.-', 'B': '-...', 'C': '-.-.', 'D': '-..', 'E': '.', 'F': '..-.', 'G': '--.', 'H': '....',
+        'I': '..', 'J': '.---', 'K': '-.-', 'L': '.-..', 'M': '--', 'N': '-.', 'O': '---', 'P': '.--.',
+        'Q': '--.-', 'R': '.-.', 'S': '...', 'T': '-', 'U': '..-', 'V': '...-', 'W': '.--', 'X': '-..-',
+        'Y': '-.--', 'Z': '--..', '1': '.----', '2': '..---', '3': '...--', '4': '....-', '5': '.....',
+        '6': '-....', '7': '--...', '8': '---..', '9': '----.', '0': '-----', ' ': '/',
+        ',': '--..--', '.': '.-.-.-', '?': '..--..', '/': '-..-.', '-': '-....-', '(': '-.--.', ')': '-.--.-'
+    }
+    
+    REVERSED_MORSE_DICT = {v: k for k, v in MORSE_CODE_DICT.items()}
+    
+    # Audio constants
+    MORSE_DOT_DURATION = 0.080
+    MORSE_DASH_DURATION = 0.080 * 3
+    SAMPLE_RATE = 44100
+    TONE_FREQUENCY = 700
+
+    @staticmethod
+    def morse_translator(text, mode):
+        """Translates text to or from Morse code."""
+        if mode == "morse":
+            return ' '.join(TranslatorToolsProcessor.MORSE_CODE_DICT.get(char.upper(), '') for char in text)
+        else:  # mode == "text"
+            return ''.join(TranslatorToolsProcessor.REVERSED_MORSE_DICT.get(code, '') for code in text.split(' '))
+
+    @staticmethod
+    def binary_translator(text):
+        """Translates text to or from binary."""
+        # Detect if input is binary or text
+        if all(c in ' 01' for c in text):  # Binary to Text
+            try:
+                return ''.join(chr(int(b, 2)) for b in text.split())
+            except (ValueError, TypeError):
+                return "Error: Invalid binary sequence."
+        else:  # Text to Binary
+            return ' '.join(format(ord(char), '08b') for char in text)
+
+    @staticmethod
+    def process_text(input_text, tool_type, settings):
+        """Process text using the specified translator tool and settings."""
+        if tool_type == "Morse Code Translator":
+            return TranslatorToolsProcessor.morse_translator(
+                input_text, 
+                settings.get("mode", "morse")
+            )
+        elif tool_type == "Binary Code Translator":
+            return TranslatorToolsProcessor.binary_translator(input_text)
+        else:
+            return f"Unknown translator tool: {tool_type}"
+
+
+class TranslatorToolsWidget(ttk.Frame):
+    """Tabbed interface widget for translator tools, similar to Sorter Tools."""
+    
+    def __init__(self, parent, app, dialog_manager=None):
+        super().__init__(parent)
+        self.app = app
+        self.dialog_manager = dialog_manager
+        self.processor = TranslatorToolsProcessor()
+        
+        # Initialize UI variables for Morse Code Translator
+        self.morse_mode = tk.StringVar(value="morse")
+        
+        # Audio-related variables
+        self.morse_thread = None
+        self.stop_morse_playback = threading.Event()
+        self.audio_stream = None
+        self.pyaudio_instance = None
+        
+        # Initialize PyAudio if available
+        self.setup_audio()
+        
+        self.create_widgets()
+        self.load_settings()
+    
+    def _show_error(self, title, message):
+        """Show error dialog using DialogManager if available, otherwise use messagebox."""
+        if self.dialog_manager:
+            return self.dialog_manager.show_error(title, message, parent=self.winfo_toplevel())
+        else:
+            from tkinter import messagebox
+            messagebox.showerror(title, message, parent=self.winfo_toplevel())
+            return True
+    
+    def _show_audio_setup_instructions(self, missing_library):
+        """Show detailed instructions for setting up audio features."""
+        title = "Audio Feature Setup Required"
+        
+        if missing_library == "NumPy":
+            message = """Morse Code Audio is not available in this optimized build.
+
+To enable audio features, you have two options:
+
+OPTION 1: Run from Source (Recommended)
+1. Download Python 3.8+ from python.org
+2. Install required libraries:
+   pip install numpy pyaudio
+3. Download source code from GitHub
+4. Run: python pomera.py
+
+OPTION 2: Use Text-Only Mode
+• Morse code text translation works perfectly
+• Copy the Morse code and use external audio tools
+• This keeps the executable small (40MB vs 400MB+)
+
+The current executable was optimized for size by excluding
+audio libraries. Text-based Morse code works fully!"""
+        
+        else:  # PyAudio
+            message = """Audio playback is not available.
+
+To enable Morse code audio:
+
+OPTION 1: Install Audio Libraries
+1. Install Python 3.8+ from python.org
+2. Install audio libraries:
+   pip install pyaudio numpy
+3. Run from source: python pomera.py
+
+OPTION 2: Use Text-Only Mode
+• All Morse code translation features work
+• Copy output to external audio tools if needed
+
+Note: Audio libraries were excluded to keep the
+executable small and portable."""
+        
+        if self.dialog_manager:
+            return self.dialog_manager.show_info(title, message, parent=self.winfo_toplevel())
+        else:
+            from tkinter import messagebox
+            messagebox.showinfo(title, message, parent=self.winfo_toplevel())
+            return True
+
+    def setup_audio(self):
+        """Initialize PyAudio for Morse code audio playback."""
+        if not PYAUDIO_AVAILABLE:
+            return
+            
+        try:
+            self.pyaudio_instance = pyaudio.PyAudio()
+            self.audio_stream = self.pyaudio_instance.open(
+                format=pyaudio.paFloat32,
+                channels=1,
+                rate=TranslatorToolsProcessor.SAMPLE_RATE,
+                output=True
+            )
+        except Exception as e:
+            print(f"Failed to initialize PyAudio: {e}")
+            self.pyaudio_instance = None
+            self.audio_stream = None
+
+    def create_widgets(self):
+        """Creates the tabbed interface for translator tools."""
+        # Create notebook for tabs
+        self.notebook = ttk.Notebook(self)
+        self.notebook.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
+        
+        # Create Morse Code Translator tab
+        self.morse_frame = ttk.Frame(self.notebook)
+        self.notebook.add(self.morse_frame, text="Morse Code Translator")
+        self.create_morse_translator_widgets()
+        
+        # Create Binary Code Translator tab
+        self.binary_frame = ttk.Frame(self.notebook)
+        self.notebook.add(self.binary_frame, text="Binary Code Translator")
+        self.create_binary_translator_widgets()
+
+    def create_morse_translator_widgets(self):
+        """Creates widgets for the Morse Code Translator tab."""
+        # Mode selection
+        mode_frame = ttk.LabelFrame(self.morse_frame, text="Translation Mode", padding=10)
+        mode_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        ttk.Radiobutton(
+            mode_frame, 
+            text="Text to Morse", 
+            variable=self.morse_mode, 
+            value="morse", 
+            command=self._on_setting_change
+        ).pack(side=tk.LEFT, padx=5)
+        
+        ttk.Radiobutton(
+            mode_frame, 
+            text="Morse to Text", 
+            variable=self.morse_mode, 
+            value="text", 
+            command=self._on_setting_change
+        ).pack(side=tk.LEFT, padx=5)
+        
+        # Buttons
+        button_frame = ttk.Frame(self.morse_frame)
+        button_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        ttk.Button(
+            button_frame, 
+            text="Translate", 
+            command=self._apply_morse_translator
+        ).pack(side=tk.LEFT, padx=5)
+        
+        # Audio button (only if PyAudio is available)
+        if PYAUDIO_AVAILABLE and self.audio_stream:
+            self.play_morse_button = ttk.Button(
+                button_frame, 
+                text="Play Morse Audio", 
+                command=self._play_morse_audio
+            )
+            self.play_morse_button.pack(side=tk.LEFT, padx=5)
+
+    def create_binary_translator_widgets(self):
+        """Creates widgets for the Binary Code Translator tab."""
+        # Info label
+        info_frame = ttk.LabelFrame(self.binary_frame, text="Information", padding=10)
+        info_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        info_label = ttk.Label(
+            info_frame, 
+            text="Automatically detects input type:\n• Text → Binary (8-bit per character)\n• Binary → Text (space-separated binary)"
+        )
+        info_label.pack()
+        
+        # Button
+        button_frame = ttk.Frame(self.binary_frame)
+        button_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        ttk.Button(
+            button_frame, 
+            text="Translate", 
+            command=self._apply_binary_translator
+        ).pack(side=tk.LEFT, padx=5)
+
+    def _on_setting_change(self):
+        """Handle setting changes."""
+        self.save_settings()
+        if hasattr(self.app, 'on_tool_setting_change'):
+            self.app.on_tool_setting_change()
+
+    def _apply_morse_translator(self):
+        """Apply the Morse Code Translator tool."""
+        self._apply_tool("Morse Code Translator")
+
+    def _apply_binary_translator(self):
+        """Apply the Binary Code Translator tool."""
+        self._apply_tool("Binary Code Translator")
+
+    def _apply_tool(self, tool_type):
+        """Apply the specified translator tool."""
+        try:
+            # Get input text from the active input tab
+            active_input_tab = self.app.input_tabs[self.app.input_notebook.index(self.app.input_notebook.select())]
+            input_text = active_input_tab.text.get("1.0", tk.END).strip()
+            
+            if not input_text:
+                # Show a message if no input text
+                active_output_tab = self.app.output_tabs[self.app.output_notebook.index(self.app.output_notebook.select())]
+                active_output_tab.text.config(state="normal")
+                active_output_tab.text.delete("1.0", tk.END)
+                active_output_tab.text.insert("1.0", f"Please enter text to translate in the input area.\n\nFor {tool_type}:\n" + 
+                    ("- Enter text to convert to Morse code, or Morse code to convert to text" if tool_type == "Morse Code Translator" 
+                     else "- Enter text to convert to binary, or binary code to convert to text"))
+                active_output_tab.text.config(state="disabled")
+                return
+            
+            # Get settings for the tool
+            settings = self.get_tool_settings(tool_type)
+            
+            # Process the text
+            result = self.processor.process_text(input_text, tool_type, settings)
+            
+            # Update output
+            active_output_tab = self.app.output_tabs[self.app.output_notebook.index(self.app.output_notebook.select())]
+            active_output_tab.text.config(state="normal")
+            active_output_tab.text.delete("1.0", tk.END)
+            active_output_tab.text.insert("1.0", result)
+            active_output_tab.text.config(state="disabled")
+            
+            # Update statistics
+            if hasattr(self.app, 'update_all_stats'):
+                self.app.after(10, self.app.update_all_stats)
+                
+        except Exception as e:
+            # Show error in output if something goes wrong
+            try:
+                active_output_tab = self.app.output_tabs[self.app.output_notebook.index(self.app.output_notebook.select())]
+                active_output_tab.text.config(state="normal")
+                active_output_tab.text.delete("1.0", tk.END)
+                active_output_tab.text.insert("1.0", f"Error: {str(e)}")
+                active_output_tab.text.config(state="disabled")
+            except:
+                print(f"Translator Tools Error: {str(e)}")  # Fallback to console
+
+    def _play_morse_audio(self):
+        """Play Morse code audio from the output area."""
+        if self.morse_thread and self.morse_thread.is_alive():
+            print("Morse playback is already in progress.")
+            return
+            
+        if not PYAUDIO_AVAILABLE or not self.audio_stream:
+            self._show_audio_setup_instructions("PyAudio")
+            return
+            
+        if not NUMPY_AVAILABLE:
+            self._show_audio_setup_instructions("NumPy")
+            return
+
+        active_output_tab = self.app.output_tabs[self.app.output_notebook.index(self.app.output_notebook.select())]
+        morse_code = active_output_tab.text.get("1.0", tk.END).strip()
+        if not morse_code:
+            print("No Morse code to play.")
+            return
+            
+        self.stop_morse_playback.clear()
+        self.morse_thread = threading.Thread(target=self._play_morse_thread, args=(morse_code,), daemon=True)
+        self.morse_thread.start()
+
+    def _stop_morse_audio(self):
+        """Stop the currently playing Morse code audio."""
+        self.stop_morse_playback.set()
+
+    def _play_morse_thread(self, morse_code):
+        """The actual playback logic that runs in a thread."""
+        if hasattr(self, 'play_morse_button'):
+            self.play_morse_button.config(text="Stop Playing", command=self._stop_morse_audio)
+        print("Starting Morse code playback.")
+
+        try:
+            for char in morse_code:
+                if self.stop_morse_playback.is_set():
+                    print("Morse playback stopped by user.")
+                    break
+                if char == '.':
+                    tone = self._generate_morse_tone(TranslatorToolsProcessor.MORSE_DOT_DURATION)
+                    self.audio_stream.write(tone.tobytes())
+                    time.sleep(TranslatorToolsProcessor.MORSE_DOT_DURATION)
+                elif char == '-':
+                    tone = self._generate_morse_tone(TranslatorToolsProcessor.MORSE_DASH_DURATION)
+                    self.audio_stream.write(tone.tobytes())
+                    time.sleep(TranslatorToolsProcessor.MORSE_DOT_DURATION)
+                elif char == ' ':
+                    time.sleep(TranslatorToolsProcessor.MORSE_DOT_DURATION * 3 - TranslatorToolsProcessor.MORSE_DOT_DURATION)
+                elif char == '/':
+                    time.sleep(TranslatorToolsProcessor.MORSE_DOT_DURATION * 7 - TranslatorToolsProcessor.MORSE_DOT_DURATION)
+        except Exception as e:
+            print(f"Error during morse playback: {e}")
+        finally:
+            if hasattr(self, 'play_morse_button'):
+                self.play_morse_button.config(text="Play Morse Audio", command=self._play_morse_audio)
+            print("Morse code playback finished.")
+            self.stop_morse_playback.clear()
+
+    def _generate_morse_tone(self, duration):
+        """Generate a sine wave for a given duration for Morse code."""
+        if not NUMPY_AVAILABLE:
+            # Return silence if numpy is not available
+            import array
+            sample_count = int(TranslatorToolsProcessor.SAMPLE_RATE * duration)
+            return array.array('f', [0.0] * sample_count)
+        
+        tone_freq = TranslatorToolsProcessor.TONE_FREQUENCY
+        t = np.linspace(0, duration, int(TranslatorToolsProcessor.SAMPLE_RATE * duration), False)
+        tone = np.sin(tone_freq * t * 2 * np.pi)
+        return (0.5 * tone).astype(np.float32)
+
+    def get_tool_settings(self, tool_type):
+        """Get settings for the specified tool."""
+        if tool_type == "Morse Code Translator":
+            return {
+                "mode": self.morse_mode.get()
+            }
+        elif tool_type == "Binary Code Translator":
+            return {}  # Binary translator doesn't have settings
+        return {}
+
+    def get_all_settings(self):
+        """Get all settings for both translator tools."""
+        return {
+            "Morse Code Translator": self.get_tool_settings("Morse Code Translator"),
+            "Binary Code Translator": self.get_tool_settings("Binary Code Translator")
+        }
+
+    def load_settings(self):
+        """Load settings from the main application."""
+        if not hasattr(self.app, 'settings'):
+            return
+            
+        # Load Morse Code Translator settings
+        morse_settings = self.app.settings.get("tool_settings", {}).get("Morse Code Translator", {})
+        self.morse_mode.set(morse_settings.get("mode", "morse"))
+
+    def save_settings(self):
+        """Save settings to the main application."""
+        if not hasattr(self.app, 'settings'):
+            return
+            
+        # Save Morse Code Translator settings
+        if "Morse Code Translator" not in self.app.settings["tool_settings"]:
+            self.app.settings["tool_settings"]["Morse Code Translator"] = {}
+        self.app.settings["tool_settings"]["Morse Code Translator"]["mode"] = self.morse_mode.get()
+
+    def __del__(self):
+        """Cleanup audio resources when widget is destroyed."""
+        if self.audio_stream:
+            try:
+                self.audio_stream.stop_stream()
+                self.audio_stream.close()
+            except:
+                pass
+        if self.pyaudio_instance:
+            try:
+                self.pyaudio_instance.terminate()
+            except:
+                pass
+
+
+class TranslatorTools:
+    """Main Translator Tools class that provides the interface for the main application."""
+    
+    def __init__(self):
+        self.processor = TranslatorToolsProcessor()
+        self.widget = None
+        
+    def create_widget(self, parent, app, dialog_manager=None):
+        """Create and return the tabbed widget component."""
+        self.widget = TranslatorToolsWidget(parent, app, dialog_manager)
+        return self.widget
+        
+    def process_text(self, input_text, tool_type, settings):
+        """Process text using the specified translator tool and settings."""
+        return self.processor.process_text(input_text, tool_type, settings)
+        
+    def get_default_settings(self):
+        """Get default settings for both translator tools."""
+        return {
+            "Morse Code Translator": {"mode": "morse", "tone": TranslatorToolsProcessor.TONE_FREQUENCY},
+            "Binary Code Translator": {}
+        }
+
+
+# Convenience functions for backward compatibility
+def morse_translator(text, mode, morse_dict=None, reversed_morse_dict=None):
+    """Translate text to/from Morse code."""
+    return TranslatorToolsProcessor.morse_translator(text, mode)
+
+
+def binary_translator(text):
+    """Translate text to/from binary code."""
+    return TranslatorToolsProcessor.binary_translator(text)
+
+
+# BaseTool-compatible wrapper
+try:
+    from tools.base_tool import ToolWithOptions
+    from typing import Dict, Any
+    
+    class TranslatorToolsV2(ToolWithOptions):
+        """
+        BaseTool-compatible version of TranslatorTools.
+        """
+        
+        TOOL_NAME = "Translator Tools"
+        TOOL_DESCRIPTION = "Translate text to/from Morse code and binary"
+        TOOL_VERSION = "2.0.0"
+        
+        OPTIONS = [
+            ("Text to Morse", "to_morse"),
+            ("Morse to Text", "from_morse"),
+            ("Text to Binary", "to_binary"),
+            ("Binary to Text", "from_binary"),
+        ]
+        OPTIONS_LABEL = "Translation"
+        USE_DROPDOWN = True
+        DEFAULT_OPTION = "to_morse"
+        
+        def __init__(self):
+            super().__init__()
+            self._processor = TranslatorToolsProcessor()
+        
+        def process_text(self, input_text: str, settings: Dict[str, Any]) -> str:
+            """Process text using the specified translation mode."""
+            mode = settings.get("mode", "to_morse")
+            
+            if mode == "to_morse":
+                return TranslatorToolsProcessor.morse_translator(input_text, "morse")
+            elif mode == "from_morse":
+                return TranslatorToolsProcessor.morse_translator(input_text, "text")
+            elif mode in ("to_binary", "from_binary"):
+                return TranslatorToolsProcessor.binary_translator(input_text)
+            else:
+                return input_text
+
+except ImportError:
     pass