eolnorm 0.2.0__py3-none-any.whl

eolnorm/__init__.py

@@ -0,0 +1,26 @@
+"""Detect, normalize and count line endings in text, bytes, streams and files."""
+
+from __future__ import annotations
+
+from ._binary import is_binary
+from ._eol import counts, detect, normalize
+from ._files import FileReport, normalize_file, scan_file
+from ._kinds import Breaks, Detected, Kind, Style
+from ._stream import Normalizer
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "Breaks",
+    "Detected",
+    "FileReport",
+    "Kind",
+    "Normalizer",
+    "Style",
+    "counts",
+    "detect",
+    "is_binary",
+    "normalize",
+    "normalize_file",
+    "scan_file",
+]

eolnorm/__main__.py

@@ -0,0 +1,7 @@
+"""Run the command line tool with ``python -m eolnorm``."""
+
+from __future__ import annotations
+
+from ._cli import main
+
+raise SystemExit(main())

eolnorm/_atomic.py

@@ -0,0 +1,58 @@
+"""Replace a file's contents atomically: readers see the old bytes or the new, never half."""
+
+from __future__ import annotations
+
+import contextlib
+import errno
+import os
+import shutil
+import stat
+import tempfile
+
+
+def write_atomic(path: str, data: bytes) -> None:
+    # Rewrite the target of a symlink, not the link itself, and stay on its filesystem so
+    # the final rename cannot fall back to a copy.
+    real = os.path.realpath(path)
+    folder = os.path.dirname(real)
+    # Windows refuses to replace a read-only file while POSIX would replace it silently;
+    # refuse everywhere so the outcome does not depend on the system.
+    if not os.access(real, os.W_OK):
+        raise PermissionError(errno.EACCES, "file is read-only", path)
+    fd, temporary = tempfile.mkstemp(dir=folder, prefix=".eolnorm-", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "wb") as handle:
+            handle.write(data)
+            handle.flush()
+            os.fsync(handle.fileno())
+        shutil.copymode(real, temporary)
+        os.replace(temporary, real)
+    except BaseException:
+        _discard(temporary)
+        raise
+    _sync_folder(folder)
+
+
+def _discard(temporary: str) -> None:
+    # copymode may have made the temporary file read-only, which blocks deleting it on
+    # Windows.
+    with contextlib.suppress(OSError):
+        os.chmod(temporary, stat.S_IWRITE | stat.S_IREAD)
+    with contextlib.suppress(OSError):
+        os.unlink(temporary)
+
+
+def _sync_folder(folder: str) -> None:
+    # On POSIX the rename is durable only once the directory entry is flushed too.
+    if not hasattr(os, "O_DIRECTORY"):
+        return
+    try:
+        descriptor = os.open(folder, os.O_RDONLY | os.O_DIRECTORY)
+    except OSError:
+        return
+    try:
+        os.fsync(descriptor)
+    except OSError:
+        pass
+    finally:
+        os.close(descriptor)

eolnorm/_binary.py

@@ -0,0 +1,45 @@
+"""Tell text from binary the way git does, and recognise byte order marks."""
+
+from __future__ import annotations
+
+import codecs
+
+# Git counts DEL and the control bytes as non-printable, except BS, HT, ESC and FF (and
+# CR and LF, which are neutral). Bytes from 0x80 up count as printable.
+_NONPRINTABLE = bytes(b for b in range(0x20) if b not in b"\b\t\n\r\x1b\x0c") + b"\x7f"
+
+# Longest first: the UTF-32 LE mark starts with the UTF-16 LE one.
+BOMS: tuple[tuple[bytes, str], ...] = (
+    (codecs.BOM_UTF32_LE, "utf-32-le"),
+    (codecs.BOM_UTF32_BE, "utf-32-be"),
+    (codecs.BOM_UTF8, "utf-8"),
+    (codecs.BOM_UTF16_LE, "utf-16-le"),
+    (codecs.BOM_UTF16_BE, "utf-16-be"),
+)
+
+
+def is_binary(data: bytes) -> bool:
+    """Apply git's text=auto statistics: True when the bytes look binary.
+
+    A NUL byte, or fewer than 128 printable bytes for each non-printable one, means
+    binary. CR and LF are neutral, BS, HT, ESC and FF are printable, DEL and the other
+    control bytes are not, and a Ctrl-Z as the very last byte is not held against the
+    data. Unlike git, a lone CR alone does not make the data binary.
+    """
+    if not isinstance(data, bytes):
+        raise TypeError(f"expected bytes, got {type(data).__name__}")
+    if b"\x00" in data:
+        return True
+    nonprintable = len(data) - len(data.translate(None, _NONPRINTABLE))
+    printable = len(data) - nonprintable - data.count(b"\n") - data.count(b"\r")
+    if data.endswith(b"\x1a"):
+        nonprintable -= 1
+    return (printable >> 7) < nonprintable
+
+
+def sniff_bom(data: bytes) -> tuple[bytes, str] | None:
+    """Return the byte order mark at the start of ``data`` and its codec, if any."""
+    for bom, codec in BOMS:
+        if data.startswith(bom):
+            return bom, codec
+    return None

eolnorm/_cli.py

@@ -0,0 +1,107 @@
+"""Command line tool: report line endings, check them, or fix them in place."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+
+from ._content import decode, fix
+from ._files import FileReport, normalize_file, scan_file
+
+
+def _parser() -> argparse.ArgumentParser:
+    from . import __version__
+
+    parser = argparse.ArgumentParser(
+        prog="eolnorm",
+        description="Report line endings, or convert them with --to. "
+        "Use - to filter standard input to standard output.",
+    )
+    parser.add_argument("paths", nargs="+", metavar="PATH")
+    parser.add_argument("--to", choices=["lf", "crlf", "cr"], help="convert to this style")
+    parser.add_argument(
+        "--check", action="store_true", help="with --to, change nothing; exit 1 if a file would"
+    )
+    parser.add_argument(
+        "--keep-lone-cr", action="store_true", help="leave a CR not followed by LF alone"
+    )
+    parser.add_argument("--breaks", choices=["ascii", "unicode", "splitlines"], default="ascii")
+    parser.add_argument(
+        "--encoding", help="decode with this codec (binary files are still skipped)"
+    )
+    parser.add_argument("--version", action="version", version=f"eolnorm {__version__}")
+    return parser
+
+
+def _describe(report: FileReport) -> str:
+    if report.binary:
+        return f"{report.path}: binary"
+    present = ", ".join(f"{name}={count}" for name, count in report.counts.items() if count)
+    return f"{report.path}: {report.detected}" + (f" ({present})" if present else "")
+
+
+def _filter(args: argparse.Namespace) -> None:
+    # The same rules as for files: a byte order mark picks and keeps the codec, binary
+    # input passes through untouched.
+    content = decode(sys.stdin.buffer.read(), args.breaks, args.encoding)
+    if content.body is None:
+        print("eolnorm: -: binary, passed through unchanged", file=sys.stderr)
+    sys.stdout.buffer.write(fix(content, args.to, args.breaks, args.keep_lone_cr))
+    sys.stdout.flush()
+
+
+def _readable(stream: object) -> None:
+    # A path the console cannot encode must not turn a finished fix into a reported failure.
+    reconfigure = getattr(stream, "reconfigure", None)
+    if reconfigure is not None:
+        reconfigure(errors="backslashreplace")
+
+
+def _one(path: str, args: argparse.Namespace) -> bool:
+    """Handle one path; return True when it was or would be changed."""
+    if args.to is None:
+        print(_describe(scan_file(path, breaks=args.breaks, encoding=args.encoding)))
+        return False
+    report = normalize_file(
+        path,
+        args.to,
+        breaks=args.breaks,
+        keep_lone_cr=args.keep_lone_cr,
+        encoding=args.encoding,
+        dry_run=args.check,
+    )
+    if report.binary:
+        print(f"skipped {path}: binary")
+    elif report.changed:
+        print(f"{'would fix' if args.check else 'fixed'} {path}")
+    return report.changed
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run the tool. Exit 0 on success, 1 when --check finds work, 2 on bad input."""
+    args = _parser().parse_args(argv)
+    for flag, used in (("--check", args.check), ("--keep-lone-cr", args.keep_lone_cr)):
+        if used and args.to is None:
+            _parser().error(f"{flag} needs --to")
+    _readable(sys.stdout)
+    _readable(sys.stderr)
+    if "-" in args.paths:
+        if args.to is None or args.check or len(args.paths) > 1:
+            _parser().error("- filters standard input and needs --to, alone, without --check")
+        try:
+            _filter(args)
+        except ValueError as error:
+            print(f"eolnorm: -: {error}", file=sys.stderr)
+            return 2
+        return 0
+    failed = pending = False
+    for path in args.paths:
+        try:
+            pending |= _one(path, args)
+        except (OSError, UnicodeError, ValueError) as error:
+            print(f"eolnorm: {path}: {error}", file=sys.stderr)
+            failed = True
+    if failed:
+        return 2
+    return 1 if pending and args.check else 0

eolnorm/_content.py

@@ -0,0 +1,90 @@
+"""Turn raw bytes into something to normalize (and back), honouring marks and codecs."""
+
+from __future__ import annotations
+
+import codecs
+from dataclasses import dataclass
+
+from ._binary import BOMS, is_binary, sniff_bom
+from ._eol import normalize
+from ._kinds import Breaks, Style
+
+# Codec names (as codecs.lookup spells them) that agree with each byte order mark.
+_AGREES = {
+    "utf-8": {"utf-8", "utf-8-sig"},
+    "utf-16-le": {"utf-16", "utf-16-le"},
+    "utf-16-be": {"utf-16", "utf-16-be"},
+    "utf-32-le": {"utf-32", "utf-32-le"},
+    "utf-32-be": {"utf-32", "utf-32-be"},
+}
+_SAMPLE = "\r\n a"
+
+
+@dataclass(frozen=True)
+class Content:
+    raw: bytes
+    prefix: bytes
+    body: str | bytes | None  # None: binary, left alone
+    codec: str | None
+
+
+def _codec(encoding: object) -> str:
+    if not isinstance(encoding, str):
+        raise TypeError(f"encoding must be a str or None, got {type(encoding).__name__}")
+    try:
+        return codecs.lookup(encoding).name
+    except LookupError:
+        raise ValueError(f"unknown encoding: {encoding!r}") from None
+
+
+def _mark(raw: bytes, wanted: str | None) -> tuple[bytes, str] | None:
+    if wanted is None:
+        return sniff_bom(raw)
+    # A named codec only looks for its own marks: "utf-16" data starting with U+0000 is not
+    # UTF-32, and a cp1252 file may start with the bytes of a mark.
+    for bom, codec in BOMS:
+        if wanted in _AGREES[codec] and raw.startswith(bom):
+            return bom, codec
+    return None
+
+
+def _ascii_compatible(codec: str) -> bool:
+    try:
+        return _SAMPLE.encode(codec) == _SAMPLE.encode("ascii")
+    except (UnicodeError, LookupError, TypeError):
+        return False
+
+
+def decode(raw: bytes, breaks: Breaks, encoding: str | None) -> Content:
+    """Split ``raw`` into a kept prefix (a byte order mark) and a body to normalize."""
+    wanted = None if encoding is None else _codec(encoding)
+    found = _mark(raw, wanted)
+    if found is not None:
+        bom, codec = found
+        if codec == "utf-8" and breaks == "ascii":
+            return Content(raw, bom, raw[len(bom) :], codec)
+        return Content(raw, bom, raw[len(bom) :].decode(codec), codec)
+    if wanted in ("utf-16", "utf-32"):
+        raise ValueError(f"no byte order mark: name the byte order, {wanted}-le or {wanted}-be")
+    if wanted is not None:
+        # Without a mark utf-8-sig decodes like utf-8, but encoding with it would add one.
+        codec = "utf-8" if wanted == "utf-8-sig" else wanted
+        if _ascii_compatible(codec) and is_binary(raw):
+            return Content(raw, b"", None, None)
+        return Content(raw, b"", raw.decode(codec), codec)
+    if is_binary(raw):
+        return Content(raw, b"", None, None)
+    if breaks == "ascii":
+        return Content(raw, b"", raw, None)
+    return Content(raw, b"", raw.decode("utf-8"), "utf-8")
+
+
+def fix(content: Content, to: Style, breaks: Breaks, keep_lone_cr: bool) -> bytes:
+    """The normalized bytes, with the same prefix and codec; binary comes back unchanged."""
+    body = content.body
+    if body is None:
+        return content.raw
+    if isinstance(body, bytes):
+        return content.prefix + normalize(body, to, keep_lone_cr=keep_lone_cr)
+    fixed = normalize(body, to, breaks=breaks, keep_lone_cr=keep_lone_cr)
+    return content.prefix + fixed.encode(str(content.codec))

eolnorm/_eol.py

@@ -0,0 +1,83 @@
+"""Detect, normalize and count line endings in text or bytes."""
+
+from __future__ import annotations
+
+from typing import AnyStr, cast
+
+from ._kinds import (
+    BYTES_PATTERN,
+    Breaks,
+    Detected,
+    Style,
+    check_breaks,
+    check_style,
+    kinds,
+    name_of,
+    sequence,
+    text_pattern,
+)
+
+
+def _check(text: object, breaks: object) -> Breaks:
+    checked = check_breaks(breaks)
+    if isinstance(text, bytes):
+        if checked != "ascii":
+            raise ValueError(f"breaks={checked!r} needs decoded text, not bytes")
+    elif not isinstance(text, str):
+        raise TypeError(f"expected str or bytes, got {type(text).__name__}")
+    return checked
+
+
+def counts(text: str | bytes, *, breaks: Breaks = "ascii") -> dict[str, int]:
+    """Count each line ending, treating CRLF as one unit rather than CR plus LF.
+
+    The keys are the kinds of the chosen boundary set, always all present, in a fixed
+    order: ``lf``, ``crlf``, ``cr``, then any others the set adds.
+    """
+    breaks = _check(text, breaks)
+    tally: dict[str, int] = dict.fromkeys(kinds(breaks), 0)
+    if isinstance(text, bytes):
+        for found in BYTES_PATTERN.finditer(text):
+            tally[name_of(found.group().decode("ascii"))] += 1
+    else:
+        for match in text_pattern(breaks).finditer(text):
+            tally[name_of(match.group())] += 1
+    return tally
+
+
+def detected_from(tally: dict[str, int]) -> Detected:
+    present = [name for name, count in tally.items() if count]
+    if not present:
+        return "none"
+    if len(present) == 1:
+        return cast(Detected, present[0])
+    return "mixed"
+
+
+def detect(text: str | bytes, *, breaks: Breaks = "ascii") -> Detected:
+    """Report the line-ending style: the single kind present, "mixed", or "none"."""
+    return detected_from(counts(text, breaks=breaks))
+
+
+def normalize(
+    text: AnyStr, to: Style = "lf", *, breaks: Breaks = "ascii", keep_lone_cr: bool = False
+) -> AnyStr:
+    """Convert every line ending of the boundary set to the chosen style.
+
+    A lone CR is converted too unless ``keep_lone_cr`` is true, which matches what git
+    does for a path with the ``text`` attribute: only a CR that precedes an LF is part of
+    an ending. ``bytes`` in, ``bytes`` out.
+    """
+    breaks = _check(text, breaks)
+    target = sequence(check_style(to))
+    if not isinstance(keep_lone_cr, bool):
+        raise TypeError("keep_lone_cr must be a bool")
+    if isinstance(text, bytes):
+        raw = target.encode("ascii")
+        if keep_lone_cr:
+            return BYTES_PATTERN.sub(lambda m: m.group() if m.group() == b"\r" else raw, text)
+        return BYTES_PATTERN.sub(raw, text)
+    pattern = text_pattern(breaks)
+    if keep_lone_cr:
+        return pattern.sub(lambda m: m.group() if m.group() == "\r" else target, text)
+    return pattern.sub(target, text)

eolnorm/_files.py

@@ -0,0 +1,87 @@
+"""Inspect and normalize files: binary detection, byte order marks, atomic rewrite."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Union
+
+from ._atomic import write_atomic
+from ._content import Content, decode, fix
+from ._eol import counts, detected_from
+from ._kinds import Breaks, Detected, Style, check_breaks, check_style, kinds
+
+StrPath = Union[str, "os.PathLike[str]"]
+
+
+@dataclass(frozen=True)
+class FileReport:
+    """What a file holds and whether normalizing it changed it (or would, in a dry run).
+
+    ``encoding`` names the codec in play: the one a byte order mark or the caller chose, or
+    utf-8 for the Unicode sets. It is None when no codec was involved, which is exact for
+    any ASCII-compatible encoding. For a binary file nothing is counted or changed.
+    """
+
+    path: str
+    binary: bool
+    encoding: str | None
+    bom: bool
+    counts: dict[str, int] = field(hash=False)
+    detected: Detected
+    changed: bool = False
+
+
+def _load(path: StrPath, breaks: Breaks, encoding: str | None) -> Content:
+    return decode(Path(path).read_bytes(), breaks, encoding)
+
+
+def _report(path: StrPath, content: Content, breaks: Breaks, changed: bool) -> FileReport:
+    tally: dict[str, int] = dict.fromkeys(kinds(breaks), 0)
+    if content.body is not None:
+        tally = counts(content.body, breaks=breaks)
+    return FileReport(
+        path=os.fspath(path),
+        binary=content.body is None,
+        encoding=content.codec,
+        bom=bool(content.prefix),
+        counts=tally,
+        detected=detected_from(tally),
+        changed=changed,
+    )
+
+
+def scan_file(
+    path: StrPath, *, breaks: Breaks = "ascii", encoding: str | None = None
+) -> FileReport:
+    """Read a file and report its line endings without writing anything."""
+    breaks = check_breaks(breaks)
+    return _report(path, _load(path, breaks, encoding), breaks, changed=False)
+
+
+def normalize_file(
+    path: StrPath,
+    to: Style = "lf",
+    *,
+    breaks: Breaks = "ascii",
+    keep_lone_cr: bool = False,
+    encoding: str | None = None,
+    dry_run: bool = False,
+) -> FileReport:
+    """Normalize a file in place, atomically, keeping its byte order mark and encoding.
+
+    A binary file is left alone. A file whose bytes would not change is not rewritten.
+    With ``dry_run`` the report says whether it would change and nothing is written. The
+    counts describe the file as it was before.
+    """
+    breaks = check_breaks(breaks)
+    to = check_style(to)
+    if not isinstance(keep_lone_cr, bool):
+        raise TypeError("keep_lone_cr must be a bool")
+    content = _load(path, breaks, encoding)
+    output = fix(content, to, breaks, keep_lone_cr)
+    changed = output != content.raw
+    if changed and not dry_run:
+        write_atomic(os.fspath(path), output)
+    return _report(path, content, breaks, changed=changed)

eolnorm/_kinds.py

@@ -0,0 +1,71 @@
+"""Line-ending kinds, the boundary sets that group them and the patterns that find them."""
+
+from __future__ import annotations
+
+import re
+from typing import Literal
+
+Style = Literal["lf", "crlf", "cr"]
+Kind = Literal["lf", "crlf", "cr", "vt", "ff", "fs", "gs", "rs", "nel", "ls", "ps"]
+Detected = Kind | Literal["mixed", "none"]
+Breaks = Literal["ascii", "unicode", "splitlines"]
+
+# Single-character kinds in report order. CRLF is the only two-character ending.
+_CHARS: dict[str, Kind] = {
+    "\n": "lf",
+    "\r": "cr",
+    "\x0b": "vt",
+    "\x0c": "ff",
+    "\x1c": "fs",
+    "\x1d": "gs",
+    "\x1e": "rs",
+    "\x85": "nel",
+    "\u2028": "ls",
+    "\u2029": "ps",
+}
+# UAX #14: BK (VT, FF, LS, PS), CR, LF and NL are the mandatory breaks. str.splitlines
+# also splits on the three information separators FS, GS and RS.
+_SETS: dict[Breaks, str] = {
+    "ascii": "\n\r",
+    "unicode": "\n\r\x0b\x0c\x85\u2028\u2029",
+    "splitlines": "\n\r\x0b\x0c\x1c\x1d\x1e\x85\u2028\u2029",
+}
+_SEQUENCES: dict[Style, str] = {"lf": "\n", "crlf": "\r\n", "cr": "\r"}
+
+
+def check_breaks(breaks: object) -> Breaks:
+    if not isinstance(breaks, str) or breaks not in _SETS:
+        raise ValueError(f"unknown boundary set: {breaks!r}")
+    return breaks
+
+
+def check_style(to: object) -> Style:
+    if not isinstance(to, str) or to not in _SEQUENCES:
+        raise ValueError(f"unknown style: {to!r}")
+    return to
+
+
+def kinds(breaks: Breaks) -> tuple[Kind, ...]:
+    """The kinds a boundary set recognises: lf, crlf, cr first, then the rest."""
+    names = [_CHARS[char] for char in _SETS[breaks]]
+    return ("lf", "crlf", "cr", *names[2:])
+
+
+def name_of(ending: str) -> Kind:
+    return "crlf" if ending == "\r\n" else _CHARS[ending]
+
+
+def sequence(to: Style) -> str:
+    return _SEQUENCES[to]
+
+
+def _build(chars: str) -> re.Pattern[str]:
+    return re.compile("\r\n|[" + re.escape(chars) + "]")
+
+
+_TEXT_PATTERNS = {breaks: _build(chars) for breaks, chars in _SETS.items()}
+BYTES_PATTERN = re.compile(rb"\r\n|[\r\n]")
+
+
+def text_pattern(breaks: Breaks) -> re.Pattern[str]:
+    return _TEXT_PATTERNS[breaks]

eolnorm/_stream.py

@@ -0,0 +1,61 @@
+"""Normalize a stream chunk by chunk, keeping CRLF whole across chunk borders."""
+
+from __future__ import annotations
+
+from typing import AnyStr, cast
+
+from ._eol import counts, detected_from, normalize
+from ._kinds import Breaks, Detected, Style, check_breaks, check_style, kinds
+
+
+class Normalizer:
+    """Incremental `normalize` with running `counts`, for text or bytes chunks.
+
+    A chunk that ends in CR is held back by one character until the next chunk shows
+    whether an LF follows. Pass ``final=True`` with the last chunk (it may be empty) to
+    release it. All chunks of one stream must be the same type, ``str`` or ``bytes``.
+    """
+
+    def __init__(
+        self, to: Style = "lf", *, breaks: Breaks = "ascii", keep_lone_cr: bool = False
+    ) -> None:
+        if not isinstance(keep_lone_cr, bool):
+            raise TypeError("keep_lone_cr must be a bool")
+        self._to = check_style(to)
+        self._breaks = check_breaks(breaks)
+        self._keep = keep_lone_cr
+        self._tally: dict[str, int] = dict.fromkeys(kinds(self._breaks), 0)
+        self._pending: str | bytes = ""
+        self._kind: type | None = None
+
+    def feed(self, chunk: AnyStr, final: bool = False) -> AnyStr:
+        """Return the normalized output that is safe to emit after this chunk."""
+        if not isinstance(chunk, (str, bytes)):
+            raise TypeError(f"expected str or bytes, got {type(chunk).__name__}")
+        if isinstance(chunk, bytes) and self._breaks != "ascii":
+            # Checked before any state changes, so a rejected chunk leaves the stream usable.
+            raise ValueError(f"breaks={self._breaks!r} needs decoded text, not bytes")
+        if self._kind is None:
+            self._kind = str if isinstance(chunk, str) else bytes
+            self._pending = chunk[:0]
+        elif not isinstance(chunk, self._kind):
+            raise TypeError(f"this stream carries {self._kind.__name__}, not a mix")
+        buffer = cast(AnyStr, self._pending) + chunk
+        hold = buffer.endswith("\r") if isinstance(buffer, str) else buffer.endswith(b"\r")
+        if hold and not final:
+            buffer, self._pending = buffer[:-1], buffer[-1:]
+        else:
+            self._pending = buffer[:0]
+        for name, count in counts(buffer, breaks=self._breaks).items():
+            self._tally[name] += count
+        return normalize(buffer, self._to, breaks=self._breaks, keep_lone_cr=self._keep)
+
+    @property
+    def counts(self) -> dict[str, int]:
+        """Endings seen so far in the input; a held-back CR is not counted yet."""
+        return dict(self._tally)
+
+    @property
+    def detected(self) -> Detected:
+        """`detect` over the input seen so far."""
+        return detected_from(self._tally)

eolnorm-0.2.0.dist-info/METADATA

@@ -0,0 +1,215 @@
+Metadata-Version: 2.5
+Name: eolnorm
+Version: 0.2.0
+Summary: Detect, normalize and count line endings in text, bytes, streams and files: git-exact, Unicode-aware, atomic rewrites, zero dependencies
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/eolnorm
+Project-URL: Issues, https://github.com/JaviLianes8/eolnorm/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/eolnorm/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: crlf,eol,gitattributes,line-endings,newline,normalize,unicode
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# eolnorm
+
+Detect, normalize and count line endings in text, bytes, streams and files. It can match
+git's `text` conversion byte for byte, knows the Unicode line boundaries, rewrites files
+atomically, and has no dependencies.
+
+## Install
+
+```
+pip install eolnorm
+```
+
+## Usage
+
+```python
+from eolnorm import counts, detect, normalize
+
+print(detect("a\r\nb\r\n"))
+# crlf
+print(detect("a\nb\r\n"))
+# mixed
+print(repr(normalize("a\r\nb\rc\n")))
+# 'a\nb\nc\n'
+print(counts("a\r\nb\r\nc\n"))
+# {'lf': 1, 'crlf': 2, 'cr': 0}
+```
+
+`detect` returns a `Detected` value: the single kind present, `"mixed"` or `"none"`.
+`normalize` converts to a `Style` (`"lf"`, the default, `"crlf"` or `"cr"`). CRLF is always
+one ending, never a CR plus an LF.
+
+### Bytes, and what git stores
+
+```python
+from eolnorm import normalize
+
+print(normalize(b"caf\xe9\r\nold\rmac\n"))
+# b'caf\xe9\nold\nmac\n'
+print(normalize(b"a\rb\r\n", keep_lone_cr=True))
+# b'a\rb\n'
+```
+
+`bytes` in, `bytes` out: CR and LF are the same bytes in every ASCII-compatible encoding
+(UTF-8, latin-1, cp1252 and so on), so nothing is decoded and every other byte is kept.
+
+`keep_lone_cr=True` leaves a CR that is not followed by LF alone. That is exactly what git
+does for a path with the `text` attribute: `normalize(data, "lf", keep_lone_cr=True)` is
+the blob `git add` stores under `text eol=lf`, and `normalize(blob, "crlf",
+keep_lone_cr=True)` is the file `git checkout` writes under `eol=crlf`. The test suite runs
+the installed git on hundreds of samples to prove it.
+
+### Unicode line boundaries
+
+```python
+from eolnorm import counts, detect, normalize
+
+text = "page one\x0cpage two\x85end"
+print(detect(text))
+# none
+print(detect(text, breaks="unicode"))
+# mixed
+print(repr(normalize(text, "lf", breaks="unicode")))
+# 'page one\npage two\nend'
+print(counts("a\x1eb", breaks="splitlines")["rs"])
+# 1
+```
+
+`breaks` picks the boundary set (a `Breaks` value). Each recognised ending has a `Kind` name.
+
+| `breaks` | Endings | Same as |
+| --- | --- | --- |
+| `"ascii"` (default) | `lf`, `crlf`, `cr` | universal newlines |
+| `"unicode"` | adds `vt`, `ff`, `nel` (U+0085), `ls` (U+2028), `ps` (U+2029) | UAX #14 mandatory breaks (classes BK, CR, LF, NL) |
+| `"splitlines"` | adds `fs`, `gs`, `rs` (U+001C to U+001E) | `str.splitlines` |
+
+`counts` always returns every kind of the chosen set, in that order. The two Unicode sets
+need decoded text: passing `bytes` with them raises `ValueError`. Note that they convert form
+feeds and vertical tabs too, so page breaks in `^L`-paginated sources become newlines; keep
+the default set for such files.
+
+### Streams
+
+```python
+from eolnorm import Normalizer
+
+stream = Normalizer("lf")
+out = stream.feed(b"one\r") + stream.feed(b"\ntwo\r") + stream.feed(b"", final=True)
+print(out)
+# b'one\ntwo\n'
+print(stream.counts, stream.detected)
+# {'lf': 0, 'crlf': 1, 'cr': 1} mixed
+```
+
+`Normalizer` takes the same options as `normalize`. A chunk ending in CR is held back until
+the next chunk shows whether an LF follows, so a CRLF split across two reads is still one
+ending. Pass `final=True` with the last chunk. All chunks of one stream are `str` or all are
+`bytes`.
+
+### Files
+
+```python
+import codecs
+import tempfile
+from pathlib import Path
+
+from eolnorm import is_binary, normalize_file, scan_file
+
+path = Path(tempfile.mkdtemp()) / "notes.txt"
+path.write_bytes(codecs.BOM_UTF16_LE + "one\r\ntwo\r\n".encode("utf-16-le"))
+report = normalize_file(path, "lf")
+print(report.encoding, report.bom, report.detected, report.changed)
+# utf-16-le True crlf True
+print(scan_file(path).detected)
+# lf
+print(normalize_file(path, "crlf", dry_run=True).changed)
+# True
+print(is_binary(b"\x89PNG\r\n\x1a\n\x00"))
+# True
+```
+
+`normalize_file` and `scan_file` return a `FileReport` (`path`, `binary`, `encoding`, `bom`,
+`counts`, `detected`, `changed`; the counts describe the file before any change).
+
+- A UTF-8, UTF-16 or UTF-32 byte order mark selects the codec, and the same mark is written
+  back. Without a mark the bytes are handled undecoded (ASCII set) or as UTF-8 (Unicode
+  sets). `encoding=` names a codec instead, for example `"utf-16-le"` for a file without a
+  mark. A named UTF codec still honours its own marks; generic `"utf-16"` and `"utf-32"`
+  without a mark are refused because the byte order is unknown. Any other codec (say
+  `"cp1252"`) decodes every byte as text, even bytes that look like a mark.
+- Binary files are reported and never changed. `is_binary` uses git's text=auto
+  statistics: a NUL byte, or fewer than 128 printable bytes per control byte, means binary.
+  Git also treats a lone CR as binary; `is_binary` does not, so old Mac files can be fixed.
+  The check also runs with an explicit ASCII-compatible `encoding`; it is skipped only for
+  codecs such as UTF-16, whose text is full of NUL bytes.
+- The rewrite is atomic: the new bytes go to a temporary file in the same folder, are
+  flushed to disk, get the original's permission bits, and replace the original in one
+  rename. A symlink is followed and stays a symlink. A file whose bytes would not change
+  is not touched, and `dry_run=True` only reports. A read-only file is refused with
+  `PermissionError` on every system. Being a new file, the result does not keep hard links,
+  the owner and group, or Windows attributes and access lists of the original.
+
+### Command line
+
+```
+$ eolnorm notes.txt logo.png
+notes.txt: crlf (crlf=2)
+logo.png: binary
+$ eolnorm --to lf --check notes.txt
+would fix notes.txt
+$ eolnorm --to lf notes.txt
+fixed notes.txt
+$ eolnorm --to crlf - < in.txt > out.txt
+```
+
+Options: `--to {lf,crlf,cr}`, `--check` (with `--to`: write nothing, exit 1 if a file would
+change, handy in a pre-commit hook), `--keep-lone-cr`, `--breaks {ascii,unicode,splitlines}`
+and `--encoding`. `-` filters standard input to standard output with the same rules as for
+files (a byte order mark is kept, binary input passes through unchanged). Exit code 2 means bad
+usage or a file that could not be read or decoded; the other files are still processed.
+`python -m eolnorm` works too.
+
+## Why
+
+The standard library resolves line endings only while decoding a file in universal newline
+mode. There is no helper to inspect, convert or count the endings of data already in
+memory, to do it on bytes without decoding, to match git's rules, or to fix a file in
+place safely. `eolify` is a compiled extension focused on fast conversion; `eolnorm` is pure
+Python and covers detection, counting, Unicode boundaries, streams and files.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

eolnorm-0.2.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+eolnorm/__init__.py,sha256=5ZkGgkAro_jBpYjgUHKZOhUGXyYVkBv0db9KXDUe0wM,564
+eolnorm/__main__.py,sha256=QJUgHCRkBs6i9De7gGjiXlj4jFCe1xtVJ51BF0WjNUs,146
+eolnorm/_atomic.py,sha256=htJN3Fy2QVBfwZGzOjfYFzBMuglZ6Uyd9kW3rzEQj9I,1855
+eolnorm/_binary.py,sha256=BxeupqBFKBblp5ZMlbSxAxZupKRBuBe4G4NawN_RiiQ,1780
+eolnorm/_cli.py,sha256=ijmrBugWtGnamVv9Ksh4DIwyQudFMUWGQc7u9sn-UcE,4022
+eolnorm/_content.py,sha256=KbuGoS0MHdRodlNIPHRh-CI40bLFbKGYhw9RYPAVtlg,3347
+eolnorm/_eol.py,sha256=vMkfCj3jjZYApEUxWNqK9_oKBCqGgZ8ceSTGy0N1ZH4,2838
+eolnorm/_files.py,sha256=nFelGObF8RtAjG9_EvfwEdXlA4_qoTVNt3YefBmVPLY,2916
+eolnorm/_kinds.py,sha256=CcorMUla6V-abkeQoYdFLL3pxr5Y71_85b0nQVZNT1E,2100
+eolnorm/_stream.py,sha256=QIY5LdUUpmc1gL7-JmB43s7LOToJVHGuLobxgiQtkek,2743
+eolnorm/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eolnorm-0.2.0.dist-info/METADATA,sha256=qE377MmzxzTpz5Rhpe6xdF-o-ba6MQaofAztRMQck9c,8352
+eolnorm-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+eolnorm-0.2.0.dist-info/entry_points.txt,sha256=1TPYvjKAz8EwZFuxYBNh1IcgsW0TQ5vPrwkARRRDCSg,46
+eolnorm-0.2.0.dist-info/licenses/LICENSE,sha256=_WmABlQG__oqlx4Rzp-qDJ10xND5KCLScftbhXbLC_c,1070
+eolnorm-0.2.0.dist-info/RECORD,,

eolnorm-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

eolnorm-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+eolnorm = eolnorm._cli:main

eolnorm-0.2.0.dist-info/licenses/LICENSE

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