pomera-ai-commander 1.1.1 → 1.2.2

package/tools/hash_generator.py

@@ -1,256 +1,256 @@
-"""
-Hash Generator Module - Cryptographic hash generation
-
-This module provides hash generation functionality for text content
-for the Pomera AI Commander application.
-
-Features:
-- MD5 hash
-- SHA-1 hash
-- SHA-256 hash
-- SHA-512 hash
-- CRC32 checksum
-- Uppercase/lowercase output option
-"""
-
-import tkinter as tk
-from tkinter import ttk
-import hashlib
-import zlib
-
-
-class HashGeneratorProcessor:
-    """Hash generator processor with multiple algorithm support."""
-    
-    ALGORITHMS = {
-        "md5": ("MD5", lambda data: hashlib.md5(data).hexdigest()),
-        "sha1": ("SHA-1", lambda data: hashlib.sha1(data).hexdigest()),
-        "sha256": ("SHA-256", lambda data: hashlib.sha256(data).hexdigest()),
-        "sha512": ("SHA-512", lambda data: hashlib.sha512(data).hexdigest()),
-        "crc32": ("CRC32", lambda data: format(zlib.crc32(data) & 0xffffffff, '08x')),
-    }
-    
-    @staticmethod
-    def generate_hash(text, algorithm, uppercase=False):
-        """Generate hash for the given text using specified algorithm."""
-        if algorithm not in HashGeneratorProcessor.ALGORITHMS:
-            return f"Unknown algorithm: {algorithm}"
-        
-        data = text.encode('utf-8')
-        name, hash_func = HashGeneratorProcessor.ALGORITHMS[algorithm]
-        result = hash_func(data)
-        
-        if uppercase:
-            result = result.upper()
-        
-        return result
-    
-    @staticmethod
-    def generate_all_hashes(text, algorithms, uppercase=False):
-        """Generate hashes for all specified algorithms."""
-        if not text:
-            return "No input text provided."
-        
-        data = text.encode('utf-8')
-        results = []
-        results.append("=" * 70)
-        results.append("HASH RESULTS")
-        results.append("=" * 70)
-        results.append(f"Input Length: {len(text)} characters, {len(data)} bytes")
-        results.append("")
-        
-        for algo in algorithms:
-            if algo in HashGeneratorProcessor.ALGORITHMS:
-                name, hash_func = HashGeneratorProcessor.ALGORITHMS[algo]
-                hash_value = hash_func(data)
-                if uppercase:
-                    hash_value = hash_value.upper()
-                results.append(f"{name}:")
-                results.append(f"  {hash_value}")
-                results.append("")
-        
-        results.append("=" * 70)
-        return '\n'.join(results)
-
-
-class HashGeneratorWidget(ttk.Frame):
-    """Widget for hash generator tool."""
-    
-    def __init__(self, parent, app):
-        super().__init__(parent)
-        self.app = app
-        self.processor = HashGeneratorProcessor()
-        
-        # Algorithm checkboxes
-        self.algo_vars = {
-            "md5": tk.BooleanVar(value=True),
-            "sha1": tk.BooleanVar(value=False),
-            "sha256": tk.BooleanVar(value=True),
-            "sha512": tk.BooleanVar(value=False),
-            "crc32": tk.BooleanVar(value=False),
-        }
-        
-        self.uppercase = tk.BooleanVar(value=False)
-        
-        self.create_widgets()
-        self.load_settings()
-    
-    def create_widgets(self):
-        """Creates the widget interface."""
-        # Algorithms frame
-        algo_frame = ttk.LabelFrame(self, text="Hash Algorithms", padding=10)
-        algo_frame.pack(fill=tk.X, padx=5, pady=5)
-        
-        algo_labels = {
-            "md5": "MD5 (128-bit)",
-            "sha1": "SHA-1 (160-bit)",
-            "sha256": "SHA-256 (256-bit)",
-            "sha512": "SHA-512 (512-bit)",
-            "crc32": "CRC32 (32-bit checksum)",
-        }
-        
-        for algo, label in algo_labels.items():
-            ttk.Checkbutton(algo_frame, text=label, 
-                           variable=self.algo_vars[algo],
-                           command=self.on_setting_change).pack(anchor=tk.W)
-        
-        # Options frame
-        options_frame = ttk.LabelFrame(self, text="Options", padding=10)
-        options_frame.pack(fill=tk.X, padx=5, pady=5)
-        
-        ttk.Checkbutton(options_frame, text="Uppercase Output", 
-                       variable=self.uppercase,
-                       command=self.on_setting_change).pack(anchor=tk.W)
-        
-        # Generate button
-        ttk.Button(self, text="Generate Hashes", 
-                  command=self.generate).pack(pady=10)
-    
-    def load_settings(self):
-        """Load settings from the application."""
-        settings = self.app.settings.get("tool_settings", {}).get("Hash Generator", {})
-        
-        algorithms = settings.get("algorithms", ["md5", "sha256"])
-        for algo in self.algo_vars:
-            self.algo_vars[algo].set(algo in algorithms)
-        
-        self.uppercase.set(settings.get("uppercase", False))
-    
-    def save_settings(self):
-        """Save current settings to the application."""
-        if "Hash Generator" not in self.app.settings["tool_settings"]:
-            self.app.settings["tool_settings"]["Hash Generator"] = {}
-        
-        algorithms = [algo for algo, var in self.algo_vars.items() if var.get()]
-        
-        self.app.settings["tool_settings"]["Hash Generator"].update({
-            "algorithms": algorithms,
-            "uppercase": self.uppercase.get()
-        })
-        
-        self.app.save_settings()
-    
-    def on_setting_change(self, *args):
-        """Handle setting changes."""
-        self.save_settings()
-    
-    def generate(self):
-        """Generate hashes for the input text."""
-        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).rstrip('\n')
-        
-        algorithms = [algo for algo, var in self.algo_vars.items() if var.get()]
-        
-        if not algorithms:
-            result = "Please select at least one hash algorithm."
-        else:
-            result = HashGeneratorProcessor.generate_all_hashes(
-                input_text,
-                algorithms,
-                self.uppercase.get()
-            )
-        
-        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")
-        
-        self.app.update_all_stats()
-
-
-class HashGenerator:
-    """Main class for Hash Generator integration."""
-    
-    def __init__(self):
-        self.processor = HashGeneratorProcessor()
-    
-    def create_widget(self, parent, app):
-        """Create and return the Hash Generator widget."""
-        return HashGeneratorWidget(parent, app)
-    
-    def get_default_settings(self):
-        """Return default settings for Hash Generator."""
-        return {
-            "algorithms": ["md5", "sha256"],
-            "uppercase": False
-        }
-    
-    def process_text(self, input_text, settings):
-        """Process text and return hashes."""
-        return HashGeneratorProcessor.generate_all_hashes(
-            input_text,
-            settings.get("algorithms", ["md5", "sha256"]),
-            settings.get("uppercase", False)
-        )
-
-
-# BaseTool-compatible wrapper (for future migration)
-try:
-    from tools.base_tool import BaseTool
-    from typing import Dict, Any, Optional, Callable
-    
-    class HashGeneratorV2(BaseTool):
-        """
-        BaseTool-compatible version of HashGenerator.
-        """
-        
-        TOOL_NAME = "Hash Generator"
-        TOOL_DESCRIPTION = "Generate MD5, SHA-1, SHA-256, SHA-512, and CRC32 hashes"
-        TOOL_VERSION = "2.0.0"
-        
-        def __init__(self):
-            super().__init__()
-            self._processor = HashGeneratorProcessor()
-        
-        def process_text(self, input_text: str, settings: Dict[str, Any]) -> str:
-            """Process text and return hashes."""
-            return HashGeneratorProcessor.generate_all_hashes(
-                input_text,
-                settings.get("algorithms", ["md5", "sha256"]),
-                settings.get("uppercase", False)
-            )
-        
-        def create_ui(self,
-                      parent,
-                      settings: Dict[str, Any],
-                      on_setting_change_callback: Optional[Callable] = None,
-                      apply_tool_callback: Optional[Callable] = None):
-            """Create the Hash Generator UI using the existing widget."""
-            self._settings = settings.copy()
-            self._on_setting_change = on_setting_change_callback
-            self._apply_callback = apply_tool_callback
-            # Use existing widget implementation
-            return None  # Widget created separately
-        
-        @classmethod
-        def get_default_settings(cls) -> Dict[str, Any]:
-            """Return default settings for Hash Generator."""
-            return {
-                "algorithms": ["md5", "sha256"],
-                "uppercase": False
-            }
-
-except ImportError:
-    # BaseTool not available
+"""
+Hash Generator Module - Cryptographic hash generation
+
+This module provides hash generation functionality for text content
+for the Pomera AI Commander application.
+
+Features:
+- MD5 hash
+- SHA-1 hash
+- SHA-256 hash
+- SHA-512 hash
+- CRC32 checksum
+- Uppercase/lowercase output option
+"""
+
+import tkinter as tk
+from tkinter import ttk
+import hashlib
+import zlib
+
+
+class HashGeneratorProcessor:
+    """Hash generator processor with multiple algorithm support."""
+    
+    ALGORITHMS = {
+        "md5": ("MD5", lambda data: hashlib.md5(data).hexdigest()),
+        "sha1": ("SHA-1", lambda data: hashlib.sha1(data).hexdigest()),
+        "sha256": ("SHA-256", lambda data: hashlib.sha256(data).hexdigest()),
+        "sha512": ("SHA-512", lambda data: hashlib.sha512(data).hexdigest()),
+        "crc32": ("CRC32", lambda data: format(zlib.crc32(data) & 0xffffffff, '08x')),
+    }
+    
+    @staticmethod
+    def generate_hash(text, algorithm, uppercase=False):
+        """Generate hash for the given text using specified algorithm."""
+        if algorithm not in HashGeneratorProcessor.ALGORITHMS:
+            return f"Unknown algorithm: {algorithm}"
+        
+        data = text.encode('utf-8')
+        name, hash_func = HashGeneratorProcessor.ALGORITHMS[algorithm]
+        result = hash_func(data)
+        
+        if uppercase:
+            result = result.upper()
+        
+        return result
+    
+    @staticmethod
+    def generate_all_hashes(text, algorithms, uppercase=False):
+        """Generate hashes for all specified algorithms."""
+        if not text:
+            return "No input text provided."
+        
+        data = text.encode('utf-8')
+        results = []
+        results.append("=" * 70)
+        results.append("HASH RESULTS")
+        results.append("=" * 70)
+        results.append(f"Input Length: {len(text)} characters, {len(data)} bytes")
+        results.append("")
+        
+        for algo in algorithms:
+            if algo in HashGeneratorProcessor.ALGORITHMS:
+                name, hash_func = HashGeneratorProcessor.ALGORITHMS[algo]
+                hash_value = hash_func(data)
+                if uppercase:
+                    hash_value = hash_value.upper()
+                results.append(f"{name}:")
+                results.append(f"  {hash_value}")
+                results.append("")
+        
+        results.append("=" * 70)
+        return '\n'.join(results)
+
+
+class HashGeneratorWidget(ttk.Frame):
+    """Widget for hash generator tool."""
+    
+    def __init__(self, parent, app):
+        super().__init__(parent)
+        self.app = app
+        self.processor = HashGeneratorProcessor()
+        
+        # Algorithm checkboxes
+        self.algo_vars = {
+            "md5": tk.BooleanVar(value=True),
+            "sha1": tk.BooleanVar(value=False),
+            "sha256": tk.BooleanVar(value=True),
+            "sha512": tk.BooleanVar(value=False),
+            "crc32": tk.BooleanVar(value=False),
+        }
+        
+        self.uppercase = tk.BooleanVar(value=False)
+        
+        self.create_widgets()
+        self.load_settings()
+    
+    def create_widgets(self):
+        """Creates the widget interface."""
+        # Algorithms frame
+        algo_frame = ttk.LabelFrame(self, text="Hash Algorithms", padding=10)
+        algo_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        algo_labels = {
+            "md5": "MD5 (128-bit)",
+            "sha1": "SHA-1 (160-bit)",
+            "sha256": "SHA-256 (256-bit)",
+            "sha512": "SHA-512 (512-bit)",
+            "crc32": "CRC32 (32-bit checksum)",
+        }
+        
+        for algo, label in algo_labels.items():
+            ttk.Checkbutton(algo_frame, text=label, 
+                           variable=self.algo_vars[algo],
+                           command=self.on_setting_change).pack(anchor=tk.W)
+        
+        # Options frame
+        options_frame = ttk.LabelFrame(self, text="Options", padding=10)
+        options_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        ttk.Checkbutton(options_frame, text="Uppercase Output", 
+                       variable=self.uppercase,
+                       command=self.on_setting_change).pack(anchor=tk.W)
+        
+        # Generate button
+        ttk.Button(self, text="Generate Hashes", 
+                  command=self.generate).pack(pady=10)
+    
+    def load_settings(self):
+        """Load settings from the application."""
+        settings = self.app.settings.get("tool_settings", {}).get("Hash Generator", {})
+        
+        algorithms = settings.get("algorithms", ["md5", "sha256"])
+        for algo in self.algo_vars:
+            self.algo_vars[algo].set(algo in algorithms)
+        
+        self.uppercase.set(settings.get("uppercase", False))
+    
+    def save_settings(self):
+        """Save current settings to the application."""
+        if "Hash Generator" not in self.app.settings["tool_settings"]:
+            self.app.settings["tool_settings"]["Hash Generator"] = {}
+        
+        algorithms = [algo for algo, var in self.algo_vars.items() if var.get()]
+        
+        self.app.settings["tool_settings"]["Hash Generator"].update({
+            "algorithms": algorithms,
+            "uppercase": self.uppercase.get()
+        })
+        
+        self.app.save_settings()
+    
+    def on_setting_change(self, *args):
+        """Handle setting changes."""
+        self.save_settings()
+    
+    def generate(self):
+        """Generate hashes for the input text."""
+        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).rstrip('\n')
+        
+        algorithms = [algo for algo, var in self.algo_vars.items() if var.get()]
+        
+        if not algorithms:
+            result = "Please select at least one hash algorithm."
+        else:
+            result = HashGeneratorProcessor.generate_all_hashes(
+                input_text,
+                algorithms,
+                self.uppercase.get()
+            )
+        
+        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")
+        
+        self.app.update_all_stats()
+
+
+class HashGenerator:
+    """Main class for Hash Generator integration."""
+    
+    def __init__(self):
+        self.processor = HashGeneratorProcessor()
+    
+    def create_widget(self, parent, app):
+        """Create and return the Hash Generator widget."""
+        return HashGeneratorWidget(parent, app)
+    
+    def get_default_settings(self):
+        """Return default settings for Hash Generator."""
+        return {
+            "algorithms": ["md5", "sha256"],
+            "uppercase": False
+        }
+    
+    def process_text(self, input_text, settings):
+        """Process text and return hashes."""
+        return HashGeneratorProcessor.generate_all_hashes(
+            input_text,
+            settings.get("algorithms", ["md5", "sha256"]),
+            settings.get("uppercase", False)
+        )
+
+
+# BaseTool-compatible wrapper (for future migration)
+try:
+    from tools.base_tool import BaseTool
+    from typing import Dict, Any, Optional, Callable
+    
+    class HashGeneratorV2(BaseTool):
+        """
+        BaseTool-compatible version of HashGenerator.
+        """
+        
+        TOOL_NAME = "Hash Generator"
+        TOOL_DESCRIPTION = "Generate MD5, SHA-1, SHA-256, SHA-512, and CRC32 hashes"
+        TOOL_VERSION = "2.0.0"
+        
+        def __init__(self):
+            super().__init__()
+            self._processor = HashGeneratorProcessor()
+        
+        def process_text(self, input_text: str, settings: Dict[str, Any]) -> str:
+            """Process text and return hashes."""
+            return HashGeneratorProcessor.generate_all_hashes(
+                input_text,
+                settings.get("algorithms", ["md5", "sha256"]),
+                settings.get("uppercase", False)
+            )
+        
+        def create_ui(self,
+                      parent,
+                      settings: Dict[str, Any],
+                      on_setting_change_callback: Optional[Callable] = None,
+                      apply_tool_callback: Optional[Callable] = None):
+            """Create the Hash Generator UI using the existing widget."""
+            self._settings = settings.copy()
+            self._on_setting_change = on_setting_change_callback
+            self._apply_callback = apply_tool_callback
+            # Use existing widget implementation
+            return None  # Widget created separately
+        
+        @classmethod
+        def get_default_settings(cls) -> Dict[str, Any]:
+            """Return default settings for Hash Generator."""
+            return {
+                "algorithms": ["md5", "sha256"],
+                "uppercase": False
+            }
+
+except ImportError:
+    # BaseTool not available
     pass