vpterm-vp 1.0.0__tar.gz

vpterm_vp-1.0.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: vpterm-vp
+Version: 1.0.0
+Summary: Terminal rendering: colors, panels, tables, progress bars.
+Author: F000NK, Voluntas Progressus
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.14

vpterm_vp-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=69.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vpterm-vp"
+version = "1.0.0"
+authors = [
+    { name = "F000NK" },
+    { name = "Voluntas Progressus" },
+]
+description = "Terminal rendering: colors, panels, tables, progress bars."
+license = "MIT"
+requires-python = ">=3.14"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: OS Independent",
+]
+dependencies = []
+
+[tool.setuptools.packages.find]
+include = ["vpterm*"]
+
+[tool.setuptools.package-data]
+vpterm = ["py.typed"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py314"

vpterm_vp-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vpterm_vp-1.0.0/vpterm/__init__.py

@@ -0,0 +1,14 @@
+"""VP Terminal — rich console output library.
+
+Provides colors, styled text, panels, key-value formatting,
+progress bars, and tables for terminal applications.
+"""
+
+from vpterm.style import Style, style, strip_ansi
+from vpterm.panel import Panel
+from vpterm.table import Table
+from vpterm.kv import KeyValue, kv_line
+from vpterm.progress import ProgressBar
+from vpterm.terminal import Terminal, get_terminal
+
+__version__ = "1.0.0"

vpterm_vp-1.0.0/vpterm/kv.py

@@ -0,0 +1,51 @@
+"""Key-value line formatting for structured log output."""
+
+from __future__ import annotations
+
+from vpterm.style import Style
+
+
+class KeyValue:
+    """Builder for key=value formatted lines.
+
+    Usage:
+        line = KeyValue()
+        line.add("epoch", "1/10")
+        line.add("loss", 3.1415, precision=4)
+        print(line.render())
+    """
+
+    def __init__(self, separator: str = "  ") -> None:
+        self.parts: list[str] = []
+        self.separator = separator
+
+    def add(self, key: str, value: str | int | float, precision: int = 4) -> KeyValue:
+        """Add a key=value pair."""
+        if isinstance(value, float):
+            formatted = f"{value:.{precision}f}"
+        else:
+            formatted = str(value)
+        self.parts.append(
+            f"{Style.metric_name(key)}{Style.dim('=')}{Style.metric_value(formatted)}"
+        )
+        return self
+
+    def add_raw(self, text: str) -> KeyValue:
+        """Add pre-formatted text."""
+        self.parts.append(text)
+        return self
+
+    def render(self) -> str:
+        """Render all pairs as a single line."""
+        return self.separator.join(self.parts)
+
+    def __str__(self) -> str:
+        return self.render()
+
+
+def kv_line(**kwargs: str | int | float) -> str:
+    """Quick helper to render key=value pairs from keyword arguments."""
+    builder = KeyValue()
+    for key, value in kwargs.items():
+        builder.add(key, value)
+    return builder.render()

vpterm_vp-1.0.0/vpterm/panel.py

@@ -0,0 +1,83 @@
+"""Panel rendering — bordered boxes for grouped content."""
+
+from __future__ import annotations
+
+from vpterm.style import Style, visible_length
+
+BOX_TOP_LEFT = "╭"
+BOX_TOP_RIGHT = "╮"
+BOX_BOTTOM_LEFT = "╰"
+BOX_BOTTOM_RIGHT = "╯"
+BOX_HORIZONTAL = "─"
+BOX_VERTICAL = "│"
+
+
+class Panel:
+    """Bordered panel for grouping related output.
+
+    Usage:
+        panel = Panel(title="Training")
+        panel.add_line("epoch 1/10  batch 50/3139")
+        panel.add_line("loss=3.14  lr=0.001")
+        print(panel.render())
+    """
+
+    def __init__(self, title: str = "", width: int = 0, min_width: int = 60) -> None:
+        self.title = title
+        self.requested_width = width
+        self.min_width = min_width
+        self.lines: list[str] = []
+
+    def add_line(self, text: str) -> Panel:
+        """Add a content line to the panel."""
+        self.lines.append(text)
+        return self
+
+    def add_blank(self) -> Panel:
+        """Add an empty line."""
+        self.lines.append("")
+        return self
+
+    def add_section(self, title: str) -> Panel:
+        """Add a section header inside the panel."""
+        self.lines.append(Style.bold(Style.cyan(title)))
+        return self
+
+    def add_kv(self, key: str, value: str, key_width: int = 14) -> Panel:
+        """Add an indented key-value pair."""
+        padded = key.ljust(key_width)
+        self.lines.append(f"  {Style.label(padded)} {value}")
+        return self
+
+    def _compute_width(self) -> int:
+        if self.requested_width > 0:
+            return self.requested_width
+        max_content = max((visible_length(line) for line in self.lines), default=0)
+        title_len = len(self.title) + 4 if self.title else 0
+        return max(self.min_width, max_content + 4, title_len)
+
+    def render(self) -> str:
+        """Render the panel as a multi-line string."""
+        width = self._compute_width()
+        inner_width = width - 2
+        output_lines: list[str] = []
+
+        if self.title:
+            title_display = f" {self.title} "
+            bar_len = max(0, inner_width - len(title_display))
+            top = f"{BOX_TOP_LEFT}{BOX_HORIZONTAL}{title_display}{BOX_HORIZONTAL * bar_len}{BOX_TOP_RIGHT}"
+        else:
+            top = f"{BOX_TOP_LEFT}{BOX_HORIZONTAL * inner_width}{BOX_TOP_RIGHT}"
+        output_lines.append(Style.dim(top))
+
+        for line in self.lines:
+            padding = max(0, inner_width - visible_length(line) - 1)
+            output_lines.append(f"{Style.dim(BOX_VERTICAL)} {line}{' ' * padding}{Style.dim(BOX_VERTICAL)}")
+
+        bottom = f"{BOX_BOTTOM_LEFT}{BOX_HORIZONTAL * inner_width}{BOX_BOTTOM_RIGHT}"
+        output_lines.append(Style.dim(bottom))
+
+        return "\n".join(output_lines)
+
+    def __str__(self) -> str:
+        return self.render()

vpterm_vp-1.0.0/vpterm/progress.py

@@ -0,0 +1,60 @@
+"""Progress bar and time formatting for training loops."""
+
+from __future__ import annotations
+
+from vpterm.style import Style
+
+
+def format_duration(total_seconds: float) -> str:
+    """Format seconds into human-readable HH:MM:SS."""
+    rounded = max(0, int(total_seconds))
+    hours, remainder = divmod(rounded, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+
+def format_number(value: int) -> str:
+    """Format integer with thousands separator."""
+    return f"{value:,}"
+
+
+class ProgressBar:
+    """Text-based progress bar.
+
+    Usage:
+        bar = ProgressBar(total=100, width=30)
+        print(bar.render(current=42))
+        # ████████████░░░░░░░░░░░░░░░░░░  42%
+    """
+
+    FILL = "█"
+    EMPTY = "░"
+
+    def __init__(self, total: int, width: int = 30) -> None:
+        self.total = max(1, total)
+        self.width = width
+
+    def render(self, current: int) -> str:
+        """Render progress bar for the given current value."""
+        fraction = min(1.0, max(0.0, current / self.total))
+        filled = int(self.width * fraction)
+        empty = self.width - filled
+        bar = self.FILL * filled + self.EMPTY * empty
+        percent = f"{fraction * 100:.0f}%"
+
+        if fraction < 0.33:
+            colored_bar = Style.red(bar)
+        elif fraction < 0.66:
+            colored_bar = Style.yellow(bar)
+        else:
+            colored_bar = Style.green(bar)
+
+        return f"{colored_bar} {Style.bold(percent)}"
+
+    def render_with_label(self, current: int, label: str = "") -> str:
+        """Render progress bar with optional label and count."""
+        bar = self.render(current)
+        count = Style.dim(f"{format_number(current)}/{format_number(self.total)}")
+        if label:
+            return f"{Style.label(label)} {bar} {count}"
+        return f"{bar} {count}"

vpterm_vp-1.0.0/vpterm/style.py

@@ -0,0 +1,204 @@
+"""ANSI terminal styling — colors, bold, dim, underline.
+
+Supports auto-detection of terminal capabilities and graceful
+fallback to plain text when colors are not supported.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+
+RESET = "\033[0m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+ITALIC = "\033[3m"
+UNDERLINE = "\033[4m"
+
+FG_BLACK = "\033[30m"
+FG_RED = "\033[31m"
+FG_GREEN = "\033[32m"
+FG_YELLOW = "\033[33m"
+FG_BLUE = "\033[34m"
+FG_MAGENTA = "\033[35m"
+FG_CYAN = "\033[36m"
+FG_WHITE = "\033[37m"
+
+FG_BRIGHT_BLACK = "\033[90m"
+FG_BRIGHT_RED = "\033[91m"
+FG_BRIGHT_GREEN = "\033[92m"
+FG_BRIGHT_YELLOW = "\033[93m"
+FG_BRIGHT_BLUE = "\033[94m"
+FG_BRIGHT_MAGENTA = "\033[95m"
+FG_BRIGHT_CYAN = "\033[96m"
+FG_BRIGHT_WHITE = "\033[97m"
+
+BG_RED = "\033[41m"
+BG_GREEN = "\033[42m"
+BG_YELLOW = "\033[43m"
+BG_BLUE = "\033[44m"
+
+_STRIP_ANSI = re.compile(r"\033\[[0-9;]*m")
+
+_colors_enabled: bool | None = None
+
+
+def _detect_color_support() -> bool:
+    """Detect if terminal supports ANSI colors."""
+    if os.environ.get("NO_COLOR"):
+        return False
+    if os.environ.get("FORCE_COLOR"):
+        return True
+    if not hasattr(sys.stdout, "isatty") or not sys.stdout.isatty():
+        return False
+    if sys.platform == "win32":
+        try:
+            import ctypes
+            kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
+            kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+            return True
+        except Exception:
+            return os.environ.get("TERM") is not None
+    return True
+
+
+def colors_enabled() -> bool:
+    """Check if ANSI colors are enabled for this session."""
+    global _colors_enabled
+    if _colors_enabled is None:
+        _colors_enabled = _detect_color_support()
+    return _colors_enabled
+
+
+def set_colors_enabled(enabled: bool) -> None:
+    """Force enable or disable colors."""
+    global _colors_enabled
+    _colors_enabled = enabled
+    
+def strip_ansi(text: str) -> str:
+    """Remove all ANSI escape sequences from text."""
+    return _STRIP_ANSI.sub("", text)
+
+
+def visible_length(text: str) -> int:
+    """Compute visible length of text (excluding ANSI codes)."""
+    return len(strip_ansi(text))
+
+
+class Style:
+    """Named style presets for consistent theming."""
+
+    @staticmethod
+    def _wrap(codes: str, text: str) -> str:
+        if not colors_enabled():
+            return text
+        return f"{codes}{text}{RESET}"
+
+    @staticmethod
+    def bold(text: str) -> str:
+        return Style._wrap(BOLD, text)
+
+    @staticmethod
+    def dim(text: str) -> str:
+        return Style._wrap(DIM, text)
+
+    @staticmethod
+    def red(text: str) -> str:
+        return Style._wrap(FG_RED, text)
+
+    @staticmethod
+    def green(text: str) -> str:
+        return Style._wrap(FG_GREEN, text)
+
+    @staticmethod
+    def yellow(text: str) -> str:
+        return Style._wrap(FG_YELLOW, text)
+
+    @staticmethod
+    def blue(text: str) -> str:
+        return Style._wrap(FG_BLUE, text)
+
+    @staticmethod
+    def magenta(text: str) -> str:
+        return Style._wrap(FG_MAGENTA, text)
+
+    @staticmethod
+    def cyan(text: str) -> str:
+        return Style._wrap(FG_CYAN, text)
+
+    @staticmethod
+    def white(text: str) -> str:
+        return Style._wrap(FG_WHITE, text)
+
+    @staticmethod
+    def bright_black(text: str) -> str:
+        return Style._wrap(FG_BRIGHT_BLACK, text)
+
+    @staticmethod
+    def bright_green(text: str) -> str:
+        return Style._wrap(FG_BRIGHT_GREEN, text)
+
+    @staticmethod
+    def bright_yellow(text: str) -> str:
+        return Style._wrap(FG_BRIGHT_YELLOW, text)
+
+    @staticmethod
+    def bright_cyan(text: str) -> str:
+        return Style._wrap(FG_BRIGHT_CYAN, text)
+
+    @staticmethod
+    def bright_red(text: str) -> str:
+        return Style._wrap(FG_BRIGHT_RED, text)
+
+    @staticmethod
+    def success(text: str) -> str:
+        return Style._wrap(FG_GREEN + BOLD, text)
+
+    @staticmethod
+    def warning(text: str) -> str:
+        return Style._wrap(FG_YELLOW + BOLD, text)
+
+    @staticmethod
+    def error(text: str) -> str:
+        return Style._wrap(FG_RED + BOLD, text)
+
+    @staticmethod
+    def info(text: str) -> str:
+        return Style._wrap(FG_CYAN, text)
+
+    @staticmethod
+    def label(text: str) -> str:
+        return Style._wrap(FG_BRIGHT_BLACK, text)
+
+    @staticmethod
+    def value(text: str) -> str:
+        return Style._wrap(FG_WHITE + BOLD, text)
+
+    @staticmethod
+    def metric_name(text: str) -> str:
+        return Style._wrap(FG_CYAN, text)
+
+    @staticmethod
+    def metric_value(text: str) -> str:
+        return Style._wrap(FG_BRIGHT_YELLOW, text)
+
+    @staticmethod
+    def improved(text: str) -> str:
+        return Style._wrap(FG_GREEN + BOLD, text)
+
+    @staticmethod
+    def degraded(text: str) -> str:
+        return Style._wrap(FG_RED, text)
+
+    @staticmethod
+    def timestamp(text: str) -> str:
+        return Style._wrap(DIM, text)
+
+
+def style(text: str, *codes: str) -> str:
+    """Apply arbitrary ANSI codes to text."""
+    if not colors_enabled():
+        return text
+    combined = "".join(codes)
+    return f"{combined}{text}{RESET}"

vpterm_vp-1.0.0/vpterm/table.py

@@ -0,0 +1,61 @@
+"""Simple table rendering for terminal output."""
+
+from __future__ import annotations
+
+from vpterm.style import Style, visible_length
+
+
+class Table:
+    """Minimal table renderer with column alignment.
+
+    Usage:
+        table = Table(["Component", "Params", "Trainable"])
+        table.add_row(["universal", "45,000,000", "yes"])
+        table.add_row(["family/slavic", "7,200,000", "no"])
+        print(table.render())
+    """
+
+    def __init__(self, headers: list[str], padding: int = 2) -> None:
+        self.headers = headers
+        self.rows: list[list[str]] = []
+        self.padding = padding
+
+    def add_row(self, values: list[str]) -> Table:
+        """Add a data row. Must have same number of columns as headers."""
+        self.rows.append(values)
+        return self
+
+    def _compute_widths(self) -> list[int]:
+        widths = [visible_length(header) for header in self.headers]
+        for row in self.rows:
+            for col_idx, cell in enumerate(row):
+                if col_idx < len(widths):
+                    widths[col_idx] = max(widths[col_idx], visible_length(cell))
+        return widths
+
+    def render(self) -> str:
+        """Render the table as a multi-line string."""
+        widths = self._compute_widths()
+        pad = " " * self.padding
+        lines: list[str] = []
+
+        header_cells = []
+        for idx, header in enumerate(self.headers):
+            header_cells.append(Style.bold(header.ljust(widths[idx])))
+        lines.append(pad.join(header_cells))
+
+        separator_cells = [Style.dim("─" * width) for width in widths]
+        lines.append(pad.join(separator_cells))
+
+        for row in self.rows:
+            cells = []
+            for col_idx, cell in enumerate(row):
+                width = widths[col_idx] if col_idx < len(widths) else 0
+                cell_padding = max(0, width - visible_length(cell))
+                cells.append(cell + " " * cell_padding)
+            lines.append(pad.join(cells))
+
+        return "\n".join(lines)
+
+    def __str__(self) -> str:
+        return self.render()

vpterm_vp-1.0.0/vpterm/terminal.py

@@ -0,0 +1,104 @@
+"""Terminal abstraction — write styled output to stdout."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from vpterm.style import Style, colors_enabled, visible_length
+
+
+class Terminal:
+    """Output controller for terminal rendering.
+
+    Manages writing styled lines, clearing, and detecting terminal width.
+    """
+
+    def __init__(self, stream: object | None = None) -> None:
+        self.stream = stream or sys.stdout
+
+    def width(self) -> int:
+        """Get terminal width in columns."""
+        try:
+            return os.get_terminal_size(self.stream.fileno()).columns
+        except (AttributeError, ValueError, OSError):
+            return 120
+
+    def write(self, text: str) -> None:
+        """Write text to stream."""
+        self.stream.write(text)
+        self.stream.flush()
+
+    def writeln(self, text: str = "") -> None:
+        """Write text followed by newline."""
+        self.stream.write(text + "\n")
+        self.stream.flush()
+
+    def blank_line(self) -> None:
+        """Write an empty line."""
+        self.writeln()
+
+    def overwrite_line(self, text: str) -> None:
+        """Overwrite the current line (carriage return)."""
+        width = self.width()
+        padded = text + " " * max(0, width - visible_length(text))
+        self.stream.write(f"\r{padded}")
+        self.stream.flush()
+
+    def separator(self, char: str = "─", label: str = "") -> None:
+        """Draw a horizontal separator line."""
+        width = self.width()
+        if label:
+            styled_label = f" {label} "
+            label_len = len(styled_label)
+            left = char * 2
+            right = char * max(0, width - 4 - label_len)
+            line = f"{left}{Style.bold(styled_label)}{right}"
+        else:
+            line = char * width
+        self.writeln(Style.dim(line) if not label else line)
+
+    def header(self, title: str) -> None:
+        """Print a styled header with separators."""
+        self.separator("─", title)
+
+    def section(self, title: str) -> None:
+        """Print a section header."""
+        self.writeln(Style.bold(Style.cyan(f"▸ {title}")))
+
+    def kv_pair(self, key: str, value: str, key_width: int = 0) -> None:
+        """Print a key=value pair with styling."""
+        padded_key = key.ljust(key_width) if key_width > 0 else key
+        self.writeln(f"  {Style.label(padded_key)}  {Style.value(value)}")
+
+    def metric(self, name: str, value: str | float, precision: int = 4) -> str:
+        """Format a metric as styled string (does not print)."""
+        if isinstance(value, float):
+            formatted = f"{value:.{precision}f}"
+        else:
+            formatted = str(value)
+        return f"{Style.metric_name(name)}{Style.dim('=')}{Style.metric_value(formatted)}"
+
+    def status(self, message: str, kind: str = "info") -> None:
+        """Print a status message."""
+        prefixes = {
+            "info": Style.cyan("ℹ"),
+            "success": Style.success("✓"),
+            "warning": Style.warning("⚠"),
+            "error": Style.error("✗"),
+            "start": Style.blue("▶"),
+            "stop": Style.yellow("■"),
+        }
+        prefix = prefixes.get(kind, Style.dim("·"))
+        self.writeln(f" {prefix} {message}")
+
+
+_default_terminal: Terminal | None = None
+
+
+def get_terminal() -> Terminal:
+    """Get the global Terminal instance."""
+    global _default_terminal
+    if _default_terminal is None:
+        _default_terminal = Terminal()
+    return _default_terminal

vpterm_vp-1.0.0/vpterm_vp.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: vpterm-vp
+Version: 1.0.0
+Summary: Terminal rendering: colors, panels, tables, progress bars.
+Author: F000NK, Voluntas Progressus
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.14

vpterm_vp-1.0.0/vpterm_vp.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+pyproject.toml
+vpterm/__init__.py
+vpterm/kv.py
+vpterm/panel.py
+vpterm/progress.py
+vpterm/py.typed
+vpterm/style.py
+vpterm/table.py
+vpterm/terminal.py
+vpterm_vp.egg-info/PKG-INFO
+vpterm_vp.egg-info/SOURCES.txt
+vpterm_vp.egg-info/dependency_links.txt
+vpterm_vp.egg-info/top_level.txt

vpterm_vp-1.0.0/vpterm_vp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vpterm_vp-1.0.0/vpterm_vp.egg-info/top_level.txt

@@ -0,0 +1 @@
+vpterm