reflectorch 1.5.1__py3-none-any.whl

reflectorch/extensions/jupyter/custom_select.py

@@ -0,0 +1,268 @@
+import ipywidgets as W
+from IPython.display import display, HTML
+from typing import List, Dict, Tuple, Callable, Optional, Any
+
+
+class CustomSelect:
+    """
+    A styled select widget for displaying tabular data with monospace formatting.
+    
+    Features:
+    - Clean, modern styling with hover effects
+    - Automatic column width calculation
+    - Header display
+    - Click callback support
+    - Easy data updates
+    """
+    
+    # Inject CSS once when class is first used
+    _css_injected = False
+    
+    @classmethod
+    def _inject_css(cls):
+        if not cls._css_injected:
+            display(HTML("""
+            <style>
+            .custom-select-container {
+                font-family: 'SF Mono', 'Monaco', 'Consolas', monospace;
+            }
+            
+            .custom-select-header {
+                margin: 0;
+                padding: 8px 12px;
+                font-family: 'SF Mono', 'Monaco', 'Consolas', monospace;
+                font-weight: 600;
+                font-size: 13px;
+                background: linear-gradient(to bottom, #f8f9fa 0%, #e9ecef 100%);
+                border: 1px solid #dee2e6;
+                border-bottom: 2px solid #adb5bd;
+                border-radius: 6px 6px 0 0;
+                color: #495057;
+                letter-spacing: 0.3px;
+            }
+            
+            .custom-select select {
+                font-family: 'SF Mono', 'Monaco', 'Consolas', monospace;
+                font-size: 13px;
+                background-color: #ffffff;
+                border: 1px solid #dee2e6;
+                border-top: none;
+                border-radius: 0 0 6px 6px;
+                padding: 6px 12px;
+                color: #212529;
+                line-height: 1.6;
+                transition: all 0.2s ease;
+            }
+            
+            .custom-select select:hover {
+                background-color: #f8f9fa;
+            }
+            
+            .custom-select select:focus {
+                outline: none;
+                border-color: #0d6efd;
+                box-shadow: 0 0 0 3px rgba(13, 110, 253, 0.1);
+                background-color: #ffffff;
+            }
+            
+            .custom-select select option {
+                padding: 4px 8px;
+            }
+            
+            .custom-select select option:hover {
+                background-color: #e7f1ff;
+            }
+            
+            .custom-select-details {
+                margin-top: 12px;
+                padding: 12px 16px;
+                background-color: #f8f9fa;
+                border: 1px solid #dee2e6;
+                border-radius: 6px;
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+                font-size: 14px;
+                color: #495057;
+                box-shadow: 0 1px 3px rgba(0,0,0,0.05);
+            }
+            
+            .custom-select-details i {
+                color: #6c757d;
+            }
+            
+            .custom-select-details b {
+                color: #0d6efd;
+                font-weight: 600;
+            }
+            </style>
+            """))
+            cls._css_injected = True
+    
+    def __init__(
+        self,
+        data: List[Dict[str, Any]],
+        columns: List[Tuple[str, str]],
+        width: str = "auto",
+        max_rows: int = 10,
+        show_details: bool = False,
+        details_template: Optional[str] = None,
+        layout: Optional[W.Layout] = None,
+    ):
+        """
+        Initialize the CustomSelect widget.
+        
+        Args:
+            data: List of dictionaries containing row data
+            columns: List of tuples (header_label, data_key)
+            width: CSS width for the select widget (e.g., '600px', 'auto')
+            max_rows: Maximum number of visible rows
+            show_details: Whether to show the details panel below
+            details_template: Custom HTML template for details (receives row dict)
+            layout: Layout for the VBox containing the widget
+        """
+        self._inject_css()
+        
+        self.data = data
+        self.columns = columns
+        self.width = width
+        self.max_rows = max_rows
+        self.show_details = show_details
+        self.details_template = details_template
+        self._callback: Optional[Callable] = None
+        
+        # Create widgets
+        self._header_widget = W.HTML()
+        self._select_widget = W.Select(layout=W.Layout(width=width))
+        self._select_widget.add_class("custom-select")
+        
+        self._details_widget = W.HTML("<i>Select a row to view details…</i>")
+        self._details_widget.add_class("custom-select-details")
+        
+        # Setup observer
+        self._select_widget.observe(self._on_selection_change, names="value")
+        
+        # Build the widget
+        self._update_display()
+        
+        # Container
+        widgets = [self._header_widget, self._select_widget]
+        if self.show_details:
+            widgets.append(self._details_widget)
+
+        if layout is not None:
+            self.container = W.VBox(widgets, layout=layout)
+        else:
+            self.container = W.VBox(widgets)
+        
+        self.container.add_class("custom-select-container")
+    
+    def _calculate_column_widths(self) -> Dict[str, int]:
+        """Calculate the width needed for each column."""
+        widths = {}
+        for header, key in self.columns:
+            header_len = len(str(header))
+            if self.data:
+                max_data_len = max(len(str(row.get(key, ""))) for row in self.data)
+                widths[key] = max(header_len, max_data_len)
+            else:
+                widths[key] = header_len
+        return widths
+    
+    def _format_row(self, row: Dict[str, Any], widths: Dict[str, int]) -> str:
+        """Format a row with proper column alignment."""
+        parts = []
+        for _, key in self.columns:
+            value = str(row.get(key, ""))
+            parts.append(value.ljust(widths[key]))
+        return "  ".join(parts)
+    
+    def _update_display(self):
+        """Update the header and select options based on current data."""
+        if not self.data:
+            self._header_widget.value = "<pre class='custom-select-header'><i>No data</i></pre>"
+            self._select_widget.options = []
+            return
+        
+        # Calculate widths
+        widths = self._calculate_column_widths()
+        
+        # Build header
+        header_parts = [h.ljust(widths[k]) for h, k in self.columns]
+        header_text = "  ".join(header_parts)
+        self._header_widget.value = f"<pre class='custom-select-header'>{header_text}</pre>"
+        
+        # Build options
+        options = [(self._format_row(row, widths), row) for row in self.data]
+        self._select_widget.options = options
+        self._select_widget.rows = min(self.max_rows, len(self.data))
+    
+    def _on_selection_change(self, change):
+        """Handle selection changes."""
+        if change["name"] == "value" and change["new"] is not None:
+            row = change["new"]
+            
+            # Update details
+            if self.show_details:
+                if self.details_template:
+                    self._details_widget.value = self.details_template.format(**row)
+                else:
+                    # Default details display
+                    details_parts = [f"<b>{k}:</b> {v}" for k, v in row.items()]
+                    self._details_widget.value = " | ".join(details_parts)
+            
+            # Call user callback
+            if self._callback:
+                self._callback(row)
+    
+    def set_data(self, data: List[Dict[str, Any]]):
+        """
+        Update the data displayed in the select widget.
+        
+        Args:
+            data: New list of dictionaries containing row data
+        """
+        self.data = data + [{}]
+        self._update_display()
+        if self.show_details:
+            self._details_widget.value = "<i>Select a row to view details…</i>"
+    
+    def set_columns(self, columns: List[Tuple[str, str]]):
+        """
+        Update the columns definition.
+        
+        Args:
+            columns: New list of tuples (header_label, data_key)
+        """
+        self.columns = columns
+        self._update_display()
+    
+    def on_select(self, callback: Callable[[Dict[str, Any]], None]):
+        """
+        Register a callback function to be called when a row is selected.
+        
+        Args:
+            callback: Function that receives the selected row dictionary
+        """
+        self._callback = callback
+        return self
+    
+    def get_selected(self) -> Optional[Dict[str, Any]]:
+        """Get the currently selected row, or None if nothing is selected."""
+        return self._select_widget.value
+    
+    def set_selected_index(self, index: int):
+        """Select a row by index."""
+        if 0 <= index < len(self.data):
+            self._select_widget.value = self.data[index]
+    
+    def clear_selection(self):
+        """Clear the current selection."""
+        self._select_widget.value = None
+        if self.show_details:
+            self._details_widget.value = "<i>Select a row to view details…</i>"
+    
+    def display(self):
+        """Display the widget."""
+        display(self.container)
+    
+    def __repr__(self):
+        return f"CustomSelect(rows={len(self.data)}, columns={len(self.columns)})"

reflectorch/extensions/jupyter/log_widget.py

@@ -0,0 +1,241 @@
+"""
+Log Widget for Jupyter Interfaces
+
+A clean, reusable log widget with print redirection capabilities.
+"""
+
+import sys
+import contextlib
+from io import StringIO
+from typing import Optional
+import ipywidgets as widgets
+
+
+class LogWidget:
+    """
+    A clean log widget with print redirection capabilities.
+    
+    Features:
+    - Hidden by default, auto-shows when messages arrive
+    - Clear and toggle visibility controls
+    - Context manager for print redirection
+    - Clean, professional styling
+    
+    Example:
+        ```python
+        log_widget = LogWidget()
+        
+        # Use in layout
+        layout = widgets.VBox([
+            main_content,
+            log_widget.widget
+        ])
+        
+        # Redirect prints
+        with log_widget.capture_prints():
+            print("This goes to the log widget")
+        
+        # Or use the convenience method
+        log_widget.log("Direct message to log")
+        ```
+    """
+    
+    def __init__(self, 
+                 height: str = '150px',
+                 hidden_by_default: bool = True,
+                 auto_show_on_message: bool = True):
+        """
+        Initialize the log widget.
+        
+        Args:
+            height: Height of the log output area
+            hidden_by_default: Whether to start with log hidden
+            auto_show_on_message: Whether to auto-show log when messages arrive
+        """
+        self.auto_show_on_message = auto_show_on_message
+        self._create_widgets(height, hidden_by_default)
+        self._setup_event_handlers()
+    
+    def _create_widgets(self, height: str, hidden_by_default: bool):
+        """Create the log widget components"""
+        # Create log output area
+        self.output = widgets.Output(
+            layout=widgets.Layout(
+                height=height,
+                width='100%',
+                border='1px solid #ccc',
+                overflow='auto',
+                display='none' if hidden_by_default else ''
+            )
+        )
+        
+        # Create control buttons
+        self.clear_button = widgets.Button(
+            description="Clear Log",
+            button_style='warning',
+            tooltip='Clear all log messages',
+            layout=widgets.Layout(width='100px')
+        )
+        
+        self.toggle_button = widgets.Button(
+            description="Show Log" if hidden_by_default else "Hide Log",
+            button_style='info',
+            tooltip='Toggle log visibility',
+            layout=widgets.Layout(width='100px')
+        )
+        
+        # Create label
+        label = widgets.HTML("<b>Log Messages:</b>")
+        
+        # Create controls layout
+        controls = widgets.HBox([
+            label,
+            widgets.HTML("&nbsp;" * 10),  # Spacer
+            self.clear_button,
+            self.toggle_button
+        ])
+        
+        # Complete widget
+        self.widget = widgets.VBox([
+            controls,
+            self.output
+        ])
+    
+    def _setup_event_handlers(self):
+        """Setup button event handlers"""
+        def clear_log(_):
+            self.output.clear_output()
+        
+        def toggle_log(_):
+            if self.output.layout.display == 'none':
+                self.show()
+            else:
+                self.hide()
+        
+        self.clear_button.on_click(clear_log)
+        self.toggle_button.on_click(toggle_log)
+    
+    def show(self):
+        """Show the log output area"""
+        self.output.layout.display = ''
+        self.toggle_button.description = "Hide Log"
+    
+    def hide(self):
+        """Hide the log output area"""
+        self.output.layout.display = 'none'
+        self.toggle_button.description = "Show Log"
+    
+    def is_visible(self) -> bool:
+        """Check if log is currently visible"""
+        return self.output.layout.display != 'none'
+    
+    def clear(self):
+        """Clear all log messages"""
+        self.output.clear_output()
+    
+    def log(self, message: str):
+        """
+        Add a message directly to the log.
+        
+        Args:
+            message: Message to add to the log
+        """
+        if self.auto_show_on_message and not self.is_visible():
+            self.show()
+        
+        with self.output:
+            print(message)
+    
+    @contextlib.contextmanager
+    def capture_prints(self):
+        """
+        Context manager to redirect print statements to the log widget.
+        
+        Example:
+            with log_widget.capture_prints():
+                print("This goes to the log")
+                some_function_that_prints()
+        """
+        if self.output is None:
+            # Fallback to normal printing if widget not available
+            yield
+            return
+        
+        # Capture stdout
+        old_stdout = sys.stdout
+        captured_output = StringIO()
+        
+        try:
+            sys.stdout = captured_output
+            yield
+        finally:
+            sys.stdout = old_stdout
+            
+            # Get captured content and add to log
+            content = captured_output.getvalue()
+            if content.strip():  # Only add if there's actual content
+                if self.auto_show_on_message and not self.is_visible():
+                    self.show()
+                
+                with self.output:
+                    print(content.rstrip())  # Remove trailing newlines
+
+
+class LoggedOperation:
+    """
+    Decorator/context manager for operations that should log to a specific log widget.
+    
+    Example:
+        ```python
+        log_widget = LogWidget()
+        
+        # As context manager
+        with LoggedOperation(log_widget):
+            print("This operation is logged")
+            do_something()
+        
+        # As decorator
+        @LoggedOperation(log_widget)
+        def my_function():
+            print("Function output goes to log")
+        ```
+    """
+    
+    def __init__(self, log_widget: LogWidget):
+        self.log_widget = log_widget
+    
+    def __enter__(self):
+        self.context = self.log_widget.capture_prints()
+        return self.context.__enter__()
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return self.context.__exit__(exc_type, exc_val, exc_tb)
+    
+    def __call__(self, func):
+        """Decorator functionality"""
+        def wrapper(*args, **kwargs):
+            with self:
+                return func(*args, **kwargs)
+        return wrapper
+
+
+# Convenience function for quick log widget creation
+def create_log_widget(height: str = '150px', 
+                     hidden_by_default: bool = True,
+                     auto_show_on_message: bool = True) -> LogWidget:
+    """
+    Convenience function to create a log widget with common settings.
+    
+    Args:
+        height: Height of the log output area
+        hidden_by_default: Whether to start with log hidden
+        auto_show_on_message: Whether to auto-show log when messages arrive
+    
+    Returns:
+        Configured LogWidget instance
+    """
+    return LogWidget(
+        height=height,
+        hidden_by_default=hidden_by_default,
+        auto_show_on_message=auto_show_on_message
+    )