pomera-ai-commander 0.1.0

package/tools/case_tool.py

@@ -0,0 +1,309 @@
+"""
+Case Tool Module - Text case conversion utility
+
+This module provides comprehensive text case conversion functionality with UI components
+for the Promera AI Commander application.
+"""
+
+import tkinter as tk
+from tkinter import ttk
+import re
+
+
+class CaseToolProcessor:
+    """Text case conversion processor with various case transformation methods."""
+    
+    @staticmethod
+    def sentence_case(text):
+        """Converts text to sentence case, capitalizing the first letter of each sentence and each new line."""
+        def capitalize_match(match):
+            return match.group(1) + match.group(2).upper()
+        
+        # Capitalize the first letter of the string, and any letter following a newline or sentence-ending punctuation.
+        return re.sub(r'([.!?\n]\s*|^)([a-z])', capitalize_match, text)
+
+    @staticmethod
+    def title_case(text, exclusions):
+        """Converts text to title case, excluding specified words."""
+        exclusion_list = {word.lower() for word in exclusions.splitlines()}
+        words = text.split(' ')
+        title_cased_words = []
+        for i, word in enumerate(words):
+            if i == 0 or word.lower() not in exclusion_list:
+                title_cased_words.append(word.capitalize())
+            else:
+                title_cased_words.append(word.lower())
+        return ' '.join(title_cased_words)
+
+    @staticmethod
+    def process_text(input_text, mode, exclusions=""):
+        """Process text based on the selected case mode."""
+        if mode == "Sentence":
+            return CaseToolProcessor.sentence_case(input_text)
+        elif mode == "Lower":
+            return input_text.lower()
+        elif mode == "Upper":
+            return input_text.upper()
+        elif mode == "Capitalized":
+            return input_text.title()
+        elif mode == "Title":
+            return CaseToolProcessor.title_case(input_text, exclusions)
+        else:
+            return input_text
+
+
+class CaseToolUI:
+    """UI components for the Case Tool."""
+    
+    def __init__(self, parent, settings, on_setting_change_callback=None, apply_tool_callback=None):
+        """
+        Initialize the Case Tool UI.
+        
+        Args:
+            parent: Parent widget
+            settings: Dictionary containing tool settings
+            on_setting_change_callback: Callback function for setting changes
+            apply_tool_callback: Callback function for applying the tool
+        """
+        self.parent = parent
+        self.settings = settings
+        self.on_setting_change_callback = on_setting_change_callback
+        self.apply_tool_callback = apply_tool_callback
+        self._initializing = True  # Start as True to prevent callbacks during creation
+        
+        # Initialize UI variables
+        self.case_mode_var = tk.StringVar(value=settings.get("mode", "Sentence"))
+        self.title_case_exclusions = None
+        self.title_case_frame = None
+        
+        self.create_widgets()
+        
+        # Now allow callbacks
+        self._initializing = False
+
+    def create_widgets(self):
+        """Creates the UI widgets for the Case Tool."""
+        # Mode selection radio buttons
+        radio_frame = ttk.Frame(self.parent)
+        radio_frame.pack(side=tk.LEFT, padx=5)
+
+        modes = ["Sentence", "Lower", "Upper", "Capitalized", "Title"]
+        for mode in modes:
+            rb = ttk.Radiobutton(
+                radio_frame, 
+                text=mode, 
+                variable=self.case_mode_var, 
+                value=mode, 
+                command=self.on_mode_change
+            )
+            rb.pack(anchor="w")
+
+        # Title case exclusions frame (shown/hidden based on mode)
+        self.title_case_frame = ttk.Frame(self.parent)
+        ttk.Label(self.title_case_frame, text="Exclusions (one per line):").pack(anchor="w")
+        self.title_case_exclusions = tk.Text(self.title_case_frame, height=5, width=20, undo=True)
+        self.title_case_exclusions.insert(tk.END, self.settings.get("exclusions", ""))
+        self.title_case_exclusions.pack(side=tk.LEFT, padx=5)
+        self.title_case_exclusions.bind("<KeyRelease>", self._on_exclusions_change)
+
+        # Process button
+        if self.apply_tool_callback:
+            ttk.Button(
+                self.parent, 
+                text="Process", 
+                command=self.apply_tool_callback
+            ).pack(side=tk.LEFT, padx=10, pady=10)
+        
+        # Initialize visibility
+        self.on_mode_change()
+
+    def on_mode_change(self):
+        """Shows or hides the Title Case exclusions widgets based on selected mode."""
+        if self.case_mode_var.get() == "Title":
+            self.title_case_frame.pack(side=tk.LEFT, padx=5)
+        else:
+            self.title_case_frame.pack_forget()
+        
+        # Trigger setting change callback if not initializing
+        if not self._initializing and self.on_setting_change_callback:
+            self.on_setting_change_callback()
+
+    def _on_exclusions_change(self, event=None):
+        """Handle changes to the exclusions text widget."""
+        if not self._initializing and self.on_setting_change_callback:
+            self.on_setting_change_callback()
+
+    def get_current_settings(self):
+        """Get the current settings from the UI."""
+        settings = {
+            "mode": self.case_mode_var.get()
+        }
+        
+        # Safely get exclusions - check widget exists and is valid
+        try:
+            if hasattr(self, 'title_case_exclusions') and self.title_case_exclusions:
+                if self.title_case_exclusions.winfo_exists():
+                    settings["exclusions"] = self.title_case_exclusions.get("1.0", tk.END).strip()
+                else:
+                    settings["exclusions"] = self.settings.get("exclusions", "")
+            else:
+                settings["exclusions"] = self.settings.get("exclusions", "")
+        except Exception:
+            settings["exclusions"] = self.settings.get("exclusions", "")
+            
+        return settings
+
+    def update_settings(self, settings):
+        """Update the UI with new settings."""
+        self._initializing = True
+        try:
+            self.case_mode_var.set(settings.get("mode", "Sentence"))
+            if self.title_case_exclusions:
+                self.title_case_exclusions.delete("1.0", tk.END)
+                self.title_case_exclusions.insert(tk.END, settings.get("exclusions", ""))
+            self.on_mode_change()
+        finally:
+            self._initializing = False
+
+
+class CaseTool:
+    """Main Case Tool class that combines processor and UI functionality."""
+    
+    def __init__(self):
+        self.processor = CaseToolProcessor()
+        self.ui = None
+        
+    def create_ui(self, parent, settings, on_setting_change_callback=None, apply_tool_callback=None):
+        """Create and return the UI component."""
+        self.ui = CaseToolUI(parent, settings, on_setting_change_callback, apply_tool_callback)
+        return self.ui
+        
+    def process_text(self, input_text, settings):
+        """Process text using the current settings."""
+        mode = settings.get("mode", "Sentence")
+        exclusions = settings.get("exclusions", "")
+        return self.processor.process_text(input_text, mode, exclusions)
+        
+    def get_default_settings(self):
+        """Get default settings for the Case Tool.
+        
+        Uses the centralized Settings Defaults Registry if available,
+        otherwise falls back to hardcoded defaults.
+        """
+        try:
+            from core.settings_defaults_registry import get_registry
+            registry = get_registry()
+            return registry.get_tool_defaults("Case Tool")
+        except ImportError:
+            pass
+        except Exception:
+            pass
+        
+        # Fallback to hardcoded defaults with updated exclusions
+        # Exclusions: a, an, the, and, but, or, for, nor, on, at, to, from, by, with, in, of
+        return {
+            "mode": "Sentence",
+            "exclusions": "a\nan\nthe\nand\nbut\nor\nfor\nnor\non\nat\nto\nfrom\nby\nwith\nin\nof"
+        }
+
+
+# Convenience functions for backward compatibility
+def sentence_case(text):
+    """Convert text to sentence case."""
+    return CaseToolProcessor.sentence_case(text)
+
+
+def title_case(text, exclusions):
+    """Convert text to title case with exclusions."""
+    return CaseToolProcessor.title_case(text, exclusions)
+
+
+def process_case_text(input_text, mode, exclusions=""):
+    """Process text with the specified case mode."""
+    return CaseToolProcessor.process_text(input_text, mode, exclusions)
+
+
+# BaseTool-compatible wrapper (for future migration)
+try:
+    from tools.base_tool import BaseTool
+    from typing import Dict, Any, Optional, Callable
+    
+    class CaseToolV2(BaseTool):
+        """
+        BaseTool-compatible version of CaseTool.
+        
+        This wrapper provides the standard BaseTool interface while using
+        the existing CaseToolProcessor and CaseToolUI for actual functionality.
+        """
+        
+        TOOL_NAME = "Case Tool"
+        TOOL_DESCRIPTION = "Convert text between different case formats"
+        TOOL_VERSION = "2.0.0"
+        
+        def __init__(self):
+            super().__init__()
+            self._processor = CaseToolProcessor()
+            self._ui_instance: Optional[CaseToolUI] = None
+        
+        def process_text(self, input_text: str, settings: Dict[str, Any]) -> str:
+            """Process text using the specified case mode."""
+            mode = settings.get("mode", "Sentence")
+            exclusions = settings.get("exclusions", "")
+            return self._processor.process_text(input_text, mode, exclusions)
+        
+        def create_ui(self,
+                      parent: tk.Frame,
+                      settings: Dict[str, Any],
+                      on_setting_change_callback: Optional[Callable] = None,
+                      apply_tool_callback: Optional[Callable] = None) -> CaseToolUI:
+            """Create the Case Tool UI."""
+            self._settings = settings.copy()
+            self._on_setting_change = on_setting_change_callback
+            self._apply_callback = apply_tool_callback
+            
+            self._ui_instance = CaseToolUI(
+                parent, 
+                settings, 
+                on_setting_change_callback, 
+                apply_tool_callback
+            )
+            return self._ui_instance
+        
+        @classmethod
+        def get_default_settings(cls) -> Dict[str, Any]:
+            """Get default settings for the Case Tool."""
+            try:
+                from core.settings_defaults_registry import get_registry
+                registry = get_registry()
+                return registry.get_tool_defaults("Case Tool")
+            except (ImportError, Exception):
+                pass
+            
+            return {
+                "mode": "Sentence",
+                "exclusions": "a\nan\nthe\nand\nbut\nor\nfor\nnor\non\nat\nto\nfrom\nby\nwith\nin\nof"
+            }
+        
+        def get_current_settings(self) -> Dict[str, Any]:
+            """Get current settings from the UI."""
+            if self._ui_instance:
+                return self._ui_instance.get_current_settings()
+            return self._settings.copy()
+        
+        def update_settings(self, settings: Dict[str, Any]) -> None:
+            """Update the UI with new settings."""
+            self._settings.update(settings)
+            if self._ui_instance:
+                self._ui_instance.update_settings(settings)
+        
+        def apply_font_to_widgets(self, font_tuple) -> None:
+            """Apply font to text widgets."""
+            if self._ui_instance and hasattr(self._ui_instance, 'title_case_exclusions'):
+                if self._ui_instance.title_case_exclusions:
+                    self._ui_instance.title_case_exclusions.configure(
+                        font=(font_tuple[0], font_tuple[1])
+                    )
+
+except ImportError:
+    # BaseTool not available, CaseToolV2 won't be defined
+    pass