eolnorm 0.2.0__tar.gz

eolnorm-0.2.0/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

eolnorm-0.2.0/.github/FUNDING.yml

@@ -0,0 +1 @@
+buy_me_a_coffee: jlianesglrs

eolnorm-0.2.0/.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Third-party data, fetched by scripts/fetch_vectors.py (see its MANIFEST.txt)
+tests/vectors/unicode/*
+!tests/vectors/unicode/MANIFEST.txt

eolnorm-0.2.0/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0]
+
+### Added
+
+- `breaks=` on every function: `"unicode"` adds the UAX #14 mandatory breaks (VT, FF, NEL,
+  LS, PS) and `"splitlines"` adds the three information separators, matching
+  `str.splitlines`. `Kind` and `Breaks` name the endings and the sets.
+- `counts`, `detect` and `normalize` accept `bytes` (ASCII set) and return the same type.
+- `keep_lone_cr=True` leaves a CR that is not followed by LF alone, as git does for paths
+  with the `text` attribute.
+- `Normalizer` for streams: a CRLF split across chunks stays one ending; running counts.
+- `is_binary`, using git's text=auto statistics.
+- `scan_file` and `normalize_file` with `FileReport`: byte order marks (UTF-8, UTF-16,
+  UTF-32) are detected and kept, an explicit `encoding` covers other codecs, binary files
+  are skipped, and the rewrite is atomic (temporary file, fsync, mode kept, one rename,
+  symlinks followed, read-only files refused). `dry_run=True` only reports.
+- The `eolnorm` command (also `python -m eolnorm`) with `--to`, `--check`, `--keep-lone-cr`,
+  `--breaks`, `--encoding` and `-` for standard input, which follows the same byte order
+  mark and binary rules as files.
+
+### Changed
+
+- `Detected` also covers the new kinds. `to` and `breaks` values are checked up front with
+  a clear `ValueError`, and a value that is neither `str` nor `bytes` raises `TypeError`.
+
+## [0.1.0]
+
+- First release: `detect`, `normalize` and `counts` for line endings in text, with CRLF
+  treated as a single unit.

eolnorm-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Contributing
+
+Thanks for taking the time. This project keeps a small, predictable shape.
+
+## Setup
+
+```
+pip install -r requirements-dev.txt
+```
+
+## Before you open a pull request
+
+- Keep public API in `src/eolnorm/__init__.py`; internals live in `_`-prefixed modules.
+- Add a test for the behaviour you change. Tests inject time, disk and network; they
+  never touch the real thing.
+- Run `scripts/check.ps1` (format, lint, types, tests) and make sure it passes.
+- One logical change per commit, imperative subject line.
+
+Open an issue first if the change is large or shifts the public API.

eolnorm-0.2.0/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.

eolnorm-0.2.0/PKG-INFO

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

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

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "eolnorm"
+version = "0.2.0"
+description = "Detect, normalize and count line endings in text, bytes, streams and files: git-exact, Unicode-aware, atomic rewrites, zero dependencies"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Javier Lianes", email = "javier@lianes8studio.com" }]
+keywords = ["line-endings", "eol", "crlf", "newline", "normalize", "gitattributes", "unicode"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Text Processing",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["ruff", "mypy", "pytest", "build", "twine"]
+
+[project.scripts]
+eolnorm = "eolnorm._cli:main"
+
+[project.urls]
+Homepage = "https://lianes8studio.com"
+Repository = "https://github.com/JaviLianes8/eolnorm"
+Issues = "https://github.com/JaviLianes8/eolnorm/issues"
+Changelog = "https://github.com/JaviLianes8/eolnorm/blob/main/CHANGELOG.md"
+LinkedIn = "https://www.linkedin.com/in/jlianes/"
+Funding = "https://buymeacoffee.com/jlianesglrs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/eolnorm"]
+
+[tool.hatch.build.targets.sdist]
+exclude = ["IMPROVEMENTS-round.md", "tests/vectors/unicode/*.txt", "!tests/vectors/unicode/MANIFEST.txt"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-q"

eolnorm-0.2.0/requirements-dev.txt

@@ -0,0 +1,3 @@
+# Development dependencies: the package in editable mode plus its dev extras
+# (ruff, mypy, pytest, build, twine). Install with:  pip install -r requirements-dev.txt
+-e .[dev]

eolnorm-0.2.0/scripts/check.ps1

@@ -0,0 +1,16 @@
+# Local quality gate. Run before every commit. No CI runs in the cloud.
+# $ErrorActionPreference does NOT stop on a native command's non-zero exit, so each tool's
+# exit code is checked explicitly: a red gate must fail, never pass silently.
+$ErrorActionPreference = "Stop"
+
+function Invoke-Step($label, [scriptblock]$cmd) {
+    Write-Host "== $label =="
+    & $cmd
+    if ($LASTEXITCODE -ne 0) { Write-Host "FAILED: $label (exit $LASTEXITCODE)"; exit $LASTEXITCODE }
+}
+
+Invoke-Step "ruff format" { ruff format --check . }
+Invoke-Step "ruff lint"   { ruff check . }
+Invoke-Step "mypy"        { mypy src tests }
+Invoke-Step "pytest"      { pytest }
+Write-Host "gate green"

eolnorm-0.2.0/scripts/fetch_vectors.py

@@ -0,0 +1,35 @@
+"""Fetch the Unicode data files listed in tests/vectors/unicode/MANIFEST.txt.
+
+The files are third-party and are not committed. Each download is checked against the size
+and SHA-256 in the manifest; a mismatch aborts without keeping the file.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import sys
+import urllib.request
+from pathlib import Path
+
+FOLDER = Path(__file__).resolve().parents[1] / "tests" / "vectors" / "unicode"
+
+
+def main() -> int:
+    lines = (FOLDER / "MANIFEST.txt").read_text(encoding="utf-8").splitlines()
+    base = next(line for line in lines if line.startswith("# URL: "))[len("# URL: ") :]
+    for line in lines:
+        if not line or line.startswith("#"):
+            continue
+        digest, size, name = line.split()
+        with urllib.request.urlopen(base.replace("<name>", name), timeout=60) as response:
+            data = response.read()
+        if len(data) != int(size) or hashlib.sha256(data).hexdigest() != digest:
+            print(f"{name}: size or sha256 does not match the manifest", file=sys.stderr)
+            return 1
+        (FOLDER / name).write_bytes(data)
+        print(f"{name}: ok")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

eolnorm-0.2.0/scripts/release.ps1

@@ -0,0 +1,28 @@
+# Build and upload to PyPI. Run scripts/check.ps1 first.
+# The name must not already exist on PyPI; the token is read from a secret store, never git.
+$ErrorActionPreference = "Stop"
+
+# Works on both Windows PowerShell 5.1 and pwsh 7 (generic catch, no PS7-only types).
+$taken = $true
+try {
+    Invoke-WebRequest -UseBasicParsing "https://pypi.org/pypi/eolnorm/json" | Out-Null
+} catch {
+    if ($_.Exception.Response.StatusCode.value__ -eq 404) { $taken = $false } else { throw }
+}
+if ($taken) { throw "The name 'eolnorm' already exists on PyPI. Choose another before publishing." }
+
+$token = $env:PYPI_TOKEN
+if (-not $token -and (Test-Path "C:\secrets\pypi-token.txt")) {
+    $token = (Get-Content "C:\secrets\pypi-token.txt" -Raw).Trim()
+}
+if (-not $token) {
+    throw "No PyPI token. Set `$env:PYPI_TOKEN or save it to C:\secrets\pypi-token.txt (never commit it)."
+}
+
+Remove-Item -Recurse -Force dist -ErrorAction SilentlyContinue
+python -m build
+python -m twine check dist/*
+
+$env:TWINE_USERNAME = "__token__"
+$env:TWINE_PASSWORD = $token
+try { python -m twine upload dist/* } finally { Remove-Item Env:\TWINE_PASSWORD -ErrorAction SilentlyContinue }

eolnorm-0.2.0/src/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",
+]