tracetui 2.0.0__py3-none-any.whl

tracetui/__init__.py

@@ -0,0 +1,3 @@
+"""TraceTUI — Interactive TUI debugger for logs."""
+
+__version__ = "0.2.0"

tracetui/__main__.py

@@ -0,0 +1,6 @@
+"""Точка входа в приложение."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

tracetui/app.py

@@ -0,0 +1,403 @@
+"""Основной TUI экран TraceTUI."""
+
+import asyncio
+from pathlib import Path
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.widgets import Header, Footer
+from textual.css.query import NoMatches
+from textual.theme import Theme
+
+from .widgets.log_list import LogList
+from .widgets.source_panel import SourcePanel
+from .widgets.detail_panel import DetailPanel
+from .widgets.live_monitor import LiveMonitor
+from .models import LogSource
+from .parsers.log_parser import load_log_source
+
+
+class TraceTUIApp(App):
+    """Главное приложение TraceTUI."""
+
+    CSS = """
+    Screen {
+        layout: grid;
+        grid-size: 3;
+        grid-columns: 3fr 6fr 3fr;
+        grid-gutter: 1 2;
+    }
+
+    #source-panel {
+        width: 100%;
+        height: 95%;
+        background: $surface;
+        border: solid $accent;
+        padding: 1;
+        overflow: auto;
+    }
+
+    #log-list {
+        width: 100%;
+        height: 95%;
+        background: $boost;
+        border: solid $primary;
+        padding: 1;
+        overflow: auto;
+    }
+
+    /* Стили DataTable — виртуализированный рендеринг логов */
+    LogList {
+        background: $boost;
+    }
+
+    LogList .row-selected {
+        background: $primary;
+        color: white;
+        text-style: bold;
+    }
+
+    #detail-panel {
+        width: 100%;
+        height: 95%;
+        background: $surface;
+        border: solid $accent;
+        padding: 1;
+        overflow: auto;
+    }
+
+    /* Стили для чекбоксов источников в merge mode */
+    SourcePanel.merge-mode {
+        background: $surface;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("f", "toggle_filter_mode", "Filter"),
+        Binding("e", "next_error", "Next error"),
+        Binding("t", "toggle_theme", "Theme"),
+        Binding("m", "toggle_merge_mode", "Timeline"),
+        Binding("left", "switch_source_left", "Prev source"),
+        Binding("right", "switch_source_right", "Next source"),
+    ]
+
+    def __init__(self, file_paths: list[Path] | None = None, format_type: str = "auto", log_level: str | None = None, **kwargs):
+        super().__init__(**kwargs)
+        self._is_dark = True
+        self._pending_sources: list[LogSource] = []
+        # Пути к файлам для асинхронной загрузки
+        self._file_paths: list[Path] = file_paths or []
+        self._format_type: str = format_type
+        # Минимальный уровень логирования для фильтрации
+        self._log_level: str | None = log_level
+        # Live-мониторинг
+        self._live_monitor: LiveMonitor | None = None
+        # Timeline merge mode
+        self.merge_mode: bool = False
+        # Индекс выбранного чекбокса в merge mode
+        self._selected_source_index: int = 0
+
+    def on_mount(self) -> None:
+        """Инициализация приложения."""
+        self._sources: list[LogSource] = []
+        self.title = "TraceTUI — Log Debugger"
+        self.sub_title = "↑↓ Navigate | ←→ Sources | F Filter | d Tag | E Next Error | T Theme | m Timeline | q Quit"
+
+        # Регистрируем светлую тему
+        self.register_theme(
+            Theme(
+                name="trace-light",
+                primary="#1976d2",
+                warning="#f57f17",
+                error="#c62828",
+                success="#2e7d32",
+                accent="#7b1fa2",
+                foreground="#1a1a1a",
+                background="#f0f0f0",
+                surface="#e0e0e0",
+                panel="#eeeeee",
+                boost="#ffffff",
+                dark=False,
+            )
+        )
+        # Принудительно регистрируем тему "textual" из built-in
+        self.register_theme(
+            Theme(
+                name="textual",
+                primary="#0072ff",
+                warning="#ffaf00",
+                error="#e6193C",
+                success="#13a10e",
+                accent="#8888fc",
+                foreground="#f8f8f2",
+                background="#272822",
+                surface="#1f2229",
+                panel="#272822",
+                boost="#353b45",
+                dark=True,
+            )
+        )
+
+        # Откладываем загрузку до полной инициализации экрана
+        self.call_later(self._load_pending_sources)
+        # Запускаем асинхронную загрузку файлов
+        self.call_later(self._load_sources_from_paths)
+
+    def on_stop(self) -> None:
+        """Остановка при закрытии приложения."""
+        if self._live_monitor:
+            self._live_monitor.stop()
+
+    def compose(self):
+        """Создание интерфейса с тремя панелями."""
+        yield Header()
+        yield SourcePanel(id="source-panel")
+        yield LogList(id="log-list")
+        yield DetailPanel(id="detail-panel")
+        yield Footer()
+
+    def add_log_source(self, source: LogSource) -> None:
+        """Добавляет источник логов (откладывается до монтирования)."""
+        self._sources.append(source)
+        self._pending_sources.append(source)
+
+    async def _load_sources_from_paths(self) -> None:
+        """Асинхронная загрузка файлов в фоне."""
+        if not self._file_paths:
+            return
+
+        async def _parse_and_register(path: Path) -> None:
+            """Парсит файл в фоне и регистрирует результат."""
+            # to_thread запускает синхронную функцию в пуле потоков
+            source = await asyncio.to_thread(load_log_source, path, self._format_type)
+            self.call_after_refresh(self._register_source, source)
+
+        tasks = []
+        for path in self._file_paths:
+            if path.exists():
+                tasks.append(_parse_and_register(path))
+            else:
+                self.call_after_refresh(lambda p=path: self.notify(f"Файл не найден: {p}", severity="error"))
+
+        await asyncio.gather(*tasks)
+
+    def _load_pending_sources(self) -> None:
+        """Загружаем все отложенные источники после полной инициализации."""
+        for source in self._pending_sources:
+            self._register_source(source)
+        self._pending_sources.clear()
+
+    def _register_source(self, source: LogSource) -> None:
+        """Регистрирует источник в панелях."""
+        # Добавляем в список, если ещё нет
+        if source not in self._sources:
+            self._sources.append(source)
+
+        # Фильтруем записи по минимальному уровню логирования
+        source.entries = self._filter_entries_by_level(source.entries)
+
+        source_panel = self.query_one("#source-panel", SourcePanel)
+        source_panel.add_source(source)
+
+        log_list = self.query_one("#log-list", LogList)
+        log_list.add_entries(source.entries)
+        log_list.set_sources(self._sources)
+
+        # Активируем первый источник
+        if self._sources.index(source) == 0:
+            source.is_active = True
+            source_panel.refresh()
+
+        # Запускаем мониторинг, если это первый файл
+        if len(self._sources) == 1 and self._file_paths and not self._live_monitor:
+            self._start_live_monitor()
+
+    def action_toggle_filter_mode(self) -> None:
+        """Передать действие фильтрации в LogList."""
+        log_list = self.query_one("#log-list", LogList)
+        log_list.action_toggle_filter_mode()
+
+    def _filter_entries_by_level(self, entries: list) -> list:
+        """Фильтрует записи по минимальному уровню логирования.
+
+        Args:
+            entries: Список LogEntry для фильтрации
+
+        Returns:
+            Отфильтрованный список записей
+        """
+        if not self._log_level:
+            return entries
+
+        # Определяем порядковый номер минимального уровня
+        level_order = {
+            "DEBUG": 0,
+            "INFO": 1,
+            "WARNING": 2,
+            "ERROR": 3,
+            "CRITICAL": 4,
+        }
+        min_order = level_order.get(self._log_level.upper(), 0)
+
+        return [
+            entry for entry in entries
+            if level_order.get(entry.level.value, 0) >= min_order
+        ]
+
+    def _start_live_monitor(self) -> None:
+        """Запускает фоновый мониторинг файлов."""
+        if not self._file_paths:
+            return
+
+        self._live_monitor = LiveMonitor(
+            file_paths=self._file_paths,
+            format_type=self._format_type,
+            on_new_entries=self._handle_new_entries,
+            poll_interval=1.0,
+        )
+        self._live_monitor.start()
+        self.notify("Live-мониторинг запущен", severity="information")
+
+    def _handle_new_entries(self, entries: list, file_path: Path) -> None:
+        """Обработчик новых записей из файлов.
+
+        Вызывается из фонового воркера для обновления UI.
+
+        Args:
+            entries: Список новых LogEntry
+            file_path: Путь к файлу, в котором появились записи
+        """
+        self.call_after_refresh(self._process_new_entries, entries, file_path)
+
+    def _process_new_entries(self, entries: list, file_path: Path) -> None:
+        """Добавляет новые записи в UI.
+
+        Args:
+            entries: Список новых LogEntry
+            file_path: Путь к файлу
+        """
+        if not entries:
+            return
+
+        # Фильтруем по минимальному уровню логирования
+        entries = self._filter_entries_by_level(entries)
+        if not entries:
+            return
+
+        # Находим источник по пути
+        source = None
+        for s in self._sources:
+            if s.path == file_path:
+                source = s
+                break
+
+        if not source:
+            return
+
+        # Добавляем новые записи с ограничением по памяти
+        source.add_entries(entries)
+        source.has_new = True
+
+        # Обновляем LogList
+        log_list = self.query_one("#log-list", LogList)
+        log_list.add_entries(entries)
+
+        # Обновляем счётчик в SourcePanel
+        source_panel = self.query_one("#source-panel", SourcePanel)
+        source_panel._refresh_sources()
+
+        # Показываем уведомление
+        self.notify(f"+{len(entries)} новых записей из {source.name}")
+
+    def action_next_error(self) -> None:
+        """Переход к следующей ошибке."""
+        log_list = self.query_one("#log-list", LogList)
+        log_list.action_next_error()
+
+    def action_toggle_merge_mode(self) -> None:
+        """Переключает режим таймлайна (merge mode)."""
+        self.merge_mode = not self.merge_mode
+        log_list = self.query_one("#log-list", LogList)
+
+        if self.merge_mode:
+            # Снимаем active flag у всех источников
+            for source in self._sources:
+                source.is_active = False
+                source.is_included = True  # Все включены по умолчанию
+            self._selected_source_index = 0
+            self.sub_title = "↑↓ Navigate | Space Toggle Source | ←→ Select | F Filter | E Next Error | T Theme | m Timeline | q Quit"
+            self.notify("Timeline mode ON — merge all sources")
+            # Синхронизируем merge mode с LogList
+            log_list.set_merge_mode(True)
+            # Перезапускаем таймлайн асинхронно
+            self.call_later(self._refresh_timeline_async)
+        else:
+            # Восстанавливаем активный источник — первый источник
+            if self._sources:
+                self._sources[0].is_active = True
+            self.sub_title = "↑↓ Navigate | ←→ Sources | F Filter | d Tag | E Next Error | T Theme | m Timeline | q Quit"
+            self.notify("Timeline mode OFF — single source view")
+            # Синхронизируем merge mode с LogList
+            log_list.set_merge_mode(False)
+
+    async def _refresh_timeline_async(self) -> None:
+        """Асинхронный запуск таймлайн-мержа в фоновом потоке."""
+        if not self.merge_mode:
+            return
+
+        entries = await asyncio.to_thread(self._build_timeline_sync)
+        self.call_after_refresh(self._apply_timeline_entries, entries)
+
+    def _build_timeline_sync(self) -> list:
+        """Синхронная функция для запуска в asyncio.to_thread.
+
+        Возвращает отфильтрованный список LogEntry из всех включённых источников.
+        """
+        from .parsers.log_parser import timeline_merge
+
+        # Собираем пути только включённых источников
+        included_sources = [s for s in self._sources if s.is_included]
+        if not included_sources:
+            return []
+
+        all_paths = [source.path for source in included_sources]
+
+        entries = []
+        for entry, path in timeline_merge(all_paths):
+            # Подменяем file_path на имя файла для маркировки
+            entry.file_path = path.name
+            entries.append(entry)
+
+        # Фильтруем по уровню
+        entries = self._filter_entries_by_level(entries)
+        return entries
+
+    def _clear_timeline(self) -> None:
+        """Очищает LogList в merge mode."""
+        log_list = self.query_one("#log-list", LogList)
+        log_list._entries = []
+        log_list._selectedIndex = -1
+        log_list._update_display()
+
+    def _apply_timeline_entries(self, entries: list) -> None:
+        """Применяет объединённые записи в LogList."""
+        log_list = self.query_one("#log-list", LogList)
+        log_list._entries = entries
+        log_list._selectedIndex = -1
+        log_list._update_display()
+
+    def action_toggle_theme(self) -> None:
+        """Переключает тему (светлая/тёмная)."""
+        self._is_dark = not self._is_dark
+        self.theme = "trace-light" if not self._is_dark else "textual"
+        self.notify("Theme: Dark" if self._is_dark else "Theme: Light")
+
+    def action_switch_source_left(self) -> None:
+        """Переключить на предыдущий источник."""
+        log_list = self.query_one("#log-list", LogList)
+        log_list.switch_source(-1)
+
+    def action_switch_source_right(self) -> None:
+        """Переключить на следующий источник."""
+        log_list = self.query_one("#log-list", LogList)
+        log_list.switch_source(1)

tracetui/cli.py

@@ -0,0 +1,56 @@
+"""Клиентский интерфейс для запуска TraceTUI."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .app import TraceTUIApp
+
+
+def main():
+    """Точка входа из CLI."""
+    parser = argparse.ArgumentParser(
+        description="TraceTUI — Interactive TUI debugger for logs"
+    )
+    parser.add_argument(
+        "files",
+        nargs="*",
+        type=Path,
+        help="Log files to open",
+    )
+    parser.add_argument(
+        "-f",
+        "--format",
+        choices=["auto", "loguru", "logging", "simple"],
+        default="auto",
+        help="Log format (default: auto-detect)",
+    )
+    parser.add_argument(
+        "-l",
+        "--log-level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
+        default=None,
+        help="Filter by minimum log level",
+    )
+
+    args = parser.parse_args()
+
+    # Фильтруем несуществующие файлы
+    valid_paths = []
+    for file_path in args.files:
+        if file_path.exists():
+            valid_paths.append(file_path)
+        else:
+            print(f"File not found: {file_path}", file=sys.stderr)
+
+    app = TraceTUIApp(
+        file_paths=valid_paths if valid_paths else None,
+        format_type=args.format,
+        log_level=args.log_level,
+    )
+
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

tracetui/models.py

@@ -0,0 +1,103 @@
+"""Модели данных для логов."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+
+
+class LogLevel(Enum):
+    """Уровни логирования."""
+
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+    @property
+    def color(self) -> str:
+        """Возвращает цвет для уровня лога."""
+        return {
+            self.DEBUG: "grey50",
+            self.INFO: "white",
+            self.WARNING: "orange1",
+            self.ERROR: "red1",
+            self.CRITICAL: "bright_red",
+        }[self]
+
+    @property
+    def icon(self) -> str:
+        """Возвращает иконку для уровня лога."""
+        return {
+            self.DEBUG: "⚬",
+            self.INFO: "ℹ",
+            self.WARNING: "⚠",
+            self.ERROR: "✕",
+            self.CRITICAL: "✕",
+        }[self]
+
+
+@dataclass
+class LogEntry:
+    """Одна запись лога."""
+
+    level: LogLevel
+    message: str
+    timestamp: str = ""
+    logger_name: str = ""
+    file_path: str = ""
+    line_number: int = 0
+    traceback: str = ""
+    tags: list[str] = field(default_factory=list)
+    selected: bool = False
+    timestamp_dt: "datetime | None" = None
+
+    @property
+    def formatted_line(self) -> str:
+        """Форматированная строка для отображения."""
+        parts = []
+        if self.timestamp:
+            parts.append(self.timestamp)
+        if self.logger_name:
+            parts.append(f"[{self.logger_name}]")
+        parts.append(f"{self.level.value}:")
+        parts.append(self.message)
+        return " ".join(parts)
+
+
+# Максимальное количество записей в одном источнике (для предотвращения утечки памяти)
+MAX_ENTRIES = 10_000
+
+
+@dataclass
+class LogSource:
+    """Источник логов (файл или поток)."""
+
+    name: str
+    path: Path
+    format_type: str = "auto"  # auto, loguru, logging, custom
+    entries: list[LogEntry] = field(default_factory=list)
+    is_active: bool = False
+    has_new: bool = False
+    is_included: bool = True  # Флаг для merge mode — включён ли в таймлайн
+
+    @property
+    def entry_count(self) -> int:
+        return len(self.entries)
+
+    def add_entries(self, entries: list[LogEntry]) -> None:
+        """Добавляет новые записи с ограничением по максимальному количеству.
+
+        При превышении MAX_ENTRIES удаляет старые элементы с начала списка,
+        чтобы предотвратить утечку памяти.
+
+        Args:
+            entries: Список новых LogEntry для добавления
+        """
+        self.entries.extend(entries)
+        # Если превышен лимит — обрезаем с начала
+        if len(self.entries) > MAX_ENTRIES:
+            excess = len(self.entries) - MAX_ENTRIES
+            self.entries = self.entries[excess:]

tracetui/parsers/__init__.py

@@ -0,0 +1 @@
+"""Пакет парсеров логов."""