curint 0.1.2__py3-none-any.whl

curint/__init__.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from .animations import (
+    bounce,
+    bounce_frames,
+    glitch,
+    glitch_frames,
+    print_animated,
+    print_bounce,
+    print_wave,
+    shimmer,
+    shimmer_frames,
+    typewriter,
+    wave,
+    wave_frames,
+)
+from .colors import PALETTES, RGB, ansi_bg, ansi_fg, blend_many, parse_color, strip_ansi
+from .console import SpectraConsole, debug, error, info, success, warning
+from .logging import SpectraLogHandler, configure_logging
+from .progress import Spinner, SpinnerRich, progress_bar, progress_bar_rich, rich_status, track_iter
+from .prompt import ask, choose, confirm
+from .text import (
+    box,
+    center,
+    color_text,
+    cprint,
+    gradient_text,
+    highlight,
+    palette_text,
+    print_color,
+    print_gradient,
+    print_gradient_rich,
+    print_rainbow,
+    rainbow_text,
+    sky_gradient,
+    style_text,
+    termcolor_text,
+)
+from .theme import THEMES, Theme, get_theme, register_theme, theme_names, use_theme
+
+__all__ = [
+    "PALETTES",
+    "RGB",
+    "THEMES",
+    "SpectraConsole",
+    "SpectraLogHandler",
+    "Spinner",
+    "SpinnerRich",
+    "Theme",
+    "ansi_bg",
+    "ansi_fg",
+    "ask",
+    "blend_many",
+    "bounce",
+    "bounce_frames",
+    "box",
+    "center",
+    "choose",
+    "color_text",
+    "configure_logging",
+    "confirm",
+    "cprint",
+    "debug",
+    "error",
+    "get_theme",
+    "glitch",
+    "glitch_frames",
+    "gradient_text",
+    "highlight",
+    "info",
+    "palette_text",
+    "parse_color",
+    "print_animated",
+    "print_bounce",
+    "print_color",
+    "print_gradient",
+    "print_gradient_rich",
+    "print_rainbow",
+    "print_wave",
+    "progress_bar",
+    "progress_bar_rich",
+    "rainbow_text",
+    "register_theme",
+    "rich_status",
+    "shimmer",
+    "shimmer_frames",
+    "sky_gradient",
+    "strip_ansi",
+    "style_text",
+    "success",
+    "termcolor_text",
+    "theme_names",
+    "track_iter",
+    "typewriter",
+    "use_theme",
+    "warning",
+    "wave",
+    "wave_frames",
+]
+
+__version__ = "0.1.2"

curint/_compat.py

@@ -0,0 +1,46 @@
+"""Compatibility shims for optional imports during local development.
+
+The package declares its core dependencies in setup.py. The fallbacks below
+let tests and docs render in constrained environments before installation.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+try:  # pragma: no cover - exercised when dependency is installed
+    from colorama import Back, Fore, Style, just_fix_windows_console
+except Exception:  # pragma: no cover - fallback for source tree tests
+    class _Codes:
+        BLACK = RED = GREEN = YELLOW = BLUE = MAGENTA = CYAN = WHITE = RESET = RESET_ALL = ""
+        BRIGHT = DIM = NORMAL = ""
+
+    Fore = Back = Style = _Codes()  # type: ignore[assignment]
+
+    def just_fix_windows_console() -> None:
+        return None
+
+try:  # pragma: no cover
+    from termcolor import colored
+except Exception:  # pragma: no cover
+    def colored(text: str, color: str | None = None, on_color: str | None = None, attrs: list[str] | None = None) -> str:
+        return text
+
+try:  # pragma: no cover
+    from rich.console import Console
+    from rich.markdown import Markdown
+    from rich.panel import Panel
+    from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn, track
+    from rich.table import Table
+    from rich.text import Text
+    from rich.tree import Tree
+except Exception as exc:  # pragma: no cover
+    raise RuntimeError("curint requires rich. Install with `pip install curint`.") from exc
+
+try:  # pragma: no cover
+    import skytext as _skytext
+except Exception:  # pragma: no cover
+    _skytext = None
+
+
+SKYTEXT: Any = _skytext

curint/animations.py

@@ -0,0 +1,109 @@
+"""Animated terminal text helpers."""
+
+from __future__ import annotations
+
+import random
+import sys
+import time
+from collections.abc import Iterator, Sequence
+
+from ._compat import Console
+from .colors import strip_ansi
+from .text import gradient_text, rainbow_text, style_text
+
+console = Console()
+
+
+def typewriter(text: str, *, delay: float = 0.03, color: str | Sequence[int] | None = None, end: str = "\n") -> None:
+    """Print text one character at a time."""
+
+    styled = style_text(text, fg=color) if color else text
+    for char in styled:
+        sys.stdout.write(char)
+        sys.stdout.flush()
+        time.sleep(delay)
+    sys.stdout.write(end)
+    sys.stdout.flush()
+
+
+def wave_frames(text: str, *, height: int = 2, cycles: int = 1) -> Iterator[str]:
+    """Generate simple vertical wave frames for testing or playback."""
+
+    height = max(1, height)
+    clean = strip_ansi(text)
+    for offset in range(max(1, cycles * len(clean))):
+        lines = [[" " for _ in clean] for _ in range(height + 1)]
+        for index, char in enumerate(clean):
+            row = abs((index + offset) % (height * 2) - height)
+            lines[row][index] = char
+        yield "\n".join("".join(line).rstrip() for line in lines)
+
+
+def wave(text: str, *, color: str | Sequence[int] | None = None, height: int = 2, cycles: int = 2, delay: float = 0.08) -> None:
+    for frame in wave_frames(text, height=height, cycles=cycles):
+        console.clear()
+        console.print(style_text(frame, fg=color) if color else frame, markup=False)
+        time.sleep(delay)
+
+
+def bounce_frames(text: str, *, width: int = 40, cycles: int = 2) -> Iterator[str]:
+    clean = strip_ansi(text)
+    width = max(len(clean), width)
+    span = width - len(clean)
+    path = list(range(span + 1)) + list(range(max(0, span - 1), 0, -1))
+    for _ in range(cycles):
+        for pos in path or [0]:
+            yield " " * pos + clean
+
+
+def bounce(text: str, *, color: str | Sequence[int] | None = None, width: int = 40, cycles: int = 2, delay: float = 0.05) -> None:
+    for frame in bounce_frames(text, width=width, cycles=cycles):
+        sys.stdout.write("\r" + style_text(frame, fg=color) if color else "\r" + frame)
+        sys.stdout.flush()
+        time.sleep(delay)
+    sys.stdout.write("\n")
+
+
+def shimmer_frames(text: str, *, cycles: int = 1) -> Iterator[str]:
+    clean = strip_ansi(text)
+    for phase in range(max(1, len(clean) * cycles)):
+        pieces: list[str] = []
+        for index, char in enumerate(clean):
+            if char.isspace():
+                pieces.append(char)
+            elif index == phase % len(clean):
+                pieces.append(style_text(char, fg="#ffffff", bold=True))
+            else:
+                pieces.append(style_text(char, fg="#6272a4"))
+        yield "".join(pieces)
+
+
+def shimmer(text: str, *, cycles: int = 2, delay: float = 0.04) -> None:
+    for frame in shimmer_frames(text, cycles=cycles):
+        sys.stdout.write("\r" + frame)
+        sys.stdout.flush()
+        time.sleep(delay)
+    sys.stdout.write("\n")
+
+
+def glitch_frames(text: str, *, intensity: float = 0.12, frames: int = 8, charset: str = "!@#$%^&*<>?/\\|~") -> Iterator[str]:
+    clean = strip_ansi(text)
+    intensity = min(1.0, max(0.0, intensity))
+    for _ in range(max(1, frames)):
+        chars = [random.choice(charset) if char.strip() and random.random() < intensity else char for char in clean]
+        yield rainbow_text("".join(chars), bold=True)
+    yield clean
+
+
+def glitch(text: str, *, intensity: float = 0.12, frames: int = 8, delay: float = 0.05) -> None:
+    for frame in glitch_frames(text, intensity=intensity, frames=frames):
+        sys.stdout.write("\r" + frame)
+        sys.stdout.flush()
+        time.sleep(delay)
+    sys.stdout.write("\n")
+
+
+# Convenience aliases.
+print_animated = typewriter
+print_wave = wave
+print_bounce = bounce

curint/colors.py

@@ -0,0 +1,152 @@
+"""Color parsing and ANSI helpers."""
+
+from __future__ import annotations
+
+import math
+import re
+from dataclasses import dataclass
+from typing import Iterable, Iterator, Sequence
+
+RGBTuple = tuple[int, int, int]
+
+RESET = "\033[0m"
+ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+CSS_COLORS: dict[str, RGBTuple] = {
+    "black": (0, 0, 0),
+    "red": (255, 85, 85),
+    "green": (80, 250, 123),
+    "yellow": (241, 250, 140),
+    "blue": (98, 114, 164),
+    "magenta": (255, 121, 198),
+    "cyan": (139, 233, 253),
+    "white": (248, 248, 242),
+    "orange": (255, 184, 108),
+    "purple": (189, 147, 249),
+    "pink": (255, 121, 198),
+    "gray": (128, 128, 128),
+    "grey": (128, 128, 128),
+}
+
+PALETTES: dict[str, list[RGBTuple]] = {
+    "rainbow": [(255, 0, 0), (255, 127, 0), (255, 255, 0), (0, 255, 0), (0, 170, 255), (75, 0, 130), (148, 0, 211)],
+    "sunset": [(255, 94, 98), (255, 153, 102), (255, 206, 84), (106, 90, 205)],
+    "ocean": [(0, 180, 219), (0, 131, 176), (72, 85, 99)],
+    "neon": [(57, 255, 20), (0, 255, 255), (255, 0, 255), (255, 255, 0)],
+    "fire": [(255, 0, 0), (255, 120, 0), (255, 255, 0), (255, 255, 255)],
+}
+
+@dataclass(frozen=True)
+class RGB:
+    """An immutable RGB color."""
+
+    r: int
+    g: int
+    b: int
+
+    def __post_init__(self) -> None:
+        for channel in (self.r, self.g, self.b):
+            if channel < 0 or channel > 255:
+                raise ValueError("RGB channels must be between 0 and 255")
+
+    @property
+    def tuple(self) -> RGBTuple:
+        return (self.r, self.g, self.b)
+
+    @property
+    def hex(self) -> str:
+        return f"#{self.r:02x}{self.g:02x}{self.b:02x}"
+
+    def fg(self) -> str:
+        return ansi_fg(self.tuple)
+
+    def bg(self) -> str:
+        return ansi_bg(self.tuple)
+
+
+def clamp(value: float, minimum: int = 0, maximum: int = 255) -> int:
+    return max(minimum, min(maximum, int(round(value))))
+
+
+def parse_color(color: str | Sequence[int] | RGB) -> RGBTuple:
+    """Parse a color name, hex value, RGB tuple/list, or :class:`RGB`."""
+
+    if isinstance(color, RGB):
+        return color.tuple
+    if isinstance(color, str):
+        value = color.strip().lower()
+        if value in CSS_COLORS:
+            return CSS_COLORS[value]
+        if value.startswith("#"):
+            value = value[1:]
+        if len(value) == 3 and all(ch in "0123456789abcdef" for ch in value):
+            return tuple(int(ch * 2, 16) for ch in value)  # type: ignore[return-value]
+        if len(value) == 6 and all(ch in "0123456789abcdef" for ch in value):
+            return (int(value[0:2], 16), int(value[2:4], 16), int(value[4:6], 16))
+        raise ValueError(f"Unknown color: {color!r}")
+    if len(color) != 3:
+        raise ValueError("RGB colors need exactly three channels")
+    rgb = tuple(int(channel) for channel in color)
+    if not all(0 <= channel <= 255 for channel in rgb):
+        raise ValueError("RGB channels must be between 0 and 255")
+    return rgb  # type: ignore[return-value]
+
+
+def ansi_fg(color: str | Sequence[int] | RGB) -> str:
+    r, g, b = parse_color(color)
+    return f"\033[38;2;{r};{g};{b}m"
+
+
+def ansi_bg(color: str | Sequence[int] | RGB) -> str:
+    r, g, b = parse_color(color)
+    return f"\033[48;2;{r};{g};{b}m"
+
+
+def strip_ansi(text: str) -> str:
+    return ANSI_RE.sub("", text)
+
+
+def lerp(start: RGBTuple, end: RGBTuple, t: float) -> RGBTuple:
+    return tuple(clamp(start[i] + (end[i] - start[i]) * t) for i in range(3))  # type: ignore[return-value]
+
+
+def blend_many(colors: Sequence[str | Sequence[int] | RGB], steps: int) -> list[RGBTuple]:
+    """Return ``steps`` colors interpolated through all stops."""
+
+    if steps <= 0:
+        return []
+    stops = [parse_color(color) for color in colors]
+    if len(stops) == 1:
+        return stops * steps
+    if steps == 1:
+        return [stops[0]]
+
+    result: list[RGBTuple] = []
+    segments = len(stops) - 1
+    for index in range(steps):
+        pos = index / (steps - 1)
+        segment = min(segments - 1, int(pos * segments))
+        local_start = segment / segments
+        local_end = (segment + 1) / segments
+        local_t = 0 if local_end == local_start else (pos - local_start) / (local_end - local_start)
+        result.append(lerp(stops[segment], stops[segment + 1], local_t))
+    return result
+
+
+def rainbow_color(index: int, total: int, phase: float = 0.0) -> RGBTuple:
+    """Return a smooth rainbow RGB value for ``index`` in ``total``."""
+
+    if total <= 0:
+        return (255, 255, 255)
+    angle = 2 * math.pi * ((index / max(total, 1)) + phase)
+    r = clamp(math.sin(angle) * 127 + 128)
+    g = clamp(math.sin(angle + 2 * math.pi / 3) * 127 + 128)
+    b = clamp(math.sin(angle + 4 * math.pi / 3) * 127 + 128)
+    return (r, g, b)
+
+
+def cycle_palette(name: str, length: int) -> Iterator[RGBTuple]:
+    palette = PALETTES.get(name, PALETTES["rainbow"])
+    if length <= 0:
+        return iter(())
+    return iter(blend_many(palette, length))

curint/console.py

@@ -0,0 +1,143 @@
+"""Rich-powered console wrappers."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable, Mapping, Sequence
+from typing import Any
+
+from ._compat import Console, Markdown, Panel, Table, Tree
+from .colors import parse_color
+from .text import gradient_text, rainbow_text, style_text
+from .theme import Theme, get_theme
+
+
+def _rich_color(color: str | Sequence[int] | None) -> str | None:
+    if color is None:
+        return None
+    if isinstance(color, str) and not color.startswith("#"):
+        try:
+            r, g, b = parse_color(color)
+            return f"#{r:02x}{g:02x}{b:02x}"
+        except ValueError:
+            return color
+    r, g, b = parse_color(color)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+class SpectraConsole:
+    """Convenience wrapper around :class:`rich.console.Console`."""
+
+    def __init__(self, *, theme: str | Theme | None = None, console: Console | None = None) -> None:
+        self.theme = get_theme(theme) if isinstance(theme, str) or theme is None else theme
+        self.console = console or Console()
+
+    def print(self, value: Any = "", *, style: str | None = None, markup: bool = True) -> None:
+        self.console.print(value, style=style, markup=markup)
+
+    def gradient(self, text: str, start: str | Sequence[int] | None = None, end: str | Sequence[int] | None = None, *, bold: bool = False) -> None:
+        self.console.print(gradient_text(text, start or self.theme.primary, end or self.theme.secondary, bold=bold), markup=False)
+
+    def rainbow(self, text: str, *, bold: bool = False) -> None:
+        self.console.print(rainbow_text(text, bold=bold), markup=False)
+
+    def banner(self, text: str, *, width: int | None = None, gradient: bool = True) -> str:
+        """Print a compact text banner without external font dependencies."""
+
+        title = f" {text.strip()} " if text.strip() else " "
+        line_width = max(len(title), width or len(title))
+        rendered = "═" * line_width + "\n" + title.center(line_width) + "\n" + "═" * line_width
+        output = gradient_text(rendered, self.theme.primary, self.theme.secondary, bold=True) if gradient else rendered
+        self.console.print(output, markup=False)
+        return output
+
+    def panel(self, text: str, *, title: str | None = None, border: str | Sequence[int] | None = None) -> None:
+        border_style = _rich_color(border or self.theme.primary)
+        self.console.print(Panel(text, title=title, border_style=border_style))
+
+    def rule(self, title: str = "", *, color: str | Sequence[int] | None = None) -> None:
+        self.console.rule(title, style=_rich_color(color or self.theme.primary))
+
+    def markdown(self, source: str) -> None:
+        self.console.print(Markdown(source))
+
+    def json(self, data: Any, *, indent: int = 2) -> None:
+        self.console.print_json(json.dumps(data, indent=indent, default=str))
+
+    def table(
+        self,
+        rows: Iterable[Mapping[str, Any] | Sequence[Any]],
+        *,
+        headers: Sequence[str] | None = None,
+        title: str | None = None,
+    ) -> Table:
+        rows = list(rows)
+        if headers is None:
+            first = rows[0] if rows else []
+            headers = list(first.keys()) if isinstance(first, Mapping) else [f"Column {i + 1}" for i in range(len(first))]
+        table = Table(title=title, header_style=_rich_color(self.theme.primary) or "bold")
+        for header in headers:
+            table.add_column(str(header))
+        for row in rows:
+            if isinstance(row, Mapping):
+                values = [row.get(header, "") for header in headers]
+            else:
+                values = list(row)
+            table.add_row(*(str(value) for value in values))
+        self.console.print(table)
+        return table
+
+    def tree(self, root: str, branches: Mapping[str, Any]) -> Tree:
+        tree = Tree(root)
+
+        def add(parent: Tree, value: Any) -> None:
+            if isinstance(value, Mapping):
+                for key, child in value.items():
+                    node = parent.add(str(key))
+                    add(node, child)
+            elif isinstance(value, (list, tuple, set)):
+                for item in value:
+                    add(parent, item)
+            else:
+                parent.add(str(value))
+
+        add(tree, branches)
+        self.console.print(tree)
+        return tree
+
+    def status(self, text: str, kind: str = "info") -> None:
+        icon = {
+            "success": "✓",
+            "error": "✖",
+            "warning": "⚠",
+            "info": "ℹ",
+            "debug": "•",
+        }.get(kind, "•")
+        color = getattr(self.theme, kind, self.theme.info)
+        self.console.print(style_text(f"{icon} {text}", fg=color, bold=True), markup=False)
+
+    def capture_gradient(self, text: str, start: str | Sequence[int] | None = None, end: str | Sequence[int] | None = None) -> str:
+        return gradient_text(text, start or self.theme.primary, end or self.theme.secondary)
+
+
+_default_console = SpectraConsole()
+
+
+def success(text: str) -> None:
+    _default_console.status(text, "success")
+
+
+def error(text: str) -> None:
+    _default_console.status(text, "error")
+
+
+def warning(text: str) -> None:
+    _default_console.status(text, "warning")
+
+
+def info(text: str) -> None:
+    _default_console.status(text, "info")
+
+
+def debug(text: str) -> None:
+    _default_console.status(text, "debug")

curint/logging.py

@@ -0,0 +1,47 @@
+"""Logging helpers that use Rich output."""
+
+from __future__ import annotations
+
+import logging
+from typing import TextIO
+
+from ._compat import Console
+from .theme import get_theme
+
+
+class SpectraLogHandler(logging.Handler):
+    """A compact, colorful logging handler powered by Rich."""
+
+    LEVEL_STYLES = {
+        logging.DEBUG: "dim",
+        logging.INFO: "cyan",
+        logging.WARNING: "yellow",
+        logging.ERROR: "bold red",
+        logging.CRITICAL: "bold white on red",
+    }
+
+    def __init__(self, *, console: Console | None = None, level: int = logging.NOTSET) -> None:
+        super().__init__(level=level)
+        self.console = console or Console(stderr=True)
+        self.setFormatter(logging.Formatter("%(message)s"))
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            message = self.format(record)
+            style = self.LEVEL_STYLES.get(record.levelno, "white")
+            self.console.print(f"[{record.levelname.lower()}] {message}", style=style)
+        except Exception:  # pragma: no cover
+            self.handleError(record)
+
+
+def configure_logging(level: int | str = logging.INFO, *, logger_name: str | None = None) -> logging.Logger:
+    """Attach a :class:`SpectraLogHandler` and return the configured logger."""
+
+    logger = logging.getLogger(logger_name)
+    numeric_level = logging.getLevelName(level) if isinstance(level, str) else level
+    if not isinstance(numeric_level, int):
+        numeric_level = logging.INFO
+    logger.setLevel(numeric_level)
+    logger.handlers[:] = [SpectraLogHandler(level=numeric_level)]
+    logger.propagate = False
+    return logger

curint/progress.py

@@ -0,0 +1,107 @@
+"""Progress bars, spinners, and task tracking."""
+
+from __future__ import annotations
+
+import contextlib
+import itertools
+import sys
+import threading
+import time
+from collections.abc import Iterable, Iterator
+from typing import TypeVar
+
+from ._compat import BarColumn, Console, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn, track
+
+T = TypeVar("T")
+
+SPINNER_STYLES: dict[str, tuple[str, ...]] = {
+    "dots": ("⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"),
+    "line": ("-", "\\", "|", "/"),
+    "circle": ("◐", "◓", "◑", "◒"),
+    "moon": ("🌑", "🌒", "🌓", "🌔", "🌕", "🌖", "🌗", "🌘"),
+    "bounce": ("⠁", "⠂", "⠄", "⠂"),
+}
+
+
+def progress_bar(total: int = 100, description: str = "Working", *, delay: float = 0.02, transient: bool = False) -> None:
+    """Display a Rich progress bar that advances from 0 to ``total``."""
+
+    total = max(0, int(total))
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("{task.percentage:>3.0f}%"),
+        TimeElapsedColumn(),
+        transient=transient,
+    ) as progress:
+        task = progress.add_task(description, total=total)
+        while not progress.finished:
+            progress.advance(task)
+            time.sleep(delay)
+
+
+class Spinner:
+    """Threaded terminal spinner.
+
+    Use as a context manager:
+
+    >>> with Spinner("Uploading"):
+    ...     run_upload()
+    """
+
+    def __init__(self, message: str = "Working", *, style: str = "dots", delay: float = 0.1, stream=None) -> None:
+        self.message = message
+        self.frames = SPINNER_STYLES.get(style, SPINNER_STYLES["dots"])
+        self.delay = delay
+        self.stream = stream or sys.stderr
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> "Spinner":
+        if self._thread and self._thread.is_alive():
+            return self
+        self._stop.clear()
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+        return self
+
+    def _spin(self) -> None:
+        for frame in itertools.cycle(self.frames):
+            if self._stop.is_set():
+                break
+            self.stream.write(f"\r{frame} {self.message}")
+            self.stream.flush()
+            time.sleep(self.delay)
+
+    def stop(self, final: str | None = None) -> None:
+        self._stop.set()
+        if self._thread:
+            self._thread.join(timeout=self.delay * 3)
+        clear = " " * (len(self.message) + 8)
+        self.stream.write(f"\r{clear}\r")
+        if final:
+            self.stream.write(final + "\n")
+        self.stream.flush()
+
+    def __enter__(self) -> "Spinner":
+        return self.start()
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.stop()
+
+
+@contextlib.contextmanager
+def rich_status(message: str, *, spinner: str = "dots") -> Iterator[None]:
+    console = Console()
+    with console.status(message, spinner=spinner):
+        yield
+
+
+def track_iter(iterable: Iterable[T], description: str = "Processing") -> Iterator[T]:
+    yield from track(iterable, description=description)
+
+
+# Convenience aliases.
+progress_bar_rich = progress_bar
+SpinnerRich = Spinner

curint/prompt.py

@@ -0,0 +1,38 @@
+"""Tiny prompt helpers styled with curint."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from .text import style_text
+from .theme import get_theme
+
+
+def ask(question: str, *, default: str | None = None) -> str:
+    theme = get_theme()
+    suffix = f" [{default}]" if default is not None else ""
+    answer = input(style_text(f"? {question}{suffix}: ", fg=theme.primary, bold=True))
+    return answer or (default or "")
+
+
+def confirm(question: str, *, default: bool = False) -> bool:
+    marker = "Y/n" if default else "y/N"
+    answer = ask(f"{question} ({marker})").strip().lower()
+    if not answer:
+        return default
+    return answer in {"y", "yes", "true", "1"}
+
+
+def choose(question: str, choices: Sequence[str], *, default: str | None = None) -> str:
+    if not choices:
+        raise ValueError("choices cannot be empty")
+    default = default or choices[0]
+    print(style_text(f"? {question}", fg=get_theme().primary, bold=True))
+    for index, choice in enumerate(choices, start=1):
+        print(f"  {index}. {choice}")
+    answer = ask("Choose a number", default=str(choices.index(default) + 1))
+    try:
+        position = int(answer) - 1
+        return choices[position]
+    except Exception:
+        return default

curint/text.py

@@ -0,0 +1,150 @@
+"""Text styling helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+from ._compat import Console, SKYTEXT, colored, just_fix_windows_console
+from .colors import PALETTES, RESET, RGB, ansi_bg, ansi_fg, blend_many, parse_color, rainbow_color, strip_ansi
+
+just_fix_windows_console()
+console = Console()
+
+
+def style_text(
+    text: str,
+    fg: str | Sequence[int] | RGB | None = None,
+    bg: str | Sequence[int] | RGB | None = None,
+    *,
+    bold: bool = False,
+    italic: bool = False,
+    underline: bool = False,
+    dim: bool = False,
+) -> str:
+    """Return ANSI-styled text with true-color foreground/background support."""
+
+    codes: list[str] = []
+    if bold:
+        codes.append("\033[1m")
+    if dim:
+        codes.append("\033[2m")
+    if italic:
+        codes.append("\033[3m")
+    if underline:
+        codes.append("\033[4m")
+    if fg is not None:
+        codes.append(ansi_fg(fg))
+    if bg is not None:
+        codes.append(ansi_bg(bg))
+    if not codes:
+        return text
+    return "".join(codes) + text + RESET
+
+
+def termcolor_text(text: str, color: str | None = None, on_color: str | None = None, attrs: list[str] | None = None) -> str:
+    """Small wrapper around :func:`termcolor.colored` for classic ANSI names."""
+
+    return colored(text, color=color, on_color=on_color, attrs=attrs)
+
+
+def gradient_text(
+    text: str,
+    start: str | Sequence[int] | RGB = "#ff5e62",
+    end: str | Sequence[int] | RGB = "#00d4ff",
+    *,
+    stops: Sequence[str | Sequence[int] | RGB] | None = None,
+    bold: bool = False,
+) -> str:
+    """Return text colored by a smooth RGB gradient."""
+
+    chars = list(text)
+    colors = blend_many(stops or [start, end], len(chars))
+    pieces: list[str] = []
+    for char, color in zip(chars, colors, strict=False):
+        if char.isspace():
+            pieces.append(char)
+        else:
+            pieces.append(style_text(char, color, bold=bold))
+    return "".join(pieces)
+
+
+def palette_text(text: str, palette: str = "rainbow", *, bold: bool = False) -> str:
+    colors = blend_many(PALETTES.get(palette, PALETTES["rainbow"]), len(text))
+    return "".join(char if char.isspace() else style_text(char, color, bold=bold) for char, color in zip(text, colors, strict=False))
+
+
+def rainbow_text(text: str, *, phase: float = 0.0, bold: bool = False) -> str:
+    pieces: list[str] = []
+    total = max(1, len(text))
+    for index, char in enumerate(text):
+        if char.isspace():
+            pieces.append(char)
+        else:
+            pieces.append(style_text(char, rainbow_color(index, total, phase), bold=bold))
+    return "".join(pieces)
+
+
+def highlight(text: str, query: str, *, fg: str | Sequence[int] | RGB = "black", bg: str | Sequence[int] | RGB = "yellow") -> str:
+    """Highlight all exact occurrences of ``query`` in ``text``."""
+
+    if not query:
+        return text
+    return text.replace(query, style_text(query, fg, bg, bold=True))
+
+
+def center(text: str, width: int = 80, fill: str = " ") -> str:
+    """Center text using a simple ANSI-stripped display width."""
+
+    display = max(0, len(strip_ansi(text)))
+    if display >= width:
+        return text
+    total = width - display
+    left = total // 2
+    right = total - left
+    return f"{fill * left}{text}{fill * right}"
+
+
+def box(text: str, *, title: str | None = None, width: int | None = None) -> str:
+    """Return a simple ANSI-free box string for logs or plain terminals."""
+
+    lines = text.splitlines() or [""]
+    content_width = max(len(strip_ansi(line)) for line in lines)
+    if title:
+        content_width = max(content_width, len(title) + 2)
+    if width is not None:
+        content_width = max(content_width, width - 4)
+    top_label = f" {title} " if title else ""
+    top = "┌" + top_label + "─" * max(0, content_width - len(top_label)) + "┐"
+    bottom = "└" + "─" * content_width + "┘"
+    body = ["│" + line + " " * max(0, content_width - len(strip_ansi(line))) + "│" for line in lines]
+    return "\n".join([top, *body, bottom])
+
+
+def sky_gradient(text: str, start: tuple[int, int, int] = (255, 0, 0), end: tuple[int, int, int] = (0, 255, 255)) -> str:
+    """Use SkyText's gradient when available, otherwise use curint's fallback."""
+
+    if SKYTEXT is not None:
+        fn = getattr(SKYTEXT, "gradient", None) or getattr(SKYTEXT, "print_gradient", None)
+        if callable(fn):
+            # Most SkyText helpers print directly. We return our fallback to keep this function pure.
+            return gradient_text(text, start, end)
+    return gradient_text(text, start, end)
+
+
+def print_color(text: str, fg: str | Sequence[int] | RGB | None = None, bg: str | Sequence[int] | RGB | None = None, **kwargs: Any) -> None:
+    console.print(style_text(text, fg=fg, bg=bg, **kwargs), markup=False)
+
+
+def print_gradient(text: str, start: str | Sequence[int] | RGB = "#ff5e62", end: str | Sequence[int] | RGB = "#00d4ff", **kwargs: Any) -> None:
+    console.print(gradient_text(text, start, end, **kwargs), markup=False)
+
+
+def print_rainbow(text: str, **kwargs: Any) -> None:
+    console.print(rainbow_text(text, **kwargs), markup=False)
+
+
+# Convenience aliases for callers who prefer print-oriented names.
+color_text = style_text
+cprint = print_color
+print_gradient_rich = print_gradient

curint/theme.py

@@ -0,0 +1,119 @@
+"""Theme definitions used by console and status helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import Mapping
+
+ColorLike = str | tuple[int, int, int]
+
+@dataclass(frozen=True)
+class Theme:
+    name: str
+    primary: ColorLike = "#00d4ff"
+    secondary: ColorLike = "#ff5e62"
+    accent: ColorLike = "#ffd166"
+    success: ColorLike = "#50fa7b"
+    error: ColorLike = "#ff5555"
+    warning: ColorLike = "#f1fa8c"
+    info: ColorLike = "#8be9fd"
+    muted: ColorLike = "#6272a4"
+
+    def as_dict(self) -> dict[str, ColorLike]:
+        return {
+            "primary": self.primary,
+            "secondary": self.secondary,
+            "accent": self.accent,
+            "success": self.success,
+            "error": self.error,
+            "warning": self.warning,
+            "info": self.info,
+            "muted": self.muted,
+        }
+
+    def with_values(self, **values: ColorLike) -> "Theme":
+        return replace(self, **values)
+
+
+THEMES: dict[str, Theme] = {
+    "default": Theme("default"),
+    "dracula": Theme(
+        "dracula",
+        primary="#bd93f9",
+        secondary="#ff79c6",
+        accent="#f1fa8c",
+        success="#50fa7b",
+        error="#ff5555",
+        warning="#ffb86c",
+        info="#8be9fd",
+        muted="#6272a4",
+    ),
+    "ocean": Theme(
+        "ocean",
+        primary="#00b4db",
+        secondary="#0083b0",
+        accent="#caf0f8",
+        success="#80ed99",
+        error="#ff6b6b",
+        warning="#ffd166",
+        info="#90e0ef",
+        muted="#6c757d",
+    ),
+    "sunset": Theme(
+        "sunset",
+        primary="#ff5e62",
+        secondary="#ff9966",
+        accent="#ffe66d",
+        success="#96f550",
+        error="#ff3864",
+        warning="#ffcc00",
+        info="#a0e7e5",
+        muted="#6d6875",
+    ),
+    "mono": Theme(
+        "mono",
+        primary="white",
+        secondary="gray",
+        accent="white",
+        success="white",
+        error="white",
+        warning="white",
+        info="white",
+        muted="gray",
+    ),
+}
+
+_current_theme = THEMES["default"]
+
+
+def get_theme(name: str | None = None) -> Theme:
+    if name is None:
+        return _current_theme
+    try:
+        return THEMES[name]
+    except KeyError as exc:
+        available = ", ".join(sorted(THEMES))
+        raise ValueError(f"Unknown theme {name!r}. Available themes: {available}") from exc
+
+
+def use_theme(name: str) -> Theme:
+    global _current_theme
+    _current_theme = get_theme(name)
+    return _current_theme
+
+
+def register_theme(theme: Theme, *, replace_existing: bool = False) -> Theme:
+    if theme.name in THEMES and not replace_existing:
+        raise ValueError(f"Theme {theme.name!r} already exists")
+    THEMES[theme.name] = theme
+    return theme
+
+
+def theme_names() -> list[str]:
+    return sorted(THEMES)
+
+
+def theme_from_mapping(name: str, mapping: Mapping[str, ColorLike]) -> Theme:
+    base = Theme(name)
+    valid = {field: value for field, value in mapping.items() if field in base.as_dict()}
+    return base.with_values(**valid)

curint-0.1.2.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 curint contributors
+
+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.

curint-0.1.2.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.1
+Name: curint
+Version: 0.1.2
+Summary: Colorful terminal output toolkit
+Author: corotosh
+License: MIT
+Keywords: terminal,colors,rich,ansi,gradient,animation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: colorama
+Requires-Dist: termcolor
+Requires-Dist: skytext
+Requires-Dist: rich
+
+curint is a Python library for colorful terminal output. It provides styled text, RGB gradients, rainbow text, themed console helpers, Rich panels and tables, status messages, prompts, logging, spinners, progress bars, and lightweight text animations.
+
+## Features
+
+- True-color foreground and background styling.
+- Gradient, palette, and rainbow text.
+- Built-in themes such as `default`, `sunset`, `ocean`, `dracula`, and `forest`.
+- Rich-backed panels, tables, trees, rules, Markdown, and JSON output.
+- Status helpers: `success()`, `error()`, `warning()`, `info()`, and `debug()`.
+- Simple prompts: `ask()`, `confirm()`, and `choose()`.
+- Spinners, progress bars, and iterable tracking.
+- Text effects: typewriter, wave, bounce, glitch, and shimmer.
+- A colorful `logging.Handler` for terminal applications.
+
+## Quick start
+
+```python
+from curint import SpectraConsole, Spinner, progress_bar, success
+
+console = SpectraConsole(theme="sunset")
+console.banner("curint")
+console.gradient("Gradient text with a theme", bold=True)
+console.rainbow("Rainbow output", bold=True)
+console.panel("Useful for build scripts, demos, and terminal applications.", title="Hello")
+
+with Spinner("Working"):
+    import time
+    time.sleep(0.5)
+
+progress_bar(25, "Finishing", delay=0.01)
+success("Done")
+```
+
+## Text helpers
+
+```python
+from curint import gradient_text, highlight, palette_text, rainbow_text, style_text
+
+print(style_text("bold cyan", fg="cyan", bold=True))
+print(gradient_text("sunset gradient", "#ff5e62", "#ffd166"))
+print(rainbow_text("rainbow"))
+print(palette_text("neon", "neon"))
+print(highlight("ship the package", "ship"))
+```
+
+## Console helpers
+
+```python
+from curint import SpectraConsole
+
+console = SpectraConsole(theme="ocean")
+console.banner("release")
+console.rule("checks")
+console.panel("All systems ready", title="Status")
+console.table(
+    [
+        {"Check": "tests", "Result": "passed"},
+        {"Check": "build", "Result": "passed"},
+    ],
+    title="Summary",
+)
+console.tree("package", {"dist": ["sdist", "wheel"], "docs": ["README"]})
+console.markdown("**Markdown** rendering via Rich")
+console.json({"ok": True, "version": "0.1.2"})
+```
+
+## Themes
+
+```python
+from curint import Theme, register_theme, theme_names, use_theme
+
+register_theme(
+    Theme(
+        name="brand",
+        primary="#7c3aed",
+        secondary="#06b6d4",
+        accent="#f59e0b",
+    )
+)
+
+console = use_theme("brand")
+console.gradient("Custom brand theme")
+print(theme_names())
+```
+
+## Animations
+
+```python
+from curint import bounce, glitch, shimmer, typewriter, wave
+
+typewriter("Typed output", delay=0.03)
+wave("wave text")
+bounce("bounce text")
+glitch("glitch text")
+shimmer("shimmer text")
+```
+
+For tests, use frame helpers that return strings instead of printing:
+
+```python
+from curint import glitch_frames, wave_frames
+
+frames = wave_frames("abc", frames=3)
+assert len(frames) == 3
+assert glitch_frames("abc", frames=2)
+```
+
+## Progress and spinners
+
+```python
+from curint import Spinner, progress_bar, rich_status, track_iter
+
+with Spinner("Uploading"):
+    import time
+    time.sleep(0.5)
+
+progress_bar(50, "Building", delay=0.01)
+
+with rich_status("Indexing"):
+    pass
+
+for item in track_iter(range(10), "Processing"):
+    pass
+```
+
+## Logging
+
+```python
+from curint import configure_logging
+
+logger = configure_logging("INFO", logger_name="curint-demo")
+logger.info("Colorful logging is ready")
+```
+
+## Prompts
+
+```python
+from curint import ask, choose, confirm
+
+name = ask("Project name", default="demo")
+color = choose("Theme", ["sunset", "ocean", "dracula"], default="ocean")
+ready = confirm("Continue?", default=True)
+```
+
+## License
+
+MIT License.

curint-0.1.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+curint/__init__.py,sha256=V1nnIV9-Tiehl6rPZoRrGknsd25oNHIP9ivXHw255Kw,2027
+curint/_compat.py,sha256=REIu4qTuEZ6dGoqJdySNqijCrKSTvh6BLqEP2zkQJmc,1620
+curint/animations.py,sha256=Lx_7ULdWY9HuVH2PinX8m3xnwm57g4MaBlzk5mVsGqY,3859
+curint/colors.py,sha256=-hwmkYt0EWRZHVr157jxXMeu74AlbhHSHHtU97J59Pc,4935
+curint/console.py,sha256=3vDvw1A03kiAvdoOdWC1FB84gVGb-NcJd_11au-8iwE,5413
+curint/logging.py,sha256=vAtAqZpLUh9h6qyzAwAORtA0R5jAzCIvQfUM0OLUPy4,1640
+curint/progress.py,sha256=ElqEf5MjWb4AamTR8jkGn1e1hf9JvtvjjVpCA9KRM_g,3289
+curint/prompt.py,sha256=0OLWL228ZOGqehCpy58hCYH79fVnN2IsB8i_ui5Zv0A,1268
+curint/text.py,sha256=Osfs5ybGtnnyBf5sQ8pLiDsHUSs6K6uQO3Dyhs-PIYc,5321
+curint/theme.py,sha256=4g0mvtWYo9_JqXRhJVk1dw9RSwYP9I3BMXyXceJyMOQ,3063
+curint-0.1.2.dist-info/LICENSE,sha256=5Ai5gNurXlg9oUX2qebY4Uw1XBvkB13Eabp5xsBBgYg,1076
+curint-0.1.2.dist-info/METADATA,sha256=dNe3JfxTXEJSBV4qFriFSnRg0qP1Shu3BuDfEvxdjnk,4600
+curint-0.1.2.dist-info/WHEEL,sha256=51RkbunBAw4BWsgaQWTpPhg4Diwp3c9P5iaLk67Hdtg,92
+curint-0.1.2.dist-info/top_level.txt,sha256=-rNbEsJbMaVg0mNvGg7mNd6mGsDRvOpzDEKR7XodMUM,7
+curint-0.1.2.dist-info/RECORD,,

curint-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.47.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

curint-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+curint