pomera-ai-commander 0.1.0

package/tools/number_base_converter.py

@@ -0,0 +1,373 @@
+"""
+Number Base Converter Module - Number system conversion utilities
+
+This module provides number base conversion functionality
+for the Pomera AI Commander application.
+
+Features:
+- Convert between Binary, Octal, Decimal, Hexadecimal
+- Batch conversion (multiple numbers per line)
+- Support for common prefixes (0x, 0b, 0o)
+- ASCII character conversion
+"""
+
+import tkinter as tk
+from tkinter import ttk
+import re
+
+
+class NumberBaseConverterProcessor:
+    """Number base converter processor."""
+    
+    BASES = {
+        "binary": 2,
+        "octal": 8,
+        "decimal": 10,
+        "hex": 16
+    }
+    
+    PREFIXES = {
+        "binary": "0b",
+        "octal": "0o",
+        "decimal": "",
+        "hex": "0x"
+    }
+    
+    @staticmethod
+    def parse_number(text, input_base):
+        """Parse a number string with optional prefix."""
+        text = text.strip()
+        
+        # Auto-detect base from prefix if present
+        if text.startswith('0b') or text.startswith('0B'):
+            return int(text, 2)
+        elif text.startswith('0o') or text.startswith('0O'):
+            return int(text, 8)
+        elif text.startswith('0x') or text.startswith('0X'):
+            return int(text, 16)
+        else:
+            base = NumberBaseConverterProcessor.BASES.get(input_base, 10)
+            return int(text, base)
+    
+    @staticmethod
+    def format_number(value, output_base, uppercase=True, show_prefix=True):
+        """Format a number in the specified base."""
+        base = NumberBaseConverterProcessor.BASES.get(output_base, 10)
+        prefix = NumberBaseConverterProcessor.PREFIXES.get(output_base, "") if show_prefix else ""
+        
+        if base == 2:
+            result = bin(value)[2:]
+        elif base == 8:
+            result = oct(value)[2:]
+        elif base == 16:
+            result = hex(value)[2:]
+            if uppercase:
+                result = result.upper()
+        else:
+            result = str(value)
+        
+        return prefix + result
+    
+    @staticmethod
+    def convert_single(text, input_base, output_base, uppercase=True, show_prefix=True):
+        """Convert a single number."""
+        try:
+            value = NumberBaseConverterProcessor.parse_number(text, input_base)
+            return NumberBaseConverterProcessor.format_number(value, output_base, uppercase, show_prefix)
+        except ValueError as e:
+            return f"Error: {str(e)}"
+    
+    @staticmethod
+    def convert_batch(text, input_base, output_base, uppercase=True, show_prefix=True):
+        """Convert multiple numbers (one per line)."""
+        lines = text.strip().split('\n')
+        results = []
+        
+        for line in lines:
+            line = line.strip()
+            if not line:
+                results.append("")
+                continue
+            
+            # Handle multiple numbers on same line (space-separated)
+            parts = line.split()
+            converted_parts = []
+            
+            for part in parts:
+                try:
+                    value = NumberBaseConverterProcessor.parse_number(part, input_base)
+                    converted = NumberBaseConverterProcessor.format_number(value, output_base, uppercase, show_prefix)
+                    converted_parts.append(converted)
+                except ValueError:
+                    converted_parts.append(f"[Error: {part}]")
+            
+            results.append(" ".join(converted_parts))
+        
+        return '\n'.join(results)
+    
+    @staticmethod
+    def text_to_ascii_codes(text, output_base="decimal", uppercase=True, show_prefix=False):
+        """Convert text to ASCII codes."""
+        results = []
+        for char in text:
+            code = ord(char)
+            formatted = NumberBaseConverterProcessor.format_number(code, output_base, uppercase, show_prefix)
+            results.append(formatted)
+        return ' '.join(results)
+    
+    @staticmethod
+    def ascii_codes_to_text(text, input_base="decimal"):
+        """Convert ASCII codes to text."""
+        parts = text.split()
+        result = []
+        
+        for part in parts:
+            try:
+                value = NumberBaseConverterProcessor.parse_number(part, input_base)
+                if 0 <= value <= 0x10FFFF:
+                    result.append(chr(value))
+                else:
+                    result.append(f"[Invalid: {part}]")
+            except ValueError:
+                result.append(f"[Error: {part}]")
+        
+        return ''.join(result)
+
+
+class NumberBaseConverterWidget(ttk.Frame):
+    """Widget for number base converter tool."""
+    
+    def __init__(self, parent, app):
+        super().__init__(parent)
+        self.app = app
+        self.processor = NumberBaseConverterProcessor()
+        
+        self.input_base = tk.StringVar(value="decimal")
+        self.output_base = tk.StringVar(value="hex")
+        self.uppercase = tk.BooleanVar(value=True)
+        self.show_prefix = tk.BooleanVar(value=True)
+        
+        self.create_widgets()
+        self.load_settings()
+    
+    def create_widgets(self):
+        """Creates the widget interface."""
+        # Input base selection
+        input_frame = ttk.LabelFrame(self, text="Input Base", padding=10)
+        input_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        bases = [("Binary (2)", "binary"), ("Octal (8)", "octal"), 
+                 ("Decimal (10)", "decimal"), ("Hexadecimal (16)", "hex")]
+        
+        for text, value in bases:
+            ttk.Radiobutton(input_frame, text=text, 
+                           variable=self.input_base, value=value,
+                           command=self.on_setting_change).pack(side=tk.LEFT, padx=5)
+        
+        # Output base selection
+        output_frame = ttk.LabelFrame(self, text="Output Base", padding=10)
+        output_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        for text, value in bases:
+            ttk.Radiobutton(output_frame, text=text, 
+                           variable=self.output_base, value=value,
+                           command=self.on_setting_change).pack(side=tk.LEFT, padx=5)
+        
+        # Options
+        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 (for hex)", 
+                       variable=self.uppercase,
+                       command=self.on_setting_change).pack(side=tk.LEFT, padx=10)
+        ttk.Checkbutton(options_frame, text="Show Prefix (0x, 0b, 0o)", 
+                       variable=self.show_prefix,
+                       command=self.on_setting_change).pack(side=tk.LEFT, padx=10)
+        
+        # Buttons
+        buttons_frame = ttk.Frame(self)
+        buttons_frame.pack(fill=tk.X, padx=5, pady=10)
+        
+        ttk.Button(buttons_frame, text="Convert Numbers", 
+                  command=self.convert).pack(side=tk.LEFT, padx=5)
+        ttk.Button(buttons_frame, text="Text to ASCII", 
+                  command=self.text_to_ascii).pack(side=tk.LEFT, padx=5)
+        ttk.Button(buttons_frame, text="ASCII to Text", 
+                  command=self.ascii_to_text).pack(side=tk.LEFT, padx=5)
+        
+        # Info
+        info = ttk.Label(self, text="Supports auto-detection of prefixes: 0x (hex), 0b (binary), 0o (octal)",
+                        font=('TkDefaultFont', 8))
+        info.pack(pady=5)
+    
+    def load_settings(self):
+        """Load settings from the application."""
+        settings = self.app.settings.get("tool_settings", {}).get("Number Base Converter", {})
+        
+        self.input_base.set(settings.get("input_base", "decimal"))
+        self.output_base.set(settings.get("output_base", "hex"))
+        self.uppercase.set(settings.get("uppercase", True))
+        self.show_prefix.set(settings.get("show_prefix", True))
+    
+    def save_settings(self):
+        """Save current settings to the application."""
+        if "Number Base Converter" not in self.app.settings["tool_settings"]:
+            self.app.settings["tool_settings"]["Number Base Converter"] = {}
+        
+        self.app.settings["tool_settings"]["Number Base Converter"].update({
+            "input_base": self.input_base.get(),
+            "output_base": self.output_base.get(),
+            "uppercase": self.uppercase.get(),
+            "show_prefix": self.show_prefix.get()
+        })
+        
+        self.app.save_settings()
+    
+    def on_setting_change(self, *args):
+        """Handle setting changes."""
+        self.save_settings()
+    
+    def convert(self):
+        """Convert numbers."""
+        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')
+        
+        if not input_text.strip():
+            return
+        
+        result = NumberBaseConverterProcessor.convert_batch(
+            input_text,
+            self.input_base.get(),
+            self.output_base.get(),
+            self.uppercase.get(),
+            self.show_prefix.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()
+    
+    def text_to_ascii(self):
+        """Convert text to ASCII codes."""
+        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')
+        
+        if not input_text:
+            return
+        
+        result = NumberBaseConverterProcessor.text_to_ascii_codes(
+            input_text,
+            self.output_base.get(),
+            self.uppercase.get(),
+            self.show_prefix.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()
+    
+    def ascii_to_text(self):
+        """Convert ASCII codes to 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')
+        
+        if not input_text.strip():
+            return
+        
+        result = NumberBaseConverterProcessor.ascii_codes_to_text(
+            input_text,
+            self.input_base.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 NumberBaseConverter:
+    """Main class for Number Base Converter integration."""
+    
+    def __init__(self):
+        self.processor = NumberBaseConverterProcessor()
+    
+    def create_widget(self, parent, app):
+        """Create and return the Number Base Converter widget."""
+        return NumberBaseConverterWidget(parent, app)
+    
+    def get_default_settings(self):
+        """Return default settings for Number Base Converter."""
+        return {
+            "input_base": "decimal",
+            "output_base": "hex",
+            "uppercase": True,
+            "show_prefix": True
+        }
+
+
+# BaseTool-compatible wrapper
+try:
+    from tools.base_tool import ToolWithOptions
+    from typing import Dict, Any
+    
+    class NumberBaseConverterV2(ToolWithOptions):
+        """
+        BaseTool-compatible version of NumberBaseConverter.
+        """
+        
+        TOOL_NAME = "Number Base Converter"
+        TOOL_DESCRIPTION = "Convert numbers between binary, octal, decimal, and hex"
+        TOOL_VERSION = "2.0.0"
+        
+        OPTIONS = [
+            ("Decimal to Hex", "dec_to_hex"),
+            ("Hex to Decimal", "hex_to_dec"),
+            ("Decimal to Binary", "dec_to_bin"),
+            ("Binary to Decimal", "bin_to_dec"),
+            ("Decimal to Octal", "dec_to_oct"),
+            ("Octal to Decimal", "oct_to_dec"),
+            ("Text to ASCII", "text_to_ascii"),
+            ("ASCII to Text", "ascii_to_text"),
+        ]
+        OPTIONS_LABEL = "Conversion"
+        USE_DROPDOWN = True
+        DEFAULT_OPTION = "dec_to_hex"
+        
+        def process_text(self, input_text: str, settings: Dict[str, Any]) -> str:
+            """Process text using the specified conversion."""
+            mode = settings.get("mode", "dec_to_hex")
+            
+            conversions = {
+                "dec_to_hex": ("decimal", "hex"),
+                "hex_to_dec": ("hex", "decimal"),
+                "dec_to_bin": ("decimal", "binary"),
+                "bin_to_dec": ("binary", "decimal"),
+                "dec_to_oct": ("decimal", "octal"),
+                "oct_to_dec": ("octal", "decimal"),
+            }
+            
+            if mode == "text_to_ascii":
+                return NumberBaseConverterProcessor.text_to_ascii_codes(input_text, "decimal")
+            elif mode == "ascii_to_text":
+                return NumberBaseConverterProcessor.ascii_codes_to_text(input_text, "decimal")
+            elif mode in conversions:
+                input_base, output_base = conversions[mode]
+                return NumberBaseConverterProcessor.convert_batch(
+                    input_text, input_base, output_base, True, True
+                )
+            else:
+                return input_text
+
+except ImportError:
+    pass