tailr 1.0.0__py3-none-any.whl

tailr/__init__.py

@@ -0,0 +1,3 @@
+"""tailr - colorized live log viewer."""
+
+__version__ = "1.0.0"

tailr/__main__.py

@@ -0,0 +1,4 @@
+from tailr.cli import main
+
+if __name__ == "__main__":
+    main()

tailr/cli.py

@@ -0,0 +1,48 @@
+"""tailr command-line interface."""
+
+import argparse
+import sys
+
+from tailr import __version__
+from tailr.core import follow_stdin, tail_file
+
+
+def build_parser():
+    p = argparse.ArgumentParser(
+        prog="tailr",
+        description="Colorized live log viewer. Tail files or piped stdin with "
+                    "regex level and keyword highlighting. Zero dependencies.",
+    )
+    p.add_argument("path", nargs="*", default=["-"],
+                   help="file to tail, or '-' for stdin (default)")
+    p.add_argument("-f", "--follow", action="store_true",
+                   help="keep following appended lines (like tail -f)")
+    p.add_argument("-n", "--lines", type=int, default=10,
+                   help="number of lines to show from the end (default 10)")
+    p.add_argument("-g", "--grep", help="only show lines matching this regex")
+    p.add_argument("-l", "--level", help="only show lines with this log level "
+                                         "(e.g. ERROR, INFO, WARN)")
+    p.add_argument("--version", action="version", version=f"tailr {__version__}")
+    return p
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    paths = args.path
+    if any(p == "-" for p in paths) and len(paths) > 1:
+        print("tailr: mixing stdin ('-') with files is not supported", file=sys.stderr)
+        return 1
+    if paths == ["-"]:
+        lines = follow_stdin(grep=args.grep, level=args.level)
+    else:
+        for path in paths:
+            try:
+                tail_file(path, follow=args.follow, lines=args.lines,
+                          grep=args.grep, level=args.level)
+            except FileNotFoundError:
+                print(f"tailr: no such file: {path}", file=sys.stderr)
+                return 1
+            except IsADirectoryError:
+                print(f"tailr: is a directory: {path}", file=sys.stderr)
+                return 1
+    return 0

tailr/core.py

@@ -0,0 +1,173 @@
+"""tailr - colorized live log viewer.
+
+Tail files (or stdin) with regex-driven level and keyword highlighting.
+Zero dependencies.
+"""
+
+import os
+import re
+import sys
+import time
+
+LEVELS = {
+    "TRACE": "\033[38;5;245m",
+    "DEBUG": "\033[38;5;244m",
+    "INFO": "\033[38;5;39m",
+    "WARN": "\033[38;5;214m",
+    "WARNING": "\033[38;5;214m",
+    "ERROR": "\033[38;5;196m",
+    "FATAL": "\033[38;5;201m",
+    "CRITICAL": "\033[38;5;201m",
+}
+RESET = "\033[0m"
+
+_TIMESTAMP = re.compile(
+    r"(?P<ts>\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[.,]\d+)?(?:Z|[+-]\d{2}:?\d{2})?)"
+)
+_ISO_TIME = re.compile(r"\d{2}:\d{2}:\d{2}(?:[.,]\d+)?")
+_KEYWORDS_TO_HIGHLIGHT = ("error", "fail", "exception", "traceback", "panic", "fatal")
+
+_LEVEL_MATCH = re.compile(
+    r"\b(" + "|".join(sorted(LEVELS.keys(), key=len, reverse=True)) + r")\b"
+)
+
+NO_COLOR = os.environ.get("NO_COLOR") is not None
+FORCE_COLOR = os.environ.get("FORCE_COLOR") not in (None, "", "0")
+
+
+def use_color():
+    if NO_COLOR:
+        return False
+    if FORCE_COLOR:
+        return True
+    return sys.stdout.isatty()
+
+
+def _level_color(token):
+    key = token.upper()
+    return LEVELS.get(key, "\033[38;5;248m")
+
+
+def colorize(line):
+    """Apply ANSI color to a single log line (best-effort, safe)."""
+    if not line:
+        return line
+    work = line
+    m = _TIMESTAMP.search(work)
+    color = "\033[38;5;240m"
+    if m:
+        work = work[: m.start()] + color + work[m.start() : m.end()] + RESET + work[m.end():]
+    else:
+        time_m = _ISO_TIME.search(work)
+        if time_m:
+            work = work[: time_m.start()] + color + work[time_m.start() : time_m.end()] + RESET + work[time_m.end():]
+    work = _highlight_level_and_keywords(work)
+    if any(k in line.lower() for k in _KEYWORDS_TO_HIGHLIGHT):
+        work = _highlight_keywords(work)
+    return work
+
+
+def _highlight_level_and_keywords(line):
+    out = []
+    pos = 0
+    for lm in _LEVEL_MATCH.finditer(line):
+        out.append(line[pos : lm.start()])
+        out.append(_level_color(lm.group(1)) + lm.group(1) + RESET)
+        pos = lm.end()
+    out.append(line[pos:])
+    return "".join(out)
+
+
+def _highlight_keywords(line):
+    def sub(m):
+        return "\033[1m\033[38;5;203m" + m.group(0) + RESET
+
+    return re.sub(r"\b(error|fail(?:ure|ed)?|exception|traceback|panic)\b",
+                  sub, line, flags=re.IGNORECASE)
+
+
+def tail_file(path, follow=False, lines=10, grep=None, level=None, stream=None):
+    """Tail a file, emitting colorized lines to ``stream`` (default stdout).
+
+    Returns the list of emitted raw lines (uncolored) for testing.
+    """
+    if stream is None:
+        stream = sys.stdout
+    use_colors = use_color()
+    grep_re = re.compile(grep, re.IGNORECASE) if grep else None
+    level_re = re.compile(r"\b" + re.escape(level) + r"\b", re.IGNORECASE) if level else None
+
+    with open(path, "r", errors="replace") as fh:
+        if not follow:
+            _seek_tail(fh, lines)
+        emitted = []
+        while True:
+            read_lines = fh.readlines()
+            for raw_line in read_lines:
+                line = raw_line.rstrip("\n")
+                if level_re and not level_re.search(line):
+                    continue
+                if grep_re and not grep_re.search(line):
+                    continue
+                out = colorize(line) if use_colors else line
+                stream.write(out + "\n")
+                emitted.append(line)
+            stream.flush()
+            if not follow:
+                return emitted
+            time.sleep(0.1)
+            if not fh.fp:
+                return emitted
+
+
+def _seek_tail(fh, lines):
+    """Position ``fh`` so that readlines() returns exactly the last ``lines`` lines."""
+    if lines <= 0:
+        fh.seek(0, 2)
+        return
+    fh.seek(0, 2)
+    size = fh.tell()
+    if size == 0:
+        fh.seek(0)
+        return
+    fh.seek(size - 1)
+    last = fh.read(1)
+    fh.seek(0)
+    newlines = 0
+    while True:
+        data = fh.read(64 * 1024)
+        if not data:
+            break
+        newlines += data.count("\n")
+    total_lines = newlines + (1 if last != "\n" else 0)
+    to_drop = total_lines - lines
+    if to_drop <= 0:
+        fh.seek(0)
+        return
+    fh.seek(0)
+    for _ in range(to_drop):
+        if not fh.readline():
+            break
+
+
+def follow_stdin(grep=None, level=None, stream=None):
+    """Tail stdin (for piped input), emitting colorized lines."""
+    if stream is None:
+        stream = sys.stdout
+    use_colors = use_color()
+    grep_re = re.compile(grep, re.IGNORECASE) if grep else None
+    level_re = re.compile(r"\b" + re.escape(level) + r"\b", re.IGNORECASE) if level else None
+    lines = []
+    try:
+        for raw_line in sys.stdin:
+            line = raw_line.rstrip("\n")
+            if level_re and not level_re.search(line):
+                continue
+            if grep_re and not grep_re.search(line):
+                continue
+            out = colorize(line) if use_colors else line
+            stream.write(out + "\n")
+            lines.append(line)
+    except KeyboardInterrupt:
+        pass
+    return lines

tailr-1.0.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: tailr
+Version: 1.0.0
+Summary: Colorized live log viewer for the terminal. Zero dependencies.
+Author: dsk-dev-ai
+License: MIT
+Project-URL: Homepage, https://github.com/dsk-dev-ai/tailr
+Project-URL: Source, https://github.com/dsk-dev-ai/tailr
+Project-URL: Issues, https://github.com/dsk-dev-ai/tailr/issues
+Project-URL: Funding, https://github.com/sponsors/dsk-dev-ai
+Keywords: log,tail,color,terminal,cli,devtools,tui
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: System :: Logging
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<div align="center">
+
+# 🎨 tailr
+
+**Colorized live log viewer for your terminal.**
+
+Tail files or piped stdin with automatic log-level and keyword highlighting.
+Zero dependencies. Works in Python 3.8+.
+
+[![PyPI](https://img.shields.io/pypi/v/tailr?color=blue&logo=pypi&logoColor=white)](https://pypi.org/project/tailr/)
+[![Python](https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)](#)
+[![License](https://img.shields.io/badge/license-MIT-green)](#)
+[![Docker](https://img.shields.io/badge/docker-ghcr.io%2Fdsk--dev--ai%2Ftailr-blue?logo=docker)](https://github.com/dsk-dev-ai/tailr/pkgs/container/tailr)
+
+</div>
+
+---
+
+## Why tailr?
+
+Logs are noisy. `tailr` makes them *readable* at a glance:
+
+- **Level highlighting** — `INFO`, `WARN`, `ERROR`, `FATAL`, `DEBUG`, `TRACE` get distinct colors.
+- **Keyword highlighting** — `error`, `failed`, `exception`, `traceback`, `panic` pop in bright red.
+- **Timestamp coloring** — dates and times are dimmed so the signal stands out.
+- **Live follow** — watch logs grow in real time, just like `tail -f`.
+- **Filter on the fly** — regex grep, or filter by log level.
+- **Zero dependencies** — pure Python stdlib. No install drama, no bloat.
+
+## Install
+
+```bash
+pip install tailr
+```
+
+Or run without installing:
+
+```bash
+pipx run tailr --help
+```
+
+Via Docker:
+
+```bash
+docker run --rm ghcr.io/dsk-dev-ai/tailr --help
+```
+
+## Usage
+
+```bash
+# Colorize a log file (last 10 lines)
+tailr app.log
+
+# Follow a growing log live
+tailr -f app.log
+
+# Follow with more history
+tailr -f -n 200 app.log
+
+# Filter by log level
+tailr -l ERROR app.log
+
+# Grep with a regex, live
+tailr -f -g "kafka|redis" app.log
+
+# Pipe anything in
+docker logs -f app | tailr
+kubectl logs -f pod | tailr
+journalctl -f | tailr -l WARN
+```
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `-f, --follow` | Keep tailing appended lines (like `tail -f`) |
+| `-n, --lines N` | Show N lines from the end (default 10) |
+| `-g, --grep REGEX` | Only show lines matching a regex |
+| `-l, --level LVL` | Only show lines with this level (`ERROR`, `WARN`, …) |
+| `--version` | Print version |
+
+### Colors
+
+```
+INFO      -> blue
+DEBUG     -> gray
+WARN      -> orange
+ERROR     -> red
+FATAL     -> magenta
+TRACE     -> gray
+keywords  -> bright red + bold
+timestamps-> dim
+```
+
+Set `NO_COLOR=1` to disable colorization, or `FORCE_COLOR=1` to force it.
+
+## How it works
+
+`tailr` streams lines and applies a lightweight ANSI colorizer powered by a few
+small regexes — no external parsing libs, no heuristics beyond the log shape.
+It respects `isatty()` to avoid spewing escape codes into pipelines.
+
+## Tests
+
+```bash
+python -m pytest
+```
+
+Tested on Python 3.8–3.12 via GitHub Actions.
+
+## Sponsor
+
+Enjoy `tailr`? Keep it free and dependency-free by [becoming a sponsor](https://github.com/sponsors/dsk-dev-ai) on GitHub 💜.
+
+---
+
+<div align="center">
+
+**tailr** · Colorized logs you can actually read.
+
+</div>

tailr-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+tailr/__init__.py,sha256=srf3GG3A4yi8SvG34RD6SHyof9rXs_XCcHiafDwCjBs,64
+tailr/__main__.py,sha256=Ct7BGwm8nmXazokS5S7W6ixL5unBRJ_6LQ73i770kPc,66
+tailr/cli.py,sha256=37CBw9nfEIZpqphAP2kAYeUd443VTGJjeLk54Af8BYs,1897
+tailr/core.py,sha256=nuIADej11XnuvXX81vs6aLmFEZG9AE1cOxcfsjxWVxs,5102
+tailr-1.0.0.dist-info/licenses/LICENSE,sha256=EAxljeOlydi0CA5dhf2z72wEjAtq_9Ig44QyLQ7XWLM,1067
+tailr-1.0.0.dist-info/METADATA,sha256=fGkG8vhquGjmNGJwTSrN-uFMtuM3yyXy8smgm7SwIgI,4157
+tailr-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+tailr-1.0.0.dist-info/entry_points.txt,sha256=NgeMHOacNGnmazJ_bCyHP-Nt9LgvrZwIXoepKo3YASY,41
+tailr-1.0.0.dist-info/top_level.txt,sha256=JMHg3kox6k0dNoy2fmdrDUAGuOElFxJF4DuVc3osNLs,6
+tailr-1.0.0.dist-info/RECORD,,

tailr-1.0.0.dist-info/WHEEL

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

tailr-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tailr = tailr.cli:main

tailr-1.0.0.dist-info/licenses/LICENSE

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

tailr-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tailr