webscout 7.8__py3-none-any.whl → 8.0__py3-none-any.whl

webscout/litprinter/__init__.py

@@ -1,667 +1,59 @@
-import sys
-import os
-import json
-import time
-import threading
-import re
-from typing import Any, Optional, TextIO, Union, Sequence, Dict, List
-import textwrap
-import shutil
-from .colors import Colors
-import ctypes
-
-# Checking Pygments availability
-try:
-    from pygments import highlight
-    from pygments.lexers import get_lexer_by_name
-    from pygments.formatters import Terminal256Formatter
-
-    PYGMENTS_AVAILABLE = True
-except ImportError:
-    PYGMENTS_AVAILABLE = False
-
-# Enabling UTF-8 output on Windows
-if sys.platform == 'win32':
-    import ctypes
-
-    kernel32 = ctypes.windll.kernel32
-    kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
-
-    # Checking and overriding sys.stdout
-    try:
-        if sys.stdout is not None:
-            sys.stdout.reconfigure(encoding='utf-8')
-        else:
-            print("sys.stdout is not available.")
-    except AttributeError:
-        print("Failed to redefine sys.stdout.")
-
-# Enabling ANSI escape sequences for Windows
-if os.name == 'nt':
-    kernel32 = ctypes.windll.kernel32
-    kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
-
-# Removed the duplicated Colors class to import from colors.py
-
-class SyntaxTheme:
-    """Syntax highlighting theme."""
-    KEYWORD = Colors.MAGENTA + Colors.BOLD
-    STRING = Colors.GREEN
-    NUMBER = Colors.CYAN
-    COMMENT = Colors.BRIGHT_BLACK + Colors.ITALIC
-    FUNCTION = Colors.BRIGHT_BLUE
-    CLASS = Colors.BRIGHT_YELLOW + Colors.BOLD
-    OPERATOR = Colors.WHITE
-    BRACKET = Colors.WHITE
-    VARIABLE = Colors.BRIGHT_WHITE
-
-class MarkdownTheme:
-    """Theme for markdown elements."""
-    H1 = Colors.BOLD + Colors.BLUE
-    H2 = Colors.BOLD + Colors.CYAN
-    H3 = Colors.BOLD + Colors.GREEN
-    BOLD = Colors.BOLD
-    ITALIC = Colors.ITALIC
-    CODE = Colors.YELLOW
-    LINK = Colors.BLUE + Colors.UNDERLINE
-    LIST_BULLET = Colors.CYAN + "•" + Colors.RESET
-    QUOTE = Colors.GRAY
-    STRIKE = Colors.STRIKE
-    TABLE = Colors.GREEN
-    TASK = Colors.YELLOW
-    DETAILS = Colors.MAGENTA
-
-class ThemeStyles:
-    SUCCESS = f"{Colors.GREEN}{Colors.BOLD}"
-    ERROR = f"{Colors.RED}{Colors.BOLD}"
-    WARNING = f"{Colors.YELLOW}{Colors.BOLD}"
-    INFO = f"{Colors.BLUE}{Colors.BOLD}"
-    DEBUG = f"{Colors.MAGENTA}"
-    CODE = f"{Colors.CYAN}"
-
-class HoverInfo:
-    """Hover information for different elements."""
-    BANNER = "A fancy banner to make your output pop!"
-    SUCCESS = "Something went right! "
-    ERROR = "Oops! Something went wrong "
-    WARNING = "Heads up! Something needs attention "
-    INFO = "Just some helpful info "
-    TABLE = "Data organized in rows and columns "
-    TREE = "Hierarchical data visualization "
-    JSON = "Pretty-printed JSON data "
-    CODE = "Syntax-highlighted code block "
-
-class ProgressBar:
-    def __init__(self, total: int, width: int = 40, prefix: str = '', suffix: str = ''):
-        self.total = total
-        self.width = width
-        self.prefix = prefix
-        self.suffix = suffix
-        self.current = 0
-        
-    def update(self, current: int):
-        self.current = current
-        filled = int(self.width * current / self.total)
-        bar = f"{Colors.GREEN}{'█' * filled}{Colors.RESET}{'░' * (self.width - filled)}"
-        percent = f"{Colors.CYAN}{int(100 * current / self.total)}%{Colors.RESET}"
-        print(f'\r{self.prefix} |{bar}| {percent} {self.suffix}', end='', flush=True)
-        if current >= self.total:
-            print()
-
-class Spinner:
-    def __init__(self, message: str = ''):
-        self.message = message
-        self.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-        self.running = False
-        self.thread = None
-        
-    def spin(self):
-        while self.running:
-            for frame in self.frames:
-                if not self.running:
-                    break
-                print(f'\r{Colors.CYAN}{frame}{Colors.RESET} {self.message}', end='', flush=True)
-                time.sleep(0.1)
-    
-    def __enter__(self):
-        self.start()
-        return self
-    
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.stop()
-    
-    def start(self):
-        self.running = True
-        self.thread = threading.Thread(target=self.spin)
-        self.thread.start()
-    
-    def stop(self):
-        self.running = False
-        if self.thread:
-            self.thread.join()
-        print('\r' + ' ' * (len(self.message) + 2), end='', flush=True)
-        print('\r', end='')
-
-class LitPrinter:
-    def __init__(self, 
-                 file: TextIO = sys.stdout, 
-                 theme: Optional[dict] = None, 
-                 indent_size: int = 4,
-                 buffer_size: int = 1024,
-                 syntax_theme: Optional[Dict[str, str]] = None,
-                 markdown_theme: Optional[Dict[str, str]] = None):
-        self.file = file
-        self.indent_size = indent_size
-        self.buffer_size = buffer_size
-        self._terminal_width = shutil.get_terminal_size().columns
-        self._last_line = ""
-        self._spinner_active = False
-        self._progress_active = False
-        
-        # Default theme
-        self.theme = theme or {
-            "str": Colors.WHITE,
-            "int": Colors.CYAN,
-            "float": Colors.CYAN,
-            "bool": Colors.YELLOW,
-            "list": Colors.MAGENTA,
-            "dict": Colors.BLUE,
-            "none": Colors.RED,
-            "timestamp": Colors.GREEN,
-            "key": Colors.YELLOW,
-            "bracket": Colors.BLUE,
-            "comma": Colors.WHITE,
-            "colon": Colors.WHITE,
-            "url": f"{Colors.BLUE}{Colors.UNDERLINE}",
-            "number": Colors.CYAN,
-            "special": Colors.MAGENTA + Colors.BOLD,
-            "error": Colors.RED + Colors.BOLD,
-            "warning": Colors.YELLOW + Colors.BOLD,
-            "success": Colors.GREEN + Colors.BOLD,
-            "info": Colors.BLUE + Colors.BOLD,
-        }
-        
-        self.syntax_theme = syntax_theme or vars(SyntaxTheme)
-        self.markdown_theme = markdown_theme or vars(MarkdownTheme)
-        
-    def _get_terminal_width(self) -> int:
-        """Get the terminal width or default to 80."""
-        try:
-            width = shutil.get_terminal_size().columns
-            return width if width > 0 else 80
-        except:
-            return 80
-
-    def _format_dict(self, d: dict, indent_level: int = 0) -> str:
-        """Format dictionary with proper indentation and colors."""
-        if not d:
-            return f"{self.theme['bracket']}{{}}{Colors.RESET}"
-
-        indent = " " * (self.indent_size * indent_level)
-        next_indent = " " * (self.indent_size * (indent_level + 1))
-        
-        lines = [f"{self.theme['bracket']}{{{Colors.RESET}"]
-        
-        for i, (key, value) in enumerate(d.items()):
-            # Format key with quotes if it's a string
-            if isinstance(key, str):
-                formatted_key = f"{self.theme['key']}'{key}'{Colors.RESET}"
-            else:
-                formatted_key = f"{self.theme['key']}{key}{Colors.RESET}"
-                
-            # Format value based on type
-            if isinstance(value, dict):
-                formatted_value = self._format_dict(value, indent_level + 1)
-            elif isinstance(value, str):
-                # Special handling for URLs
-                if any(url_prefix in value.lower() for url_prefix in ['http://', 'https://', 'www.']):
-                    formatted_value = f"{self.theme['url']}{value}{Colors.RESET}"
-                else:
-                    # Word wrap long strings
-                    if len(value) > 80:
-                        wrapped = textwrap.fill(value, width=80, subsequent_indent=next_indent + "    ")
-                        formatted_value = f"{self.theme['str']}'{wrapped}'{Colors.RESET}"
-                    else:
-                        formatted_value = f"{self.theme['str']}'{value}'{Colors.RESET}"
-            elif isinstance(value, (int, float)):
-                formatted_value = f"{self.theme['number']}{value}{Colors.RESET}"
-            elif isinstance(value, bool):
-                formatted_value = f"{self.theme['bool']}{value}{Colors.RESET}"
-            elif value is None:
-                formatted_value = f"{self.theme['none']}None{Colors.RESET}"
-            else:
-                formatted_value = self._format_value(value)
-            
-            # Add comma if not last item
-            comma = f"{self.theme['comma']},{Colors.RESET}" if i < len(d) - 1 else ""
-            
-            lines.append(f"{next_indent}{formatted_key}{self.theme['colon']}: {Colors.RESET}{formatted_value}{comma}")
-        
-        lines.append(f"{indent}{self.theme['bracket']}}}{Colors.RESET}")
-        return '\n'.join(lines)
-
-    def _format_sequence(self, seq: Sequence, indent_level: int = 0) -> str:
-        """Format sequences (lists, tuples, sets) with proper indentation."""
-        if not seq:
-            return f"{self.theme['bracket']}[]{Colors.RESET}"
-
-        indent = " " * (self.indent_size * indent_level)
-        next_indent = " " * (self.indent_size * (indent_level + 1))
-        
-        lines = [f"{self.theme['bracket']}[{Colors.RESET}"]
-        
-        for i, item in enumerate(seq):
-            formatted_item = self._format_value(item, indent_level + 1)
-            comma = f"{self.theme['comma']},{Colors.RESET}" if i < len(seq) - 1 else ""
-            lines.append(f"{next_indent}{formatted_item}{comma}")
-        
-        lines.append(f"{indent}{self.theme['bracket']}]{Colors.RESET}")
-        return '\n'.join(lines)
-
-    def _format_value(self, value: Any, indent_level: int = 0) -> str:
-        """Enhanced format for any value with proper indentation and styling."""
-        if value is None:
-            return f"{self.theme['none']}None{Colors.RESET}"
-        
-        if isinstance(value, dict):
-            return self._format_dict(value, indent_level)
-        
-        if isinstance(value, (list, tuple, set)):
-            return self._format_sequence(value, indent_level)
-        
-        if isinstance(value, str):
-            return str(value)
-        
-        if isinstance(value, bool):
-            return f"{self.theme['bool']}{str(value)}{Colors.RESET}"
-        
-        if isinstance(value, (int, float)):
-            return f"{self.theme['number']}{str(value)}{Colors.RESET}"
-        
-        if hasattr(value, '__dict__'):
-            return self._format_dict(value.__dict__, indent_level)
-        
-        return str(value)
-
-    def _highlight_code(self, code: str, language: str = "python") -> str:
-        """Print code with that extra drip """
-        if PYGMENTS_AVAILABLE:
-            try:
-                lexer = get_lexer_by_name(language)
-                formatter = Terminal256Formatter(style='monokai')
-                return highlight(code, lexer, formatter)
-            except:
-                pass
-        
-        if language != 'python':
-            return code
-
-        lines = []
-        for line in code.split('\n'):
-            if '#' in line:
-                code_part, comment_part = line.split('#', 1)
-                line = code_part + f"{self.syntax_theme['COMMENT']}#{comment_part}{Colors.RESET}"
-            
-            line = re.sub(r'(".*?"|\'.*?\')', 
-                         f"{self.syntax_theme['STRING']}\\1{Colors.RESET}", line)
-            
-            line = re.sub(r'\b(\d+)\b', 
-                         f"{self.syntax_theme['NUMBER']}\\1{Colors.RESET}", line)
-            
-            keywords = ['def', 'class', 'if', 'else', 'elif', 'for', 'while', 'try',
-                       'except', 'finally', 'with', 'as', 'import', 'from', 'return']
-            
-            for keyword in keywords:
-                line = re.sub(f'\\b{keyword}\\b', 
-                            f"{self.syntax_theme['KEYWORD']}{keyword}{Colors.RESET}", line)
-            
-            lines.append(line)
-        
-        return '\n'.join(lines)
-
-    def _format_markdown_stream(self, text: str) -> str:
-        """Enhanced markdown formatting for streaming mode."""
-        # Headers with emoji flair
-        text = re.sub(r'^# (.+)$', f"{self.markdown_theme['H1']}🔥 \\1{Colors.RESET}", text, flags=re.M)
-        text = re.sub(r'^## (.+)$', f"{self.markdown_theme['H2']}✨ \\1{Colors.RESET}", text, flags=re.M)
-        text = re.sub(r'^### (.+)$', f"{self.markdown_theme['H3']}💫 \\1{Colors.RESET}", text, flags=re.M)
-        
-        # Bold, italic, and combined with multiple styles
-        text = re.sub(r'\*\*\*(.+?)\*\*\*', f"{Colors.BOLD}{Colors.ITALIC}\\1{Colors.RESET}", text)
-        text = re.sub(r'\*\*(.+?)\*\*', f"{Colors.BOLD}\\1{Colors.RESET}", text)
-        text = re.sub(r'\*(.+?)\*', f"{Colors.ITALIC}\\1{Colors.RESET}", text)
-        text = re.sub(r'__(.+?)__', f"{Colors.BOLD}\\1{Colors.RESET}", text)
-        text = re.sub(r'_(.+?)_', f"{Colors.ITALIC}\\1{Colors.RESET}", text)
-        
-        # Code blocks and inline code
-        text = re.sub(r'```(\w+)?\n(.*?)\n```', lambda m: self._highlight_code(m.group(2), m.group(1) or 'text'), text, flags=re.S)
-        text = re.sub(r'`(.+?)`', f"{Colors.CYAN}\\1{Colors.RESET}", text)
-        
-        # Lists with proper indentation and bullets
-        lines = text.split('\n')
-        formatted_lines = []
-        for i, line in enumerate(lines):
-            # Match different bullet point styles
-            bullet_match = re.match(r'^(\s*)([-•*]|\d+\.) (.+)$', line)
-            if bullet_match:
-                indent, bullet, content = bullet_match.groups()
-                indent_level = len(indent) // 2
-                
-                # Choose bullet style based on nesting level
-                if indent_level == 0:
-                    bullet_style = "•"
-                elif indent_level == 1:
-                    bullet_style = "◦"
-                else:
-                    bullet_style = "▪"
-                
-                # Format the line with proper indentation and bullet
-                formatted_line = f"{' ' * (indent_level * 2)}{Colors.CYAN}{bullet_style}{Colors.RESET} {content}"
-                formatted_lines.append(formatted_line)
-            else:
-                formatted_lines.append(line)
-        text = '\n'.join(formatted_lines)
-        
-        # Links with underline
-        text = re.sub(r'\[(.+?)\]\((.+?)\)', f"{Colors.BLUE}{Colors.UNDERLINE}\\1{Colors.RESET}", text)
-        
-        # Blockquotes with style
-        text = re.sub(r'^> (.+)$', f"{self.markdown_theme['QUOTE']}│ \\1{Colors.RESET}", text, flags=re.M)
-        
-        # Strikethrough
-        text = re.sub(r'~~(.+?)~~', f"{Colors.STRIKE}\\1{Colors.RESET}", text)
-        
-        # Task lists with fancy checkboxes
-        text = re.sub(r'- \[ \] (.+)$', f"{self.markdown_theme['TASK']}☐ \\1{Colors.RESET}", text, flags=re.M)
-        text = re.sub(r'- \[x\] (.+)$', f"{self.markdown_theme['TASK']}☑ \\1{Colors.RESET}", text, flags=re.M)
-        
-        # Tables with borders
-        table_pattern = r'\|(.+?)\|[\r\n]+\|[-:| ]+\|[\r\n]+((?:\|.+?\|[\r\n]+)+)'
-        text = re.sub(table_pattern, self._format_table_markdown, text, flags=re.M)
-        
-        return text
-
-    def _format_table_markdown(self, match) -> str:
-        """Format markdown tables with style."""
-        header = [cell.strip() for cell in match.group(1).split('|') if cell.strip()]
-        rows = []
-        for row in match.group(2).strip().split('\n'):
-            cells = [cell.strip() for cell in row.split('|')[1:-1]]
-            if cells:
-                rows.append(cells)
-        
-        # Get column widths
-        widths = [max(len(str(row[i])) for row in [header] + rows) for i in range(len(header))]
-        
-        # Build table
-        result = []
-        # Header
-        result.append('┌' + '┬'.join('─' * (w + 2) for w in widths) + '┐')
-        result.append('│ ' + ' │ '.join(f"{h:<{w}}" for h, w in zip(header, widths)) + ' │')
-        result.append('├' + '┼'.join('─' * (w + 2) for w in widths) + '┤')
-        # Rows
-        for row in rows:
-            result.append('│ ' + ' │ '.join(f"{str(c):<{w}}" for c, w in zip(row, widths)) + ' │')
-        result.append('└' + '┴'.join('─' * (w + 2) for w in widths) + '┘')
-        
-        return '\n'.join(result)
-
-    def print(self, *args, 
-             # Builtin print compatibility
-             sep: str = " ",
-             end: str = "\n",
-             file: Optional[TextIO] = None,
-             flush: bool = True,
-             
-             # Styling options
-             style: Optional[str] = None,
-             color: Optional[str] = None,
-             bg_color: Optional[str] = None,
-             bold: bool = False,
-             italic: bool = False,
-             underline: bool = False,
-             blink: bool = False,
-             strike: bool = False,
-             dim: bool = False,
-             reverse: bool = False,
-             
-             # Layout options
-             markdown: Optional[bool] = None,
-             highlight: bool = False,
-             center: bool = False,
-             indent: int = 0,
-             prefix: Optional[str] = None,
-             suffix: Optional[str] = None,
-             width: Optional[int] = None,
-             padding: int = 0,
-             margin: int = 0,
-             align: str = "left",
-             
-             # Border options
-             border: bool = False,
-             border_style: Optional[str] = None,
-             border_char: str = "─",
-             border_color: Optional[str] = None,
-             rounded_corners: bool = False,
-             double_border: bool = False,
-             
-             # Animation options
-             animate: bool = False,
-             animation_speed: float = 0.05,
-             animation_type: str = "typing",
-             
-             # Special features
-             as_table: bool = False,
-             as_tree: bool = False,
-             as_json: bool = False,
-             as_code: bool = False,
-             language: str = "python",
-             
-             # Advanced features
-             raw: bool = False) -> None:
-        """
-        Enhanced print with all builtin features plus rich formatting.
-        
-        Supports all builtin print parameters plus rich formatting features.
-        Automatically detects and formats markdown content unless explicitly disabled.
-        """
-        # Handle raw output mode
-        if raw:
-            print(*args, sep=sep, end=end, file=file or self.file, flush=flush)
-            return
-            
-        # Join args with separator
-        output = sep.join(str(arg) for arg in args)
-        
-        # Auto-detect markdown if not explicitly set
-        if markdown is None:  
-            markdown = any(marker in output for marker in [
-                '#', '*', '_', '`', '>', '-', '•', '|',  
-                # '✨', '🔥', '💫', '☐', '☑',             
-                'http://', 'https://',                   
-                '```', '~~~',                           
-                '<details>', '<summary>',               
-            ])
-        
-        # Apply markdown formatting if enabled
-        if markdown:
-            output = self._format_markdown_stream(output)
-        
-        # Build style string
-        style_str = style or ""
-        if color:
-            style_str += getattr(Colors, color.upper(), "")
-        if bg_color:
-            style_str += getattr(Colors, f"BG_{bg_color.upper()}", "")
-        if bold:
-            style_str += Colors.BOLD
-        if italic:
-            style_str += Colors.ITALIC
-        if underline:
-            style_str += Colors.UNDERLINE
-        if blink:
-            style_str += Colors.BLINK
-        if strike:
-            style_str += Colors.STRIKE
-        if dim:
-            style_str += Colors.DIM
-        if reverse:
-            style_str += Colors.REVERSE
-        
-        # Apply style if any
-        if style_str:
-            output = f"{style_str}{output}{Colors.RESET}"
-        
-        # Handle special formatting
-        if as_json:
-            output = self._format_json(output)
-        elif as_code:
-            output = self._highlight_code(output, language)
-        elif as_table:
-            if isinstance(output, (list, tuple)):
-                self.table(*output)
-                return
-        elif as_tree:
-            if isinstance(output, (dict, list)):
-                self.tree(output)
-                return
-        
-        # Apply layout options
-        if center:
-            term_width = self._get_terminal_width()
-            output = output.center(term_width)
-        if indent > 0:
-            output = " " * (indent * 4) + output
-        if prefix:
-            output = prefix + output
-        if suffix:
-            output = output + suffix
-        if width:
-            output = textwrap.fill(output, width=width)
-        
-        # Add borders
-        if border:
-            width = max(len(line) for line in output.split('\n'))
-            border_top = '┌' + border_char * width + '┐'
-            border_bottom = '└' + border_char * width + '┘'
-            output = f"{border_top}\n{output}\n{border_bottom}"
-        
-        # Handle animation
-        if animate:
-            for char in output:
-                print(char, end="", flush=True)
-                time.sleep(animation_speed)
-            print(end=end, flush=flush)
-            return
-        
-        # Final output
-        print(output, end=end, file=file or self.file, flush=flush)
-
-    def status(self, text: str, style: Optional[str] = None):
-        """Print a status message that can be overwritten."""
-        style = style or self.theme['info']
-        self._clear_line()
-        self._last_line = f"{style}{text}{Colors.RESET}"
-        print(self._last_line, end='\r', file=self.file, flush=True)
-
-    def banner(self, text: str, style: Optional[str] = None):
-        """Print a fancy banner with hover info."""
-        print(f"\033]1337;Custom=id=banner:{HoverInfo.BANNER}\a", end='')
-        style = style or self.theme['special']
-        width = self._get_terminal_width() - 4
-        
-        lines = textwrap.wrap(text, width=width, break_long_words=False)
-        
-        print('╔' + '═' * width + '╗')
-        for line in lines:
-            padding = width - len(line)
-            print('║ ' + line + ' ' * padding + ' ║')
-        print('╚' + '═' * width + '╝')
-        print("\033]1337;Custom=id=banner:end\a", end='')
-
-    def success(self, text: str):
-        """Print a success message with hover info."""
-        print(f"\033]1337;Custom=id=success:{HoverInfo.SUCCESS}\a", end='')
-        self.print(f"✓ {text}", style=self.theme['success'])
-        print("\033]1337;Custom=id=success:end\a", end='')
-
-    def error(self, text: str):
-        """Print an error message with hover info."""
-        print(f"\033]1337;Custom=id=error:{HoverInfo.ERROR}\a", end='')
-        self.print(f"✗ {text}", style=self.theme['error'])
-        print("\033]1337;Custom=id=error:end\a", end='')
-
-    def warning(self, text: str):
-        """Print a warning message with hover info."""
-        print(f"\033]1337;Custom=id=warning:{HoverInfo.WARNING}\a", end='')
-        self.print(f"⚠ {text}", style=self.theme['warning'])
-        print("\033]1337;Custom=id=warning:end\a", end='')
-
-    def info(self, text: str):
-        """Print an info message with hover info."""
-        print(f"\033]1337;Custom=id=info:{HoverInfo.INFO}\a", end='')
-        self.print(f"ℹ {text}", style=self.theme['info'])
-        print("\033]1337;Custom=id=info:end\a", end='')
-
-    def table(self, headers: List[str], rows: List[List[Any]], style: Optional[str] = None):
-        """Print a formatted table."""
-        style = style or self.theme['special']
-        
-        col_widths = [len(h) for h in headers]
-        for row in rows:
-            for i, cell in enumerate(row):
-                col_widths[i] = max(col_widths[i], len(str(cell)))
-
-        header_line = '| ' + ' | '.join(f"{h:<{w}}" for h, w in zip(headers, col_widths)) + ' |'
-        print(header_line)
-
-        separator = '+' + '+'.join('-' * (w + 2) for w in col_widths) + '+'
-        print(separator)
-
-        for row in rows:
-            row_line = '| ' + ' | '.join(f"{str(cell):<{w}}" for cell, w in zip(row, col_widths)) + ' |'
-            print(row_line)
-
-    def tree(self, data: Union[Dict, List], indent: int = 0):
-        """Print a tree structure of nested data."""
-        if isinstance(data, dict):
-            for key, value in data.items():
-                self.print("  " * indent + "├─ " + str(key) + ":", style=self.theme['key'])
-                if isinstance(value, (dict, list)):
-                    self.tree(value, indent + 1)
-                else:
-                    self.print("  " * (indent + 1) + "└─ " + str(value))
-        elif isinstance(data, list):
-            for item in data:
-                if isinstance(item, (dict, list)):
-                    self.tree(item, indent + 1)
-                else:
-                    self.print("  " * indent + "├─ " + str(item))
-
-    def json(self, data: Any, indent: int = 4):
-        """Print formatted JSON data."""
-        formatted = json.dumps(data, indent=indent)
-        self.print(formatted, highlight=True)
-
-    def code_block(self, code: str, language: str = "python"):
-        """Print code in a fancy box with syntax highlighting."""
-        highlighted = self._highlight_code(code, language)
-        lines = highlighted.split('\n')
-        
-        width = max(len(line) for line in lines)
-        width = min(width, self._get_terminal_width() - 4)  # Account for borders
-        
-        print('┌' + '─' * width + '┐')
-        
-        for line in lines:
-            if len(line) > width:
-                line = line[:width-3] + '...'
-            else:
-                line = line + ' ' * (width - len(line))
-            print('│ ' + line + ' │')
-        
-        print('└' + '─' * width + '┘')
-
-    def _clear_line(self):
-        """Clear the current line."""
-        print('\r' + ' ' * self._get_terminal_width(), end='\r', file=self.file, flush=True)
+"""
+>>> from litprinter import litprint
+>>> from litprinter import lit
+>>> from litprinter import install, uninstall
+>>>
+>>> litprint("Hello, world!")
+LIT -> [__main__.py:1] in () >>> Hello, world!
+>>>
+>>> def my_function():
+...    lit(1, 2, 3)
+>>> my_function()
+LIT -> [__main__.py:4] in my_function() >>> 1, 2, 3
+>>> install()
+>>> ic("This is now the builtins.ic()")
+LIT -> [__main__.py:7] in () >>> This is now the builtins.ic()
+>>> uninstall()
+
+This module provides enhanced print and logging functionalities for Python,
+allowing developers to debug their code with style and precision. It
+includes the litprint and lit functions for debugging, log for logging, and
+install/uninstall functions for integration into the builtins module.
+It also handles colorizing output and provides different styles and customizable
+options.
+
+LITPRINTER is inspired by the icecream package and provides similar functionality
+with additional features:
+- Variable inspection with expression display
+- Return value handling for inline usage
+- Support for custom formatters for specific data types
+- Execution context tracking
+- Rich-like colorized output with multiple themes (JARVIS, RICH, MODERN, NEON, CYBERPUNK)
+- Better JSON formatting with indent=2 by default
+- Advanced pretty printing for complex data structures with smart truncation
+- Clickable file paths in supported terminals and editors (VSCode compatible)
+- Enhanced visual formatting with better spacing and separators
+- Special formatters for common types (Exception, bytes, set, frozenset, etc.)
+- Smart object introspection for custom classes
+- Logging capabilities with timestamp and log levels
+"""
+
+# Try to import from the standalone litprinter package first
+# If it's not installed
+try:
+    import litprinter
+    # If standalone package is found, re-export all its components
+    from litprinter import litprint, lit, log, ic, install, uninstall
+    from litprinter import LITPrintDebugger, argumentToString
+    from litprinter import JARVIS, RICH, MODERN, NEON, CYBERPUNK, create_custom_style
+    from litprinter import traceback   
+    # For compatibility with icecream
+    enable = litprinter.enable
+    disable = litprinter.disable
+    
+except ImportError:
+    # Raise a more informative error when litprinter is not installed
+    raise ImportError(
+        "The 'litprinter' package is required but not installed. "
+        "Please install it using: pip install litprinter"
+    ) from None