souleyez 2.43.29__py3-none-any.whl → 3.0.0__py3-none-any.whl

souleyez/ui/interactive_selector.py

@@ -17,6 +17,7 @@ from souleyez.ui.design_system import DesignSystem
 # Key codes - using readchar constants when available
 try:
     import readchar
+
     KEY_UP = readchar.key.UP
     KEY_DOWN = readchar.key.DOWN
     KEY_LEFT = readchar.key.LEFT
@@ -28,15 +29,15 @@ try:
     KEY_SPACE = readchar.key.SPACE
 except (ImportError, AttributeError):
     # Fallback to raw codes
-    KEY_UP = '\x1b[A'
-    KEY_DOWN = '\x1b[B'
-    KEY_LEFT = '\x1b[D'
-    KEY_RIGHT = '\x1b[C'
-    KEY_PAGE_UP = '\x1b[5~'
-    KEY_PAGE_DOWN = '\x1b[6~'
-    KEY_ESCAPE = '\x1b'
-    KEY_ENTER = '\r'
-    KEY_SPACE = ' '
+    KEY_UP = "\x1b[A"
+    KEY_DOWN = "\x1b[B"
+    KEY_LEFT = "\x1b[D"
+    KEY_RIGHT = "\x1b[C"
+    KEY_PAGE_UP = "\x1b[5~"
+    KEY_PAGE_DOWN = "\x1b[6~"
+    KEY_ESCAPE = "\x1b"
+    KEY_ENTER = "\r"
+    KEY_SPACE = " "
 
 
 def _get_key() -> str:
@@ -48,6 +49,7 @@ def _get_key() -> str:
     """
     try:
         import readchar
+
         key = readchar.readkey()
         return key
     except ImportError:
@@ -58,44 +60,44 @@ def _get_key() -> str:
         ch = click.getchar()
 
         # Handle escape sequences (arrow keys send \x1b[A, \x1b[B, etc.)
-        if ch == '\x1b' or (len(ch) > 1 and ch.startswith('\x1b')):
+        if ch == "\x1b" or (len(ch) > 1 and ch.startswith("\x1b")):
             # click.getchar() may return the full sequence or just escape
             if len(ch) >= 3:
-                if ch == '\x1b[A':
+                if ch == "\x1b[A":
                     return KEY_UP
-                elif ch == '\x1b[B':
+                elif ch == "\x1b[B":
                     return KEY_DOWN
-                elif ch == '\x1b[C':
+                elif ch == "\x1b[C":
                     return KEY_RIGHT
-                elif ch == '\x1b[D':
+                elif ch == "\x1b[D":
                     return KEY_LEFT
-                elif ch in ('\x1b[5~', '\x1b[5'):
+                elif ch in ("\x1b[5~", "\x1b[5"):
                     return KEY_PAGE_UP
-                elif ch in ('\x1b[6~', '\x1b[6'):
+                elif ch in ("\x1b[6~", "\x1b[6"):
                     return KEY_PAGE_DOWN
-            elif ch == '\x1b':
+            elif ch == "\x1b":
                 # Got just escape - try to read more (arrow key sequence)
                 try:
                     ch2 = click.getchar()
-                    if ch2 == '[':
+                    if ch2 == "[":
                         ch3 = click.getchar()
-                        if ch3 == 'A':
+                        if ch3 == "A":
                             return KEY_UP
-                        elif ch3 == 'B':
+                        elif ch3 == "B":
                             return KEY_DOWN
-                        elif ch3 == 'C':
+                        elif ch3 == "C":
                             return KEY_RIGHT
-                        elif ch3 == 'D':
+                        elif ch3 == "D":
                             return KEY_LEFT
-                        elif ch3 in ('5', '6'):
+                        elif ch3 in ("5", "6"):
                             click.getchar()  # consume ~
-                            return KEY_PAGE_UP if ch3 == '5' else KEY_PAGE_DOWN
+                            return KEY_PAGE_UP if ch3 == "5" else KEY_PAGE_DOWN
                     # Unknown sequence, ignore it
-                    return ''  # Return empty to ignore
+                    return ""  # Return empty to ignore
                 except Exception:
                     return KEY_ESCAPE
             # Unknown escape sequence, ignore
-            return ''
+            return ""
         return ch
     except Exception:
         pass
@@ -113,29 +115,29 @@ def _get_key() -> str:
             ch = sys.stdin.read(1)
 
             # Handle escape sequences (arrow keys, etc.)
-            if ch == '\x1b':
+            if ch == "\x1b":
                 # Check if more characters are available (escape sequence)
                 if select.select([sys.stdin], [], [], 0.05)[0]:
                     ch2 = sys.stdin.read(1)
-                    if ch2 == '[':
+                    if ch2 == "[":
                         # CSI sequence - read the final byte
                         if select.select([sys.stdin], [], [], 0.05)[0]:
                             ch3 = sys.stdin.read(1)
                             # Map to our key constants
-                            if ch3 == 'A':
+                            if ch3 == "A":
                                 return KEY_UP
-                            elif ch3 == 'B':
+                            elif ch3 == "B":
                                 return KEY_DOWN
-                            elif ch3 == 'C':
+                            elif ch3 == "C":
                                 return KEY_RIGHT
-                            elif ch3 == 'D':
+                            elif ch3 == "D":
                                 return KEY_LEFT
-                            elif ch3 == '5':
+                            elif ch3 == "5":
                                 # Page Up - consume the ~
                                 if select.select([sys.stdin], [], [], 0.05)[0]:
                                     sys.stdin.read(1)
                                 return KEY_PAGE_UP
-                            elif ch3 == '6':
+                            elif ch3 == "6":
                                 # Page Down - consume the ~
                                 if select.select([sys.stdin], [], [], 0.05)[0]:
                                     sys.stdin.read(1)
@@ -181,12 +183,12 @@ class InteractiveSelector:
     """
 
     # Checkbox characters (using larger circles for visibility)
-    CHECKBOX_EMPTY = '○'
-    CHECKBOX_CHECKED = '●'
+    CHECKBOX_EMPTY = "○"
+    CHECKBOX_CHECKED = "●"
 
     # Cursor indicator
-    CURSOR = '▶'
-    NO_CURSOR = ' '
+    CURSOR = "▶"
+    NO_CURSOR = " "
 
     def __init__(
         self,
@@ -194,11 +196,11 @@ class InteractiveSelector:
         columns: List[Dict[str, Any]],
         selected_ids: Set[Any],
         get_id: Callable[[Dict], Any],
-        title: str = 'SELECT ITEMS',
+        title: str = "SELECT ITEMS",
         page_size: int = 20,
         format_cell: Optional[Callable[[Dict, str], str]] = None,
         show_header_info: Optional[Callable[[], str]] = None,
-        extra_actions: Optional[Dict[str, str]] = None
+        extra_actions: Optional[Dict[str, str]] = None,
     ):
         """
         Initialize the interactive selector.
@@ -244,7 +246,7 @@ class InteractiveSelector:
             The modified selected_ids set
         """
         if not self.items:
-            click.echo(click.style("  No items to select.", fg='yellow'))
+            click.echo(click.style("  No items to select.", fg="yellow"))
             click.pause()
             return self.selected_ids
 
@@ -266,7 +268,11 @@ class InteractiveSelector:
         # Title
         click.echo()
         click.echo("┌" + "─" * (width - 2) + "┐")
-        click.echo("│" + click.style(f" {self.title} ".center(width - 2), bold=True, fg='cyan') + "│")
+        click.echo(
+            "│"
+            + click.style(f" {self.title} ".center(width - 2), bold=True, fg="cyan")
+            + "│"
+        )
         click.echo("└" + "─" * (width - 2) + "┘")
         click.echo()
 
@@ -280,13 +286,15 @@ class InteractiveSelector:
         # Stats
         total = len(self.items)
         selected_count = len(self.selected_ids)
-        click.echo(f"  {click.style('Total:', bold=True)} {total} items  |  "
-                   f"{click.style('Selected:', bold=True, fg='cyan')} {selected_count}")
+        click.echo(
+            f"  {click.style('Total:', bold=True)} {total} items  |  "
+            f"{click.style('Selected:', bold=True, fg='cyan')} {selected_count}"
+        )
         click.echo()
 
         # Calculate visible items
         page_end = min(self.page_start + self.page_size, len(self.items))
-        visible_items = self.items[self.page_start:page_end]
+        visible_items = self.items[self.page_start : page_end]
 
         # Create table
         table = Table(
@@ -294,7 +302,7 @@ class InteractiveSelector:
             header_style="bold cyan",
             box=DesignSystem.TABLE_BOX,
             padding=(0, 1),
-            expand=True
+            expand=True,
         )
 
         # Add cursor column
@@ -305,11 +313,11 @@ class InteractiveSelector:
         # Add user-defined columns
         for col in self.columns:
             table.add_column(
-                col['name'],
-                width=col.get('width'),
-                justify=col.get('justify', 'left'),
-                no_wrap=col.get('no_wrap', False),
-                style=col.get('style')
+                col["name"],
+                width=col.get("width"),
+                justify=col.get("justify", "left"),
+                no_wrap=col.get("no_wrap", False),
+                style=col.get("style"),
             )
 
         # Add rows
@@ -318,7 +326,7 @@ class InteractiveSelector:
             item_id = self.get_id(item)
 
             # Cursor indicator
-            is_cursor = (absolute_idx == self.cursor_pos)
+            is_cursor = absolute_idx == self.cursor_pos
             cursor = self.CURSOR if is_cursor else self.NO_CURSOR
 
             # Checkbox
@@ -329,13 +337,13 @@ class InteractiveSelector:
             row_values = [cursor, checkbox]
 
             for col in self.columns:
-                key = col['key']
+                key = col["key"]
                 if self.format_cell:
                     value = self.format_cell(item, key)
-                elif 'format' in col:
-                    value = col['format'](item.get(key, ''))
+                elif "format" in col:
+                    value = col["format"](item.get(key, ""))
                 else:
-                    value = str(item.get(key, '-') or '-')
+                    value = str(item.get(key, "-") or "-")
                 row_values.append(value)
 
             # Apply highlight style for cursor row
@@ -350,8 +358,7 @@ class InteractiveSelector:
         if len(self.items) > self.page_size:
             page_num = (self.page_start // self.page_size) + 1
             total_pages = (len(self.items) + self.page_size - 1) // self.page_size
-            click.echo(f"\n  Page {page_num}/{total_pages}  |  "
-                       f"p/n: Prev/Next page")
+            click.echo(f"\n  Page {page_num}/{total_pages}  |  " f"p/n: Prev/Next page")
 
         # Help bar
         click.echo()
@@ -375,7 +382,7 @@ class InteractiveSelector:
     def _handle_key(self, key: str):
         """Handle a keypress."""
         # Navigation - Up
-        if key in (KEY_UP, 'k'):
+        if key in (KEY_UP, "k"):
             if self.cursor_pos > 0:
                 self.cursor_pos -= 1
                 # Scroll up if needed
@@ -383,7 +390,7 @@ class InteractiveSelector:
                     self.page_start = max(0, self.page_start - self.page_size)
 
         # Navigation - Down
-        elif key in (KEY_DOWN, 'j'):
+        elif key in (KEY_DOWN, "j"):
             if self.cursor_pos < len(self.items) - 1:
                 self.cursor_pos += 1
                 # Scroll down if needed
@@ -391,14 +398,14 @@ class InteractiveSelector:
                     self.page_start += self.page_size
 
         # Page Up / Previous page
-        elif key in (KEY_PAGE_UP, 'p', '[', '<'):
+        elif key in (KEY_PAGE_UP, "p", "[", "<"):
             current_page = self.page_start // self.page_size
             if current_page > 0:
                 self.page_start = (current_page - 1) * self.page_size
                 self.cursor_pos = self.page_start
 
         # Page Down / Next page
-        elif key in (KEY_PAGE_DOWN, 'n', ']', '>'):
+        elif key in (KEY_PAGE_DOWN, "n", "]", ">"):
             total_pages = (len(self.items) + self.page_size - 1) // self.page_size
             current_page = self.page_start // self.page_size
             if current_page < total_pages - 1:
@@ -420,18 +427,18 @@ class InteractiveSelector:
                     self.selected_ids.add(item_id)
 
         # Select all
-        elif key == 'a':
+        elif key == "a":
             for item in self.items:
                 self.selected_ids.add(self.get_id(item))
 
         # Select none / Unselect all
-        elif key == 'u':
+        elif key == "u":
             # Only clear items that are in current list
             current_ids = {self.get_id(item) for item in self.items}
             self.selected_ids -= current_ids
 
         # Exit - q, Enter, or Escape
-        elif key in (KEY_ESCAPE, KEY_ENTER, 'q', '\x03', '\r', '\n'):  # \x03 is Ctrl+C
+        elif key in (KEY_ESCAPE, KEY_ENTER, "q", "\x03", "\r", "\n"):  # \x03 is Ctrl+C
             self.exit_key = key
             self.running = False
 
@@ -446,8 +453,8 @@ def interactive_select(
     columns: List[Dict[str, Any]],
     selected_ids: Set[Any],
     get_id: Callable[[Dict], Any],
-    title: str = 'SELECT ITEMS',
-    **kwargs
+    title: str = "SELECT ITEMS",
+    **kwargs,
 ) -> Set[Any]:
     """
     Convenience function to run an interactive selector.
@@ -469,6 +476,6 @@ def interactive_select(
         selected_ids=selected_ids,
         get_id=get_id,
         title=title,
-        **kwargs
+        **kwargs,
     )
     return selector.run()

souleyez/ui/log_formatter.py

@@ -11,72 +11,80 @@ from typing import List, Optional
 def format_json_log_line(line: str) -> Optional[str]:
     """
     Format a JSON log line into human-readable format.
-    
+
     Args:
         line: Raw JSON log line
-        
+
     Returns:
         Formatted string or None if not JSON
     """
     try:
         data = json.loads(line.strip())
-        
+
         # JSON can parse primitives (numbers, strings, booleans) - we only want objects
         if not isinstance(data, dict):
             return None
-        
+
         # Extract common fields
-        timestamp = data.get('timestamp', '')
-        level = data.get('levelname', 'INFO')
-        name = data.get('name', '')
-        message = data.get('message', '')
-        
+        timestamp = data.get("timestamp", "")
+        level = data.get("levelname", "INFO")
+        name = data.get("name", "")
+        message = data.get("message", "")
+
         # Parse timestamp
         if timestamp:
             try:
-                dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
-                time_str = dt.strftime('%H:%M:%S')
+                dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+                time_str = dt.strftime("%H:%M:%S")
             except:
                 time_str = timestamp[:8] if len(timestamp) > 8 else timestamp
         else:
-            time_str = '??:??:??'
-        
+            time_str = "??:??:??"
+
         # Color codes for log levels
         level_colors = {
-            'DEBUG': '\033[36m',    # Cyan
-            'INFO': '\033[32m',     # Green
-            'WARNING': '\033[33m',  # Yellow
-            'ERROR': '\033[31m',    # Red
-            'CRITICAL': '\033[35m'  # Magenta
+            "DEBUG": "\033[36m",  # Cyan
+            "INFO": "\033[32m",  # Green
+            "WARNING": "\033[33m",  # Yellow
+            "ERROR": "\033[31m",  # Red
+            "CRITICAL": "\033[35m",  # Magenta
         }
-        reset = '\033[0m'
-        
-        level_color = level_colors.get(level, '')
+        reset = "\033[0m"
+
+        level_color = level_colors.get(level, "")
         level_short = level[0]  # D, I, W, E, C
-        
+
         # Build formatted line
         formatted = f"{time_str} {level_color}[{level_short}]{reset} "
-        
+
         # Add module name if not too long
         if name and len(name) < 30:
-            module = name.split('.')[-1]  # Last part only
+            module = name.split(".")[-1]  # Last part only
             formatted += f"{module}: "
-        
+
         formatted += message
-        
+
         # Add interesting extra fields
         extras = []
-        skip_fields = {'timestamp', 'levelname', 'name', 'message', 'log_file', 'log_level', 'log_format'}
+        skip_fields = {
+            "timestamp",
+            "levelname",
+            "name",
+            "message",
+            "log_file",
+            "log_level",
+            "log_format",
+        }
         for key, value in data.items():
             if key not in skip_fields and value:
                 if isinstance(value, (str, int, float, bool)):
                     extras.append(f"{key}={value}")
-        
+
         if extras:
             formatted += f" ({', '.join(extras[:3])})"  # Limit to 3 extras
-        
+
         return formatted
-        
+
     except (json.JSONDecodeError, KeyError):
         # Not JSON or malformed
         return None
@@ -85,20 +93,20 @@ def format_json_log_line(line: str) -> Optional[str]:
 def format_log_stream(lines: List[str], max_lines: int = 50) -> List[str]:
     """
     Format a stream of log lines (mix of JSON and plain text).
-    
+
     Args:
         lines: List of raw log lines
         max_lines: Maximum lines to return
-        
+
     Returns:
         List of formatted lines
     """
     formatted = []
-    
+
     for line in lines[-max_lines:]:
         if not line.strip():
             continue
-        
+
         # Try JSON formatting first
         json_formatted = format_json_log_line(line)
         if json_formatted:
@@ -106,25 +114,25 @@ def format_log_stream(lines: List[str], max_lines: int = 50) -> List[str]:
         else:
             # Keep plain text as-is (tool output, etc.)
             formatted.append(line.rstrip())
-    
+
     return formatted
 
 
 def tail_and_format_log(log_path: str, num_lines: int = 50) -> List[str]:
     """
     Read last N lines from log file and format them.
-    
+
     Args:
         log_path: Path to log file
         num_lines: Number of lines to read
-        
+
     Returns:
         List of formatted lines
     """
     try:
-        with open(log_path, 'r', encoding='utf-8', errors='replace') as f:
+        with open(log_path, "r", encoding="utf-8", errors="replace") as f:
             lines = f.readlines()
-        
+
         return format_log_stream(lines, max_lines=num_lines)
     except Exception as e:
         return [f"Error reading log: {e}"]

souleyez/ui/menu_components.py

@@ -1,6 +1,7 @@
 """
 Reusable menu UI components for consistent layouts.
 """
+
 import click
 from typing import List, Dict
 from souleyez.ui.design_system import DesignSystem
@@ -10,7 +11,13 @@ class StandardMenu:
     """Standard menu renderer with consistent formatting."""
 
     @staticmethod
-    def render(options: List[Dict[str, str]], show_back: bool = True, shortcuts: Dict[str, int] = None, show_shortcuts: bool = True, tip: str = None):
+    def render(
+        options: List[Dict[str, str]],
+        show_back: bool = True,
+        shortcuts: Dict[str, int] = None,
+        show_shortcuts: bool = True,
+        tip: str = None,
+    ):
         """
         Render a standardized menu with single OPTIONS section.
 
@@ -29,14 +36,14 @@ class StandardMenu:
         width = DesignSystem.get_terminal_width()
 
         click.echo()
-        click.echo(click.style("⚙️  OPTIONS", bold=True, fg='cyan'))
+        click.echo(click.style("⚙️  OPTIONS", bold=True, fg="cyan"))
         click.echo("─" * width)
         click.echo()
 
         for opt in options:
-            number = opt['number']
-            label = opt['label']
-            desc = opt.get('description', '')
+            number = opt["number"]
+            label = opt["label"]
+            desc = opt.get("description", "")
 
             if desc:
                 click.echo(f"  [{number}] {label} - {desc}")
@@ -56,20 +63,20 @@ class StandardMenu:
             shortcut_hints = []
             for key, option_num in shortcuts.items():
                 # Map common shortcuts to their actions
-                if key == 'n':
+                if key == "n":
                     shortcut_hints.append(f"'{key}' = Next Page")
-                elif key == 'p':
+                elif key == "p":
                     shortcut_hints.append(f"'{key}' = Previous Page")
-                elif key == '>':
+                elif key == ">":
                     shortcut_hints.append("'>' = Next Page")
-                elif key == '<':
+                elif key == "<":
                     shortcut_hints.append("'<' = Previous Page")
-                elif key == '?':
+                elif key == "?":
                     shortcut_hints.append("'?' = Help")
                 else:
                     # For other shortcuts, try to find the label
                     for opt in options:
-                        if opt['number'] == option_num:
+                        if opt["number"] == option_num:
                             shortcut_hints.append(f"'{key}' = {opt['label']}")
                             break
             if shortcut_hints:
@@ -78,12 +85,14 @@ class StandardMenu:
         # Show tip if provided
         if tip:
             click.echo()
-            click.echo("  " + click.style("💡 TIP:", fg='cyan', bold=True) + " " + tip)
+            click.echo("  " + click.style("💡 TIP:", fg="cyan", bold=True) + " " + tip)
 
         click.echo()
 
         try:
-            choice_input = click.prompt("Select option", type=str, default="0", show_default=False)
+            choice_input = click.prompt(
+                "Select option", type=str, default="0", show_default=False
+            )
 
             # Handle keyboard shortcuts
             if shortcuts and choice_input.lower() in shortcuts: