tailr 1.0.0__tar.gz

tailr-1.0.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,121 @@
+<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/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tailr"
+version = "1.0.0"
+description = "Colorized live log viewer for the terminal. Zero dependencies."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "dsk-dev-ai" }]
+keywords = ["log", "tail", "color", "terminal", "cli", "devtools", "tui"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Logging",
+    "Topic :: Terminals",
+    "Topic :: Utilities",
+]
+
+[project.scripts]
+tailr = "tailr.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/dsk-dev-ai/tailr"
+Source = "https://github.com/dsk-dev-ai/tailr"
+Issues = "https://github.com/dsk-dev-ai/tailr/issues"
+Funding = "https://github.com/sponsors/dsk-dev-ai"
+
+[tool.setuptools]
+packages = ["tailr"]

tailr-1.0.0/setup.cfg

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

tailr-1.0.0/tailr/__init__.py

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

tailr-1.0.0/tailr/__main__.py

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

tailr-1.0.0/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-1.0.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/tailr.egg-info/PKG-INFO

@@ -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/tailr.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+tailr/__init__.py
+tailr/__main__.py
+tailr/cli.py
+tailr/core.py
+tailr.egg-info/PKG-INFO
+tailr.egg-info/SOURCES.txt
+tailr.egg-info/dependency_links.txt
+tailr.egg-info/entry_points.txt
+tailr.egg-info/top_level.txt
+tests/test_tailr.py

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

@@ -0,0 +1 @@
+

tailr-1.0.0/tailr.egg-info/entry_points.txt

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

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

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

tailr-1.0.0/tests/test_tailr.py

@@ -0,0 +1,137 @@
+import io
+import sys
+
+import pytest
+
+import tailr.core as core
+from tailr.core import (
+    _level_color,
+    _seek_tail,
+    colorize,
+    follow_stdin,
+    tail_file,
+)
+
+
+SAMPLE = [
+    "2024-01-02 03:04:05 INFO  starting service",
+    "2024-01-02 03:04:06 DEBUG loading config",
+    "2024-01-02 03:04:07 ERROR failed to connect",
+    "2024-01-02 03:04:08 WARN retrying in 5s",
+]
+
+
+@pytest.fixture(autouse=True)
+def no_color(monkeypatch):
+    core.FORCE_COLOR = False
+    core.NO_COLOR = True
+
+
+@pytest.fixture
+def log_file(tmp_path):
+    p = tmp_path / "sample.log"
+    p.write_text("\n".join(SAMPLE) + "\n")
+    return p
+
+
+def test_level_color_known_and_unknown():
+    assert _level_color("INFO") == "\033[38;5;39m"
+    assert _level_color("ERROR") == "\033[38;5;196m"
+    assert _level_color("NOPE") == "\033[38;5;248m"
+
+
+def test_colorize_timestamp_highlighted():
+    out = colorize("2024-01-02 03:04:05 INFO hello")
+    assert "\033[38;5;240m" in out
+    assert "INFO" in out
+
+
+def test_colorize_level_colored():
+    out = colorize("INFO hello")
+    assert _level_color("INFO") in out
+
+
+def test_colorize_error_keyword_bold():
+    out = colorize("2024-01-02 03:04:05 ERROR failed to connect")
+    assert _level_color("ERROR") in out
+    assert "\033[1m" in out
+
+
+def test_colorize_plain_message_kept():
+    out = colorize("just a plain message")
+    assert "just a plain message" in out
+
+
+def test_colorize_empty():
+    assert colorize("") == ""
+    assert colorize("\n") == "\n"
+
+
+def test_seek_tail_last_n_lines():
+    data = io.TextIOWrapper(io.BytesIO("\n".join(SAMPLE).encode("utf-8")))
+    _seek_tail(data, 2)
+    assert data.readlines() == [
+        "2024-01-02 03:04:07 ERROR failed to connect\n",
+        "2024-01-02 03:04:08 WARN retrying in 5s",
+    ]
+
+
+def test_tail_file_returns_last_lines(log_file):
+    stream = io.StringIO()
+    emitted = tail_file(str(log_file), follow=False, lines=2, stream=stream)
+    assert emitted == SAMPLE[-2:]
+
+
+def test_tail_file_grep_filter(log_file):
+    stream = io.StringIO()
+    emitted = tail_file(str(log_file), follow=False, lines=10,
+                        grep="ERROR|WARN", stream=stream)
+    assert emitted == [
+        "2024-01-02 03:04:07 ERROR failed to connect",
+        "2024-01-02 03:04:08 WARN retrying in 5s",
+    ]
+
+
+def test_tail_file_level_filter(log_file):
+    stream = io.StringIO()
+    emitted = tail_file(str(log_file), follow=False, lines=10,
+                        level="ERROR", stream=stream)
+    assert emitted == ["2024-01-02 03:04:07 ERROR failed to connect"]
+
+
+def test_tail_file_no_color(log_file):
+    core.FORCE_COLOR = False
+    core.NO_COLOR = True
+    stream = io.StringIO()
+    tail_file(str(log_file), follow=False, lines=10, stream=stream)
+    assert "\033" not in stream.getvalue()
+
+
+def test_follow_stdin(monkeypatch):
+    monkeypatch.setattr(core.sys, "stdin", io.StringIO("INFO a\nERROR boom\n"))
+    stream = io.StringIO()
+    lines = follow_stdin(stream=stream)
+    assert lines == ["INFO a", "ERROR boom"]
+
+
+def test_follow_stdin_grep(monkeypatch):
+    monkeypatch.setattr(core.sys, "stdin", io.StringIO("INFO a\nERROR boom\nWARN c\n"))
+    stream = io.StringIO()
+    lines = follow_stdin(grep="ERROR|WARN", stream=stream)
+    assert lines == ["ERROR boom", "WARN c"]
+
+
+def test_missing_file_returns_error(cli_main, capsys):
+    rc = cli_main(["-n", "10", "no_such_file.log"])
+    assert rc == 1
+
+
+def test_mixing_stdin_and_files(cli_main):
+    rc = cli_main(["-", "somefile"])
+    assert rc == 1
+
+
+@pytest.fixture
+def cli_main():
+    from tailr.cli import main
+    return main