logscope-cli 0.4.1__py3-none-any.whl

logscope/__init__.py

@@ -0,0 +1,4 @@
+"""
+LogScope — Beautiful log viewer for the terminal
+"""
+__version__ = "0.4.1"

logscope/cli.py

@@ -0,0 +1,187 @@
+import sys
+import gzip
+import typer
+import re
+import json
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Optional
+from typing_extensions import Annotated
+from .viewer import stream_logs, run_dashboard, manager
+
+app = typer.Typer(
+    help="LogScope — Beautiful log viewer for the terminal",
+    add_completion=False,
+    rich_markup_mode="rich"
+)
+
+def parse_relative_time(time_str: str) -> Optional[datetime]:
+    """Parse relative time like '10m', '1h', '2d' or ISO strings."""
+    if not time_str:
+        return None
+
+    # Check if absolute ISO format first
+    try:
+        return datetime.fromisoformat(time_str.replace('Z', '+00:00'))
+    except ValueError:
+        pass
+
+    # Regex for relative formats: <digit><unit>
+    match = re.match(r'^(\d+)([smhd])$', time_str.lower())
+    if not match:
+        return None
+
+    value, unit = int(match.group(1)), match.group(2)
+    now = datetime.now()
+
+    if unit == 's':
+        return now - timedelta(seconds=value)
+    if unit == 'm':
+        return now - timedelta(minutes=value)
+    if unit == 'h':
+        return now - timedelta(hours=value)
+    if unit == 'd':
+        return now - timedelta(days=value)
+
+    return None
+
+def load_theme(requested_theme: Optional[str], no_color: bool = False):
+    """Load theme from config file or use requested/default. Persist if requested."""
+    config_file = Path(".logscoperc")
+    if not config_file.exists():
+        config_file = Path.home() / ".logscoperc"
+
+    config = {}
+    if config_file.exists():
+        try:
+            with open(config_file, "r", encoding="utf-8") as f:
+                config = json.load(f)
+        except Exception:
+            pass
+
+    # If requested via CLI, save it to the config for future use
+    if requested_theme:
+        config["theme"] = requested_theme
+        try:
+            # We prefer saving to local .logscoperc if it exists, otherwise home. 
+            # If neither exists, we'll create one in the home directory for persistence.
+            save_path = Path(".logscoperc") if Path(".logscoperc").exists() else Path.home() / ".logscoperc"
+            with open(save_path, "w", encoding="utf-8") as f:
+                json.dump(config, f, indent=4)
+            manager.console.print(f"[bold green]✅ Theme '{requested_theme}' saved as your default preference![/bold green]")
+        except Exception as e:
+            manager.console.print(f"[dim red]⚠️ Failed to save theme preference: {e}[/dim red]")
+    else:
+        requested_theme = config.get("theme", "default")
+
+    if "custom_themes" in config:
+        # Merge custom themes into a copy of DEFAULT_THEMES to avoid mutating the module global
+        from .themes import DEFAULT_THEMES
+        themes_copy = dict(DEFAULT_THEMES)
+        themes_copy.update(config["custom_themes"])
+        manager.apply_theme(requested_theme, custom_themes=themes_copy, no_color=no_color)
+    else:
+        manager.apply_theme(requested_theme, no_color=no_color)
+
+@app.command()
+def main(
+    log_file: Annotated[Optional[Path], typer.Argument(help="Path to the log file (leave empty to read from STDIN via pipe)")] = None,
+    follow: Annotated[bool, typer.Option("--follow", "-f", help="Follow log output in real-time (like tail -f)")] = False,
+    level: Annotated[Optional[str], typer.Option("--level", "-l", help="Filter by level; comma-separated for multiple (e.g. ERROR,WARN,INFO)")] = None,
+    min_level: Annotated[Optional[str], typer.Option("--min-level", "-m", help="Show logs at or above this level threshold (e.g. WARN shows WARN, ERROR, CRITICAL, ALERT, FATAL)")] = None,
+    search: Annotated[Optional[str], typer.Option("--search", "-s", help="Search string to filter logs (substring unless --regex)")] = None,
+    dashboard: Annotated[bool, typer.Option("--dashboard", "-d", help="Open visual dashboard showing log statistics")] = False,
+    export_html: Annotated[Optional[Path], typer.Option("--export-html", help="Export the beautiful log output to an HTML file")] = None,
+    line_numbers: Annotated[bool, typer.Option("--line-numbers", "-n", help="Show line numbers for each log message")] = False,
+    since: Annotated[Optional[str], typer.Option("--since", help="Show logs since a point in time (e.g. '1h', '30m', '2026-01-01T00:00:00')")] = None,
+    until: Annotated[Optional[str], typer.Option("--until", help="Show logs until a point in time")] = None,
+    theme: Annotated[Optional[str], typer.Option("--theme", "-t", help="Choose a theme for colors and emojis (default, neon, ocean, forest, minimal)")] = None,
+    use_regex: Annotated[bool, typer.Option("--regex", "-e", help="Treat --search as a regular expression")] = False,
+    case_sensitive: Annotated[bool, typer.Option("--case-sensitive", help="Case-sensitive substring or regex search")] = False,
+    invert_match: Annotated[bool, typer.Option("--invert-match", "-v", help="Hide lines that match --search (grep -v)")] = False,
+    no_color: Annotated[bool, typer.Option("--no-color", help="Disable colors and terminal highlighting")] = False,
+    highlight: Annotated[Optional[str], typer.Option("--highlight", "-H", help="Highlight specific keyword in log messages (can be used multiple times)")] = None,
+    highlight_color: Annotated[str, typer.Option("--highlight-color", help="Rich style for highlighted keywords (default: bold magenta)")] = "bold magenta",
+):
+    """
+    [blue]LogScope[/blue] parses standard logs and makes them [bold]beautiful[/bold] and [bold]readable[/bold].
+    """
+    if use_regex and not search:
+        typer.echo("❌ Error: --regex requires --search.", err=True)
+        raise typer.Exit(1)
+    if invert_match and not search:
+        typer.echo("❌ Error: --invert-match requires --search.", err=True)
+        raise typer.Exit(1)
+
+    search_pattern = None
+    if search and use_regex:
+        try:
+            flags = 0 if case_sensitive else re.IGNORECASE
+            search_pattern = re.compile(search, flags)
+        except re.error as exc:
+            typer.echo(f"❌ Error: invalid regular expression: {exc}", err=True)
+            raise typer.Exit(1)
+
+    if log_file is None:
+        if sys.stdin.isatty():
+            typer.echo("❌ Error: Please provide a log file path or pipe data to STDIN (cat file | logscope).", err=True)
+            raise typer.Exit(1)
+        file_obj = sys.stdin
+    else:
+        if log_file.suffix.lower() == ".gz":
+            file_obj = gzip.open(log_file, "rt", encoding="utf-8", errors="replace")
+        else:
+            file_obj = open(log_file, "r", encoding="utf-8", errors="replace")
+
+    since_dt = parse_relative_time(since) if since else None
+    until_dt = parse_relative_time(until) if until else None
+
+    load_theme(theme, no_color=no_color)
+
+    # Inform user about themes only if they are using default and haven't hidden the tip by having a config
+    has_config = Path(".logscoperc").exists() or (Path.home() / ".logscoperc").exists()
+    if not theme and not has_config:
+        manager.console.print("[dim]💡 Tip: Use '--theme' or create a '.logscoperc' file to change colors. Themes: neon, ocean, forest, minimal[/dim]\n")
+
+    try:
+        if dashboard:
+            run_dashboard(
+                file_obj,
+                follow=follow,
+                level_filter=level,
+                search_filter=search,
+                show_line_numbers=line_numbers,
+                since=since_dt,
+                until=until_dt,
+                use_regex=use_regex,
+                search_pattern=search_pattern,
+                case_sensitive=case_sensitive,
+                invert_match=invert_match,
+                highlight=highlight,
+                highlight_color=highlight_color,
+                min_level=min_level,
+            )
+        else:
+            stream_logs(
+                file_obj,
+                follow=follow,
+                level=level,
+                search=search,
+                export_html=export_html,
+                show_line_numbers=line_numbers,
+                since=since_dt,
+                until=until_dt,
+                use_regex=use_regex,
+                search_pattern=search_pattern,
+                case_sensitive=case_sensitive,
+                invert_match=invert_match,
+                highlight=highlight,
+                highlight_color=highlight_color,
+                min_level=min_level,
+            )
+    finally:
+        if log_file is not None:
+            file_obj.close()
+
+if __name__ == "__main__":
+    app()

logscope/parser.py

@@ -0,0 +1,188 @@
+import re
+import json
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional, Tuple
+
+# Compiled regex patterns for performance
+_BRACKET_LEVEL_PATTERN = re.compile(
+    r'\[(TRACE|DEBUG|INFO|NOTICE|WARN|WARNING|ERROR|ERR|CRITICAL|ALERT|FATAL|EMERGENCY)\]',
+    re.IGNORECASE
+)
+_BRACKETLESS_LEVEL_PATTERN = re.compile(
+    r'\b(TRACE|DEBUG|INFO|NOTICE|WARN|WARNING|ERROR|ERR|CRITICAL|ALERT|FATAL|EMERGENCY)\b',
+    re.IGNORECASE
+)
+
+# Multiple timestamp patterns for different log formats
+_TIMESTAMP_PATTERNS = [
+    # ISO 8601: 2026-03-21T10:00:00Z or 2026-03-21T10:00:00.123Z or 2026-03-21T10:00:00+00:00
+    re.compile(r'(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)'),
+    # ISO-like with space: 2026-03-21 10:00:00 or 2026-03-21 10:00:00.123
+    re.compile(r'(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}(?:\.\d+)?)'),
+    # Common Log Format / Apache: 21/Mar/2026:10:00:00 +0000 or [21/Mar/2026:10:00:00 +0000]
+    re.compile(r'(\d{2}/[A-Za-z]{3}/\d{4}:\d{2}:\d{2}:\d{2}(?:\s+[+-]\d{4})?)'),
+    # Syslog-style: Mar 21 10:00:00 (year is assumed current year)
+    re.compile(r'([A-Za-z]{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2})'),
+    # Unix timestamp: 1711054800 (10 digits for seconds)
+    re.compile(r'\b(\d{10})\b'),
+]
+
+# Month name mapping for parsing
+_MONTH_MAP = {
+    'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
+    'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12
+}
+
+@dataclass
+class LogEntry:
+    level: str
+    message: str
+    raw: str
+    timestamp: Optional[datetime] = None
+    service: Optional[str] = None
+    trace_id: Optional[str] = None
+    span_id: Optional[str] = None
+
+
+# Level normalization constants
+_NORMALIZE_LEVEL_MAP = {
+    "WARNING": "WARN",
+    "EMERGENCY": "FATAL",
+    "ERR": "ERROR",
+}
+
+
+def _normalize_level(level: str) -> str:
+    """Normalize log level aliases to canonical forms."""
+    return _NORMALIZE_LEVEL_MAP.get(level.upper(), level.upper())
+
+
+def _extract_json_observability(data: dict) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    """Pull service / trace / span from common JSON log shapes (K8s, OTel, Docker)."""
+    k8s = data.get("kubernetes")
+    k8s_d: dict = k8s if isinstance(k8s, dict) else {}
+    pod_name = k8s_d.get("pod_name")
+    if not pod_name and isinstance(k8s_d.get("pod"), dict):
+        pod_name = k8s_d["pod"].get("name")
+
+    service = (
+        data.get("service")
+        or data.get("service.name")
+        or data.get("service_name")
+        or pod_name
+        or k8s_d.get("container_name")
+        or data.get("container")
+        or data.get("container.name")
+        or data.get("logger")
+        or data.get("logger.name")
+    )
+    if service is not None:
+        service = str(service)
+
+    trace_id = data.get("trace_id") or data.get("traceId") or data.get("trace.id")
+    if not trace_id and isinstance(data.get("trace"), dict):
+        trace_id = data["trace"].get("id")
+    if not trace_id and isinstance(data.get("otelTraceID"), str):
+        trace_id = data["otelTraceID"]
+    if trace_id is not None:
+        trace_id = str(trace_id)
+
+    span_id = data.get("span_id") or data.get("spanId") or data.get("span.id")
+    if span_id is not None:
+        span_id = str(span_id)
+
+    return service, trace_id, span_id
+
+def parse_line(line: str) -> LogEntry:
+    """Parse a single line of log and extract severity level."""
+    line = line.strip()
+    
+    # 1. Check if JSON log object (common in docker/kubernetes/modern APIs)
+    if line.startswith('{') and line.endswith('}'):
+        try:
+            data = json.loads(line)
+            # Find level key
+            level = _normalize_level(data.get('level', data.get('severity', data.get('log.level', 'UNKNOWN'))))
+            # Find message key
+            message = str(data.get('message', data.get('msg', data.get('text', line))))
+            
+            # Find timestamp
+            timestamp_str = data.get('timestamp', data.get('time', data.get('@timestamp')))
+            timestamp = None
+            if timestamp_str:
+                try:
+                    # Basic ISO parsing
+                    timestamp = datetime.fromisoformat(str(timestamp_str).replace('Z', '+00:00'))
+                except ValueError:
+                    pass
+
+            svc, tid, sid = _extract_json_observability(data)
+            return LogEntry(
+                level=level,
+                message=message,
+                raw=line,
+                timestamp=timestamp,
+                service=svc,
+                trace_id=tid,
+                span_id=sid,
+            )
+        except json.JSONDecodeError:
+            pass
+
+    # 2. Try typical log formats like [INFO], (WARN), ERROR:
+    match = _BRACKET_LEVEL_PATTERN.search(line)
+    if not match:
+        # Try finding without brackets as a fallback, e.g. "INFO:" or "INFO - "
+        match = _BRACKETLESS_LEVEL_PATTERN.search(line)
+
+    if match:
+        level = _normalize_level(match.group(1))
+
+        # Remove the [LEVEL] part from the message for cleaner display
+        message = line.replace(match.group(0), '', 1).strip()
+        
+        # Clean up common separators left behind like ": " or "- "
+        if message.startswith(':') or message.startswith('-'):
+            message = message[1:].strip()
+            
+        return LogEntry(level=level, message=message, raw=line, timestamp=extract_timestamp(line))
+    
+    # fallback
+    return LogEntry(level="UNKNOWN", message=line, raw=line, timestamp=extract_timestamp(line))
+
+def extract_timestamp(text: str) -> Optional[datetime]:
+    """Extract a timestamp from a raw string using multiple format patterns."""
+    for pattern in _TIMESTAMP_PATTERNS:
+        match = pattern.search(text)
+        if match:
+            ts_str = match.group(1)
+            try:
+                # Try ISO format first (handles most cases)
+                if '-' in ts_str and ('T' in ts_str or ts_str[10:11] == ' '):
+                    # Handle ISO-like with space instead of T
+                    return datetime.fromisoformat(ts_str.replace('Z', '+00:00').replace(' ', 'T'))
+                # Handle Common Log Format: 21/Mar/2026:10:00:00 +0000
+                elif '/' in ts_str:
+                    parts = ts_str.split()
+                    main_part = parts[0]
+                    # Parse: DD/Mon/YYYY:HH:MM:SS
+                    match_parts = re.match(r'(\d{2})/([A-Za-z]{3})/(\d{4}):(\d{2}):(\d{2}):(\d{2})', main_part)
+                    if match_parts:
+                        day, month_str, year, hour, minute, second = match_parts.groups()
+                        month = _MONTH_MAP.get(month_str, 1)
+                        return datetime(int(year), month, int(day), int(hour), int(minute), int(second))
+                # Handle Syslog-style: Mar 21 10:00:00
+                elif ts_str[0].isalpha():
+                    match_parts = re.match(r'([A-Za-z]{3})\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})', ts_str)
+                    if match_parts:
+                        month_str, day, hour, minute, second = match_parts.groups()
+                        month = _MONTH_MAP.get(month_str, 1)
+                        year = datetime.now().year  # Assume current year
+                        return datetime(year, month, int(day), int(hour), int(minute), int(second))
+                # Handle Unix timestamp
+                elif ts_str.isdigit():
+                    return datetime.fromtimestamp(int(ts_str))
+            except (ValueError, OSError):
+                continue
+    return None

logscope/themes.py

@@ -0,0 +1,160 @@
+# Default themes and mappings for LogScope
+
+DEFAULT_THEMES = {
+    "default": {
+        "levels": {
+            "TRACE": ("🔍", "dim white"),
+            "DEBUG": ("🐛", "bold blue"),
+            "INFO": ("🔵", "bold green"),
+            "NOTICE": ("🔔", "bold cyan"),
+            "WARN": ("🟡", "bold yellow"),
+            "ERROR": ("🔴", "bold red"),
+            "CRITICAL": ("💥", "bold magenta"),
+            "ALERT": ("🚨", "bold color(208)"),
+            "FATAL": ("💀", "bold dark_red"),
+            "UNKNOWN": ("⚪", "dim white")
+        },
+        "highlights": {
+            "logscope.ip": "bold green",
+            "logscope.url": "underline blue",
+            "logscope.timestamp": "cyan",
+            "logscope.uuid": "bold magenta",
+            "logscope.email": "underline yellow",
+            "logscope.path": "dim blue",
+            "logscope.status_ok": "bold green",
+            "logscope.status_warn": "bold yellow",
+            "logscope.status_err": "bold red",
+            "logscope.method": "bold cyan"
+        }
+    },
+    "neon": {
+        "levels": {
+            "TRACE": ("·", "magenta"),
+            "DEBUG": ("⚡", "bold magenta"),
+            "INFO": ("✨", "bold pink1"),
+            "NOTICE": ("🌌", "bold purple"),
+            "WARN": ("🔥", "bold yellow1"),
+            "ERROR": ("🧨", "bold red1"),
+            "CRITICAL": ("⬢", "bold magenta"),
+            "ALERT": ("📣", "bold orange1"),
+            "FATAL": ("☣️", "bold dark_red"),
+            "UNKNOWN": ("?", "dim white")
+        },
+        "highlights": {
+            "logscope.ip": "bold pink1",
+            "logscope.url": "italic underline magenta",
+            "logscope.timestamp": "bold purple",
+            "logscope.uuid": "bold yellow",
+            "logscope.email": "bold pink1",
+            "logscope.path": "italic magenta",
+            "logscope.status_ok": "bold pink1",
+            "logscope.status_warn": "bold yellow",
+            "logscope.status_err": "bold red",
+            "logscope.method": "bold cyan"
+        }
+    },
+    "ocean": {
+        "levels": {
+             "TRACE": ("⚓", "dim cyan"),
+             "DEBUG": ("🌊", "blue"),
+             "INFO": ("💧", "bold blue"),
+             "NOTICE": ("🐳", "cyan"),
+             "WARN": ("🐚", "yellow"),
+             "ERROR": ("🌋", "red"),
+             "CRITICAL": ("⛈️ ", "bold blue"),
+             "ALERT": ("🚩", "bold orange1"),
+             "FATAL": ("🌪️ ", "bold red"),
+             "UNKNOWN": ("?", "dim cyan")
+        },
+        "highlights": {
+            "logscope.ip": "bold cyan",
+            "logscope.url": "underline deep_sky_blue1",
+            "logscope.timestamp": "blue",
+            "logscope.uuid": "bold deep_sky_blue3",
+            "logscope.email": "underline cyan",
+            "logscope.path": "dim cyan",
+            "logscope.status_ok": "bold green",
+            "logscope.status_warn": "bold yellow",
+            "logscope.status_err": "bold red",
+            "logscope.method": "bold cyan"
+        }
+    },
+    "forest": {
+        "levels": {
+            "TRACE": ("🍃", "dim green"),
+            "DEBUG": ("🌿", "green"),
+            "INFO": ("🌳", "bold green"),
+            "NOTICE": ("🍄", "magenta"),
+            "WARN": ("🍂", "yellow"),
+            "ERROR": ("🪵", "red"),
+            "CRITICAL": ("🌲", "bold white"),
+            "ALERT": ("🐺", "bold orange1"),
+            "FATAL": ("💀", "bold dark_red"),
+            "UNKNOWN": ("?", "dim green")
+        },
+        "highlights": {
+            "logscope.ip": "bold green3",
+            "logscope.url": "underline dark_green",
+            "logscope.timestamp": "yellow4",
+            "logscope.uuid": "bold orange4",
+            "logscope.email": "underline green",
+            "logscope.path": "dim green3",
+            "logscope.status_ok": "bold green",
+            "logscope.status_warn": "bold yellow",
+            "logscope.status_err": "bold red",
+            "logscope.method": "bold green1"
+        }
+    },
+    "minimal": {
+        "levels": {
+            "TRACE": (" ", "dim"),
+            "DEBUG": (" ", "dim"),
+            "INFO": (" ", "white"),
+            "NOTICE": ("!", "cyan"),
+            "WARN": ("?", "yellow"),
+            "ERROR": ("#", "red"),
+            "CRITICAL": ("*", "bold red"),
+            "ALERT": ("!", "bold yellow"),
+            "FATAL": ("X", "bold red"),
+            "UNKNOWN": ("?", "dim")
+        },
+        "highlights": {
+            "logscope.ip": "bold",
+            "logscope.url": "underline",
+            "logscope.timestamp": "dim",
+            "logscope.uuid": "dim",
+            "logscope.email": "underline",
+            "logscope.path": "italic",
+            "logscope.status_ok": "green",
+            "logscope.status_warn": "yellow",
+            "logscope.status_err": "red",
+            "logscope.method": "bold"
+        }
+    },
+    "spectra": {
+        "levels": {
+            "TRACE": ("◦", "dim cyan"),
+            "DEBUG": ("◇", "cyan"),
+            "INFO": ("◆", "bold bright_cyan"),
+            "NOTICE": ("▹", "bold turquoise2"),
+            "WARN": ("⚠", "bold bright_yellow"),
+            "ERROR": ("✖", "bold bright_red"),
+            "CRITICAL": ("⬢", "bold magenta"),
+            "ALERT": ("⚡", "bold color(214)"),
+            "FATAL": ("☠", "bold red3"),
+            "UNKNOWN": ("·", "dim white")
+        },
+        "highlights": {
+            "logscope.ip": "bold bright_cyan",
+            "logscope.url": "underline bright_magenta",
+            "logscope.timestamp": "bold cyan",
+            "logscope.uuid": "bold bright_white",
+            "logscope.email": "underline turquoise2",
+            "logscope.path": "italic cyan",
+            "logscope.status_ok": "bold spring_green1",
+            "logscope.status_warn": "bold gold1",
+            "logscope.status_err": "bold red1",
+            "logscope.method": "bold deep_sky_blue1"
+        }
+    },
+}

logscope/viewer.py

@@ -0,0 +1,401 @@
+import sys
+import time
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, List, TextIO, Set, Pattern
+
+from rich.console import Console, Group
+from rich.live import Live
+from rich.layout import Layout
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.highlighter import RegexHighlighter
+from rich.theme import Theme
+
+from .parser import parse_line, LogEntry, _normalize_level
+from .themes import DEFAULT_THEMES
+
+# Level severity order (lowest to highest)
+# Used for --min-level threshold filtering
+LEVEL_ORDER = {
+    "TRACE": 0,
+    "DEBUG": 1,
+    "INFO": 2,
+    "NOTICE": 3,
+    "WARN": 4,
+    "ERROR": 5,
+    "CRITICAL": 6,
+    "ALERT": 7,
+    "FATAL": 8,
+    "UNKNOWN": 0,  # Treat as lowest
+}
+
+if sys.platform == "win32" and hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(encoding="utf-8")
+
+class LogScopeHighlighter(RegexHighlighter):
+    """Apply style to anything that looks like an IP address, URL, or timestamp."""
+    base_style = "logscope."
+    highlights = [
+        r"(?P<ip>\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b)",
+        r"(?P<url>https?://[a-zA-Z0-9./?=#_%:-]+)",
+        r"(?P<timestamp>\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)",
+        r"(?P<uuid>\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b)",
+        r"(?P<email>\b[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+\b)",
+        r"(?P<path>(?:[a-zA-Z]:|\/)[a-zA-Z0-9._\-\/\\ ]+)",
+        r"(?P<status_ok>\b(200|201|204)\b)",
+        r"(?P<status_warn>\b(301|302|400|401|403|404)\b)",
+        r"(?P<status_err>\b(500|502|503|504)\b)",
+        r"(?P<method>\b(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)\b)",
+    ]
+
+
+class LogScopeManager:
+    """Manages the console state and current theme."""
+    def __init__(self, theme_name: str = "default"):
+        self._no_color = False
+        self.apply_theme(theme_name)
+
+    def apply_theme(self, theme_name_or_dict, no_color: bool = False, custom_themes: Optional[dict] = None):
+        self._no_color = no_color
+        themes = custom_themes if custom_themes is not None else DEFAULT_THEMES
+        if isinstance(theme_name_or_dict, str):
+            theme_config = themes.get(theme_name_or_dict, themes["default"])
+        else:
+            theme_config = theme_name_or_dict
+
+        self.level_mapping = theme_config["levels"]
+        self.rich_theme = Theme(theme_config["highlights"])
+        self.console = Console(
+            theme=self.rich_theme,
+            highlighter=LogScopeHighlighter(),
+            no_color=no_color,
+        )
+
+    def format_log(self, entry: LogEntry, line_number: Optional[int] = None, highlight: Optional[str] = None, highlight_color: str = "bold magenta", case_sensitive: bool = False) -> Text:
+        """Format a log entry with current theme's colors and emojis."""
+        icon, style = self.level_mapping.get(entry.level, self.level_mapping.get("UNKNOWN", ("⚪", "dim white")))
+
+        text = Text()
+        if line_number is not None:
+            text.append(f"{line_number:>4} │ ", style="dim")
+
+        text.append(f"{icon} {entry.level:<7} ", style=style)
+
+        # Apply custom highlight to message if keyword is specified
+        if highlight and highlight.strip():
+            message = entry.message
+            keyword = highlight.strip()
+            if self._no_color:
+                text.append(message)
+            elif case_sensitive:
+                # Case-sensitive: simple split
+                parts = message.split(keyword)
+                if len(parts) > 1:
+                    for i, part in enumerate(parts):
+                        text.append(part)
+                        if i < len(parts) - 1:
+                            text.append(keyword, style=highlight_color)
+                else:
+                    text.append(message)
+            else:
+                # Case-insensitive: use regex to find matches and preserve original case
+                import re
+                pattern = re.compile(re.escape(keyword), re.IGNORECASE)
+                last_end = 0
+                for match in pattern.finditer(message):
+                    text.append(message[last_end:match.start()])
+                    text.append(match.group(), style=highlight_color)
+                    last_end = match.end()
+                text.append(message[last_end:])
+        else:
+            text.append(entry.message)
+
+        return text
+
+# Global manager instance
+manager = LogScopeManager()
+
+
+def parse_level_filter(level: Optional[str]) -> Optional[Set[str]]:
+    if not level or not level.strip():
+        return None
+    parts = {_normalize_level(p.strip()) for p in level.split(",") if p.strip()}
+    return parts or None
+
+
+def line_passes_level(entry_level: str, allowed: Optional[Set[str]]) -> bool:
+    if not allowed:
+        return True
+    return entry_level in allowed
+
+
+def line_passes_min_level(entry_level: str, min_level: Optional[str]) -> bool:
+    """Check if entry level meets minimum severity threshold."""
+    if not min_level:
+        return True
+    entry_severity = LEVEL_ORDER.get(entry_level, 0)
+    min_severity = LEVEL_ORDER.get(_normalize_level(min_level), 0)
+    return entry_severity >= min_severity
+
+
+def line_passes_search(
+    line: str,
+    search: Optional[str],
+    *,
+    pattern: Optional[Pattern[str]],
+    use_regex: bool,
+    case_sensitive: bool,
+    invert_match: bool,
+) -> bool:
+    if not search:
+        return True
+    if use_regex and pattern is not None:
+        matched = pattern.search(line) is not None
+    elif case_sensitive:
+        matched = search in line
+    else:
+        matched = search.lower() in line.lower()
+    if invert_match:
+        return not matched
+    return matched
+
+
+def line_passes_filters(
+    entry: LogEntry,
+    level_set: Optional[Set[str]],
+    search: Optional[str],
+    since: Optional[datetime],
+    until: Optional[datetime],
+    *,
+    pattern: Optional[Pattern[str]],
+    use_regex: bool,
+    case_sensitive: bool,
+    invert_match: bool,
+    min_level: Optional[str] = None,
+) -> bool:
+    """Check if an entry passes all filters (level, min_level, search, timestamp)."""
+    if not line_passes_level(entry.level, level_set):
+        return False
+    if not line_passes_min_level(entry.level, min_level):
+        return False
+    if not line_passes_search(
+        entry.raw,
+        search,
+        pattern=pattern,
+        use_regex=use_regex,
+        case_sensitive=case_sensitive,
+        invert_match=invert_match,
+    ):
+        return False
+    if entry.timestamp:
+        if since and entry.timestamp.replace(tzinfo=None) < since.replace(tzinfo=None):
+            return False
+        if until and entry.timestamp.replace(tzinfo=None) > until.replace(tzinfo=None):
+            return False
+    return True
+
+
+def get_lines(file: TextIO, follow: bool):
+    """Generator that yields (line_number, line) tuples from a file, optionally tailing it."""
+    line_number = 0
+    # yield existing lines
+    for line in file:
+        line_number += 1
+        if line.strip():
+            yield line_number, line
+
+    if not follow:
+        return
+
+    # tailing
+    manager.console.print("[dim]-- 🔭 Tailing new logs... (Press Ctrl+C to exit) --[/dim]")
+    try:
+        while True:
+            line = file.readline()
+            if not line:
+                time.sleep(0.1)
+                continue
+            line_number += 1
+            if line.strip():
+                yield line_number, line
+    except KeyboardInterrupt:
+        return
+
+
+def stream_logs(
+    file: TextIO,
+    follow: bool,
+    level: Optional[str] = None,
+    search: Optional[str] = None,
+    export_html: Optional[Path] = None,
+    show_line_numbers: bool = False,
+    since: Optional[datetime] = None,
+    until: Optional[datetime] = None,
+    *,
+    use_regex: bool = False,
+    search_pattern: Optional[Pattern[str]] = None,
+    case_sensitive: bool = False,
+    invert_match: bool = False,
+    highlight: Optional[str] = None,
+    highlight_color: str = "bold magenta",
+    min_level: Optional[str] = None,
+):
+    """Basic console mode: prints directly to stdout, supporting tails."""
+    if export_html:
+        manager.console.record = True
+
+    level_set = parse_level_filter(level)
+
+    line_count = 0
+    try:
+        for line_number, line in get_lines(file, follow):
+            line_count = line_number
+            entry = parse_line(line)
+
+            if not line_passes_filters(
+                entry,
+                level_set,
+                search,
+                since,
+                until,
+                pattern=search_pattern,
+                use_regex=use_regex,
+                case_sensitive=case_sensitive,
+                invert_match=invert_match,
+                min_level=min_level,
+            ):
+                continue
+                
+            formatted = manager.format_log(
+                entry,
+                line_number=line_count if show_line_numbers else None,
+                highlight=highlight,
+                highlight_color=highlight_color,
+                case_sensitive=case_sensitive,
+            )
+            manager.console.print(formatted)
+    finally:
+        if export_html:
+            manager.console.save_html(str(export_html), clear=False)
+            manager.console.print(f"\n[bold green]✅ Logs exported successfully to {export_html}[/bold green]")
+
+
+def run_dashboard(
+    file: TextIO,
+    follow: bool,
+    level_filter: Optional[str] = None,
+    search_filter: Optional[str] = None,
+    show_line_numbers: bool = False,
+    since: Optional[datetime] = None,
+    until: Optional[datetime] = None,
+    *,
+    use_regex: bool = False,
+    search_pattern: Optional[Pattern[str]] = None,
+    case_sensitive: bool = False,
+    invert_match: bool = False,
+    highlight: Optional[str] = None,
+    highlight_color: str = "bold magenta",
+    min_level: Optional[str] = None,
+):
+    """Dashboard mode: Shows a summary stats panel and recent logs layout."""
+
+    level_set = parse_level_filter(level_filter)
+
+    stats = {
+        "FATAL": 0,
+        "ALERT": 0,
+        "CRITICAL": 0,
+        "ERROR": 0,
+        "WARN": 0,
+        "NOTICE": 0,
+        "INFO": 0,
+        "DEBUG": 0,
+        "TRACE": 0,
+        "UNKNOWN": 0
+    }
+    
+    total_processed = 0
+    recent_logs: List[Text] = []
+    MAX_LOGS = 25 # Number of lines to keep in the scrolling window
+
+    def generate_layout() -> Layout:
+        layout = Layout()
+        layout.split_column(
+            Layout(name="header", size=5),
+            Layout(name="body")
+        )
+        
+        # Stats table
+        table = Table(show_header=False, expand=True, border_style="dim", box=None)
+        table.add_column("C1", justify="center")
+        table.add_column("C2", justify="center")
+        table.add_column("C3", justify="center")
+        table.add_column("C4", justify="center")
+        
+        table.add_row(
+            f"[bold dark_red]💀 Fatal: {stats.get('FATAL', 0)}[/bold dark_red]",
+            f"[bold magenta]💥 Critical: {stats.get('CRITICAL', 0)}[/bold magenta]",
+            f"[bold red]🔴 Errors: {stats.get('ERROR', 0)}[/bold red]",
+            f"[bold yellow]🟡 Warns: {stats.get('WARN', 0)}[/bold yellow]"
+        )
+        table.add_row(
+            f"[bold green]🔵 Info: {stats.get('INFO', 0)}[/bold green]",
+            f"[bold blue]🐛 Debug: {stats.get('DEBUG', 0)}[/bold blue]",
+            f"[dim white]🔍 Trace: {stats.get('TRACE', 0)}[/dim white]",
+            f"[dim white]⚪ Unknown: {stats.get('UNKNOWN', 0)}[/dim white]"
+        )
+        
+        layout["header"].update(Panel(table, title=f"[bold]✨ LogScope Live Dashboard — Total: {total_processed}[/bold]", border_style="cyan"))
+        
+        # Logs
+        log_group = Group(*recent_logs)
+        title = "Recent Logs (Auto-highlight enabled)"
+        if follow:
+            title += " - [blink green]● LIVE[/blink green]"
+            
+        layout["body"].update(Panel(log_group, title=title))
+        
+        return layout
+
+    manager.console.clear()
+    
+    try:
+        with Live(generate_layout(), console=manager.console, refresh_per_second=10) as live:
+            for line_number, line in get_lines(file, follow):
+                total_processed = line_number
+                entry = parse_line(line)
+
+                if not line_passes_filters(
+                    entry,
+                    level_set,
+                    search_filter,
+                    since,
+                    until,
+                    pattern=search_pattern,
+                    use_regex=use_regex,
+                    case_sensitive=case_sensitive,
+                    invert_match=invert_match,
+                    min_level=min_level,
+                ):
+                    continue
+
+                # Update stats tally
+                entry_level = entry.level if entry.level in stats else "UNKNOWN"
+                stats[entry_level] += 1
+
+                formatted = manager.format_log(
+                    entry,
+                    line_number=total_processed if show_line_numbers else None,
+                    highlight=highlight,
+                    highlight_color=highlight_color,
+                    case_sensitive=case_sensitive,
+                )
+                recent_logs.append(formatted)
+                if len(recent_logs) > MAX_LOGS:
+                    recent_logs.pop(0)
+                    
+                live.update(generate_layout())
+    except KeyboardInterrupt:
+        pass

logscope_cli-0.4.1.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: logscope-cli
+Version: 0.4.1
+Summary: LogScope — Beautiful log viewer for the terminal
+License-File: LICENSE
+Author: vinnytherobot
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: rich (>=13.0.0,<14.0.0)
+Requires-Dist: typer (>=0.15.1,<0.16.0)
+Requires-Dist: typing-extensions (>=4.0.0,<5.0.0)
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <img src="./assets/logscope-logo.png" alt="LogScope Logo" width="500" height="500">
+  
+  # LogScope
+  
+  **Beautiful, simple, and powerful log viewer for the terminal.**
+  
+  [![Python](https://img.shields.io/badge/Python-3.9%2B-blue)](https://python.org)
+  [![Typer](https://img.shields.io/badge/CLI-Typer-green)](https://typer.tiangolo.com/)
+  [![Rich](https://img.shields.io/badge/UI-Rich-magenta)](https://rich.readthedocs.io/)
+  [![License](https://img.shields.io/badge/License-MIT-gray.svg)](#)
+</div>
+
+<p align="center">
+  A modern CLI tool that turns boring text logs or messy JSON lines into stunning, structured, and colorful terminal outputs—complete with a live dashboard, smart highlighting, and HTML exporting.
+</p>
+
+---
+
+## Features that shine
+
+*   **Fast & Lightweight**: Tail files natively or stream huge data directly via pipes (`cat server.log | logscope`).
+*   **Colored & Structured Logs**: Automatically identifies `INFO`, `WARNING`, `ERROR`, `CRITICAL`, and `DEBUG`, applying beautiful typography.
+*   **Universal Parser**: Reads typical bracket logs (`[INFO]`) **and** parses modern NDJSON / JSON logs out of the box (e.g., Kubernetes, Docker).
+*   **Auto-Highlighting**: Magically highlights `IPs`, `URLs`, `Dates/Timestamps`, `UUIDs`, and `E-Mails` with dynamic colors.
+*   **Custom Keyword Highlighting**: Highlight specific keywords in log messages with `--highlight` and customize colors with `--highlight-color`.
+*   **Live Dashboard**: Watch logs stream in real-time alongside a live statistics panel keeping track of Error vs Info counts (`--dashboard`).
+*   **HTML Export**: Loved your console output so much you want to share it? Export the beautiful log structure directly to an HTML file to share with your team! (`--export-html results.html`)
+*   **Filtering**: Filter by one or more levels (`--level ERROR` or `--level ERROR,WARN,INFO`). Search by substring (`--search`) or regular expression (`--regex` / `-e`), with optional **case-sensitive** matching and **invert match** (`--invert-match` / `-v`, grep-style) to hide matching lines.
+*   **Themes**: Choose from 6 beautiful themes (`default`, `neon`, `ocean`, `forest`, `minimal`, `spectra`) or create custom themes via config file.
+*   **Plain output**: Use `--no-color` when you need unstyled text (e.g. piping to other tools or logs without ANSI codes).
+*   **Gzip logs**: Read `.gz` files directly—LogScope opens them as text without a manual `zcat` pipe.
+
+---
+
+## Installation
+
+Ensure you have Python 3.9+ and pip installed.
+
+```bash
+# Clone the repository
+git clone https://github.com/vinnytherobot/logscope.git
+cd logscope
+
+# Install via Poetry
+poetry install
+poetry run logscope --help
+
+# Or install globally via pip
+pip install -e .
+```
+
+---
+
+## Usage & Examples
+
+### Using a File
+```bash
+# Basic colorized look
+logscope /var/log/syslog
+
+# Tailing a log in real-time (like tail -f)
+logscope backend.log --follow
+
+# Filter only errors
+logscope production.log --level ERROR
+
+# Multiple levels (comma-separated)
+logscope production.log --level ERROR,WARN,INFO
+
+# Search text dynamically
+logscope server.log --search "Connection Timeout"
+
+# Regex search (requires --search)
+logscope server.log --search "timeout|refused|ECONNRESET" --regex
+
+# Hide lines that match a pattern
+logscope noisy.log --search "healthcheck" --invert-match
+
+# Case-sensitive search
+logscope app.log --search "UserID" --case-sensitive
+
+# Highlight specific keywords
+logscope server.log --highlight "timeout" --highlight-color "bold red"
+
+# No colors (plain terminal output)
+logscope app.log --no-color
+
+# Compressed log file
+logscope archive/app.log.gz
+```
+
+### Piping from other commands (Stdin support)
+LogScope acts as a brilliant text reformatter for other tools!
+
+```bash
+kubectl logs my-pod -f | logscope
+docker logs api-gateway | logscope --level CRITICAL
+cat nginx.log | grep -v GET | logscope --dashboard
+```
+
+### The Live Dashboard Mode
+Monitor your logs like a pro with a live dashboard tracking error occurrences.
+
+```bash
+logscope app.log --dashboard --follow
+```
+
+### Exporting to HTML
+Need to attach the logs to a Jira ticket or Slack message but want to keep the formatting?
+
+```bash
+logscope failed_job.log --export-html bug_report.html
+```
+
+### Themes
+Choose from 6 beautiful themes: `default`, `neon`, `ocean`, `forest`, `minimal`, `spectra`.
+
+```bash
+logscope app.log --theme neon
+```
+
+Create a `.logscoperc` file to set your preferred theme:
+
+```json
+{
+  "theme": "neon",
+  "custom_themes": {
+    "my-theme": {
+      "levels": {
+        "ERROR": ("✖", "bold red")
+      }
+    }
+  }
+}
+```
+
+---
+
+## Stack
+
+*   [**Rich**](https://github.com/Textualize/rich) -> UI Layouts, Colors, Highlighters, HTML Export.
+*   [**Typer**](https://github.com/tiangolo/typer) -> Modern, fast, and robust CLI creation.
+*   [**typing-extensions**](https://github.com/python/typing_extensions) -> Typed CLI annotations on Python 3.9.
+*   **Pathlib / Sys / gzip** -> File and standard input streaming; gzip text logs.
+
+## Contributing
+Open an issue or submit a pull request! Tests are written using `pytest`.
+
+```bash
+# Running tests
+pytest tests/
+```
+
+## License
+MIT License.
+
+Made by [vinnytherobot](https://github.com/vinnytherobot)

logscope_cli-0.4.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+logscope/__init__.py,sha256=UAliSoi17ev1nmQ7_30bjTgOlJ-VfaD3gmbwdnh4rno,85
+logscope/cli.py,sha256=05Jfz1SG3vBEmQUwApkMTQ7O_iUXoVT9T6yDcApkDlQ,8498
+logscope/parser.py,sha256=qW0keilWPZ6q423PL4PFSiZz988tRxS1Yqf0QQatqzo,7723
+logscope/themes.py,sha256=zmdC9eDgIBubP7AZ-biWiwvQgqQN91QwClYvOoZ2Oss,6143
+logscope/viewer.py,sha256=VEv-rZdXAIVERIFEPyRDjSIT2cbAz28ghWrAG4RGFsA,13505
+logscope_cli-0.4.1.dist-info/entry_points.txt,sha256=TQg5CmFjOVS8K7py8doZkzqQ98z0oWewlXx3OTFef8Q,45
+logscope_cli-0.4.1.dist-info/licenses/LICENSE,sha256=E9YjzvjsSNiaRgFq6KALrt5XfA9z0qzO2ZO8o1dl3-4,1089
+logscope_cli-0.4.1.dist-info/METADATA,sha256=3lqXu7SyGn_U53nH7k0uMBbrptf_OiNGIkck-RptLSU,5945
+logscope_cli-0.4.1.dist-info/WHEEL,sha256=Vz2fHgx6HFtSwhs8KvkHLqH5Ea4w1_rner5uNVGCeIE,88
+logscope_cli-0.4.1.dist-info/RECORD,,

logscope_cli-0.4.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.3.2
+Root-Is-Purelib: true
+Tag: py3-none-any

logscope_cli-0.4.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+logscope=logscope.cli:app
+

logscope_cli-0.4.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 João Vinny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.