crc8-pure 0.1.0__tar.gz

crc8_pure-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 crc8-pure contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

crc8_pure-0.1.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: crc8-pure
+Version: 0.1.0
+Summary: Zero-dependency, pure-Python CRC-8 over 7 RevEng-catalogued variants
+Author: crc8-pure contributors
+License: MIT
+Keywords: crc,crc8,checksum,pure-python,zero-dependency
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# crc8-pure
+
+Zero-dependency, pure-Python CRC-8 over 7 RevEng-catalogued variants.
+
+`crc8-pure` provides a single, self-contained implementation of seven widely
+used CRC-8 variants — `crc-8`, `crc-8-darc`, `crc-8-i-code`, `crc-8-itu`
+(CCITT), `crc-8-maxim` (DOW), `crc-8-rohc`, and `crc-8-wcdma` — together
+with a class-based incremental API and a command-line entry point. No
+C-extension dependencies; only the Python standard library is used at
+runtime.
+
+## Install
+
+```bash
+pip install crc8-pure
+```
+
+Or from a local checkout:
+
+```bash
+pip install -e .
+```
+
+Requires Python ≥ 3.8. There are no runtime dependencies.
+
+## Quickstart
+
+```python
+import crc8_pure
+
+# Functional API: returns an int 0–255
+crc8_pure.crc8(b"hello")                  # crc-8 variant (default)
+crc8_pure.crc8(b"hello", variant="crc-8-maxim")
+crc8_pure.crc8_maxim(b"hello")            # convenience wrapper
+
+# Incremental / streaming API
+crc8_pure.crc8(b"hel", init=0x00)
+crc8_pure.crc8(b"lo", init=<prev>)        # continues from previous state
+
+# Class API
+h = crc8_pure.CRC8(variant="crc-8-maxim")
+h.update(b"hello")
+h.digest()                                # -> bytes
+h.hexdigest()                             # -> "3b"
+```
+
+### CLI
+
+```bash
+# String input
+python -m crc8_pure crc8-maxim "123456789"
+
+# Hex-prefixed output
+python -m crc8_pure crc8 "123456789" --hex
+
+# File input
+python -m crc8_pure crc8-maxim path/to/file.bin
+
+# Read from stdin
+cat file.bin | python -m crc8_pure crc-8 -
+```
+
+## 7 Variants
+
+| Variant        | Polynomial | Init | RefIn | RefOut | XOR Out | Check (`"123456789"`) |
+|----------------|-----------:|-----:|:-----:|:------:|--------:|---------------------:|
+| `crc-8`        | `0x07`     | `0x00` |  no  |  no   | `0x00`  | `0xF4`              |
+| `crc-8-darc`   | `0x39`     | `0x00` | yes  |  yes  | `0x00`  | `0x15`              |
+| `crc-8-i-code` | `0x1D`     | `0xFD` |  no  |  no   | `0x00`  | `0x7E`              |
+| `crc-8-itu`    | `0x07`     | `0x55` |  no  |  no   | `0x55`  | `0xA1`              |
+| `crc-8-maxim`  | `0x31`     | `0x00` | yes  |  yes  | `0x00`  | `0xA1`              |
+| `crc-8-rohc`   | `0x07`     | `0xFF` | yes  |  yes  | `0x00`  | `0xD0`              |
+| `crc-8-wcdma`  | `0x9B`     | `0x00` | yes  |  yes  | `0x00`  | `0x25`              |
+
+Check values come from the
+[RevEng CRC Catalogue](https://reveng.sourceforge.io/crc-catalogue/all.htm)
+and have been verified byte-exact against `crcmod`.
+
+Aliases: `CCITT` → `crc-8-itu`, `MAXIM` → `crc-8-maxim`,
+`DOW-CRC` → `crc-8-maxim`.
+
+## API
+
+### `crc8(data=b"", variant="crc-8", init=None) -> int`
+
+Compute a CRC-8 checksum. `init` lets you resume from a previous partial
+result: `crc8(b"lo", init=crc8(b"hel"))` is equivalent to
+`crc8(b"hello")`.
+
+### `CRC8(variant="crc-8", init=None)`
+
+Incremental calculator. Use `update(data)` to feed bytes, then
+`digest()` (bytes) or `hexdigest()` (string).
+
+### CLI
+
+`python -m crc8_pure <variant> [FILE_OR_STRING...] [--hex]`
+
+If no input is given (or `-`), data is read from stdin. A single argument
+is treated as a file path if it exists, otherwise as a string literal.
+Multiple arguments are concatenated.
+
+## Tests
+
+```bash
+pip install pytest
+pytest -q
+```
+
+The test suite covers all 21 canonical vectors (3 inputs × 7 variants)
+plus boundary conditions, alias resolution, incremental equivalence,
+class API, and CLI smoke tests.
+
+Current test count: **126 tests**.
+
+## Known Issues / Limitations
+
+The following are honest documented limits of crc8-pure:
+
+- **CRC-8 is not cryptographic.** CRC-8 is for error-detection on trusted media; do not
+  use it as a cryptographic integrity check or MAC.
+- **CLI stdin/file materialization.** `python -m crc8_pure <variant> <file>` fully
+  materializes the file into RAM before processing. For multi-GB inputs this may
+  exhaust memory; no streaming boundary is applied.
+- **Thread-safety.** A `CRC8` instance is not safe for concurrent `update()` calls
+  from multiple threads; create one instance per thread.
+- **`data` accepts non-bytes silently.** Pass bytes-like objects (bytes/bytearray/
+  memoryview). Passing a non-bytes value will produce a non-canonical result
+  without raising an error.
+- **No `CRC8.copy()` / `CRC8.reset()`.** Re-using a `CRC8` instance requires
+  constructing a new one; there is no `copy()` or `reset()` method.
+
+## License
+
+MIT — see `LICENSE`.

crc8_pure-0.1.0/README.md

@@ -0,0 +1,135 @@
+# crc8-pure
+
+Zero-dependency, pure-Python CRC-8 over 7 RevEng-catalogued variants.
+
+`crc8-pure` provides a single, self-contained implementation of seven widely
+used CRC-8 variants — `crc-8`, `crc-8-darc`, `crc-8-i-code`, `crc-8-itu`
+(CCITT), `crc-8-maxim` (DOW), `crc-8-rohc`, and `crc-8-wcdma` — together
+with a class-based incremental API and a command-line entry point. No
+C-extension dependencies; only the Python standard library is used at
+runtime.
+
+## Install
+
+```bash
+pip install crc8-pure
+```
+
+Or from a local checkout:
+
+```bash
+pip install -e .
+```
+
+Requires Python ≥ 3.8. There are no runtime dependencies.
+
+## Quickstart
+
+```python
+import crc8_pure
+
+# Functional API: returns an int 0–255
+crc8_pure.crc8(b"hello")                  # crc-8 variant (default)
+crc8_pure.crc8(b"hello", variant="crc-8-maxim")
+crc8_pure.crc8_maxim(b"hello")            # convenience wrapper
+
+# Incremental / streaming API
+crc8_pure.crc8(b"hel", init=0x00)
+crc8_pure.crc8(b"lo", init=<prev>)        # continues from previous state
+
+# Class API
+h = crc8_pure.CRC8(variant="crc-8-maxim")
+h.update(b"hello")
+h.digest()                                # -> bytes
+h.hexdigest()                             # -> "3b"
+```
+
+### CLI
+
+```bash
+# String input
+python -m crc8_pure crc8-maxim "123456789"
+
+# Hex-prefixed output
+python -m crc8_pure crc8 "123456789" --hex
+
+# File input
+python -m crc8_pure crc8-maxim path/to/file.bin
+
+# Read from stdin
+cat file.bin | python -m crc8_pure crc-8 -
+```
+
+## 7 Variants
+
+| Variant        | Polynomial | Init | RefIn | RefOut | XOR Out | Check (`"123456789"`) |
+|----------------|-----------:|-----:|:-----:|:------:|--------:|---------------------:|
+| `crc-8`        | `0x07`     | `0x00` |  no  |  no   | `0x00`  | `0xF4`              |
+| `crc-8-darc`   | `0x39`     | `0x00` | yes  |  yes  | `0x00`  | `0x15`              |
+| `crc-8-i-code` | `0x1D`     | `0xFD` |  no  |  no   | `0x00`  | `0x7E`              |
+| `crc-8-itu`    | `0x07`     | `0x55` |  no  |  no   | `0x55`  | `0xA1`              |
+| `crc-8-maxim`  | `0x31`     | `0x00` | yes  |  yes  | `0x00`  | `0xA1`              |
+| `crc-8-rohc`   | `0x07`     | `0xFF` | yes  |  yes  | `0x00`  | `0xD0`              |
+| `crc-8-wcdma`  | `0x9B`     | `0x00` | yes  |  yes  | `0x00`  | `0x25`              |
+
+Check values come from the
+[RevEng CRC Catalogue](https://reveng.sourceforge.io/crc-catalogue/all.htm)
+and have been verified byte-exact against `crcmod`.
+
+Aliases: `CCITT` → `crc-8-itu`, `MAXIM` → `crc-8-maxim`,
+`DOW-CRC` → `crc-8-maxim`.
+
+## API
+
+### `crc8(data=b"", variant="crc-8", init=None) -> int`
+
+Compute a CRC-8 checksum. `init` lets you resume from a previous partial
+result: `crc8(b"lo", init=crc8(b"hel"))` is equivalent to
+`crc8(b"hello")`.
+
+### `CRC8(variant="crc-8", init=None)`
+
+Incremental calculator. Use `update(data)` to feed bytes, then
+`digest()` (bytes) or `hexdigest()` (string).
+
+### CLI
+
+`python -m crc8_pure <variant> [FILE_OR_STRING...] [--hex]`
+
+If no input is given (or `-`), data is read from stdin. A single argument
+is treated as a file path if it exists, otherwise as a string literal.
+Multiple arguments are concatenated.
+
+## Tests
+
+```bash
+pip install pytest
+pytest -q
+```
+
+The test suite covers all 21 canonical vectors (3 inputs × 7 variants)
+plus boundary conditions, alias resolution, incremental equivalence,
+class API, and CLI smoke tests.
+
+Current test count: **126 tests**.
+
+## Known Issues / Limitations
+
+The following are honest documented limits of crc8-pure:
+
+- **CRC-8 is not cryptographic.** CRC-8 is for error-detection on trusted media; do not
+  use it as a cryptographic integrity check or MAC.
+- **CLI stdin/file materialization.** `python -m crc8_pure <variant> <file>` fully
+  materializes the file into RAM before processing. For multi-GB inputs this may
+  exhaust memory; no streaming boundary is applied.
+- **Thread-safety.** A `CRC8` instance is not safe for concurrent `update()` calls
+  from multiple threads; create one instance per thread.
+- **`data` accepts non-bytes silently.** Pass bytes-like objects (bytes/bytearray/
+  memoryview). Passing a non-bytes value will produce a non-canonical result
+  without raising an error.
+- **No `CRC8.copy()` / `CRC8.reset()`.** Re-using a `CRC8` instance requires
+  constructing a new one; there is no `copy()` or `reset()` method.
+
+## License
+
+MIT — see `LICENSE`.

crc8_pure-0.1.0/crc8_pure/__init__.py

@@ -0,0 +1,93 @@
+"""crc8-pure: zero-dependency CRC-8 over 7 RevEng-catalogued variants."""
+from __future__ import annotations
+import argparse
+import sys
+
+from ._variants import VARIANTS, normalize_variant
+from ._class import CRC8
+
+__version__ = "0.1.0"
+
+
+def _compute(data, variant: str, init):
+    name = normalize_variant(variant)
+    poly, raw_init, refin, refout, xorout, _check = VARIANTS[name]
+    from ._variants import TABLES  # local import keeps __init__ slim
+    table = TABLES[name]
+    if init is None:
+        crc = (raw_init ^ xorout) & 0xFF
+    else:
+        crc = (init ^ xorout) & 0xFF
+    for b in data:
+        crc = table[(crc ^ b) & 0xFF]
+    if refout and not refin:
+        from ._variants import reflect8
+        crc = reflect8(crc)
+    return (crc ^ xorout) & 0xFF
+
+
+def crc8(data=b"", variant: str = "crc-8", init=None) -> int:
+    """Compute CRC-8 checksum; returns int 0-255."""
+    return _compute(data, variant, init)
+
+
+def crc8_darc(data) -> int:    return crc8(data, "crc-8-darc")
+def crc8_i_code(data) -> int:  return crc8(data, "crc-8-i-code")
+def crc8_itu(data) -> int:     return crc8(data, "crc-8-itu")
+def crc8_maxim(data) -> int:   return crc8(data, "crc-8-maxim")
+def crc8_rohc(data) -> int:    return crc8(data, "crc-8-rohc")
+def crc8_wcdma(data) -> int:   return crc8(data, "crc-8-wcdma")
+
+
+__all__ = [
+    "__version__", "CRC8", "crc8",
+    "crc8_darc", "crc8_i_code", "crc8_itu",
+    "crc8_maxim", "crc8_rohc", "crc8_wcdma",
+]
+
+
+_VARIANT_NAMES = sorted(VARIANTS.keys())
+
+
+def _isfile(path: str) -> bool:
+    try:
+        with open(path, "rb"):
+            return True
+    except OSError:
+        return False
+
+
+def _read_file(path: str) -> bytes:
+    with open(path, "rb") as f:
+        return f.read()
+
+
+def _main(argv):
+    p = argparse.ArgumentParser(prog="crc8_pure", description="CRC-8 checksum CLI")
+    p.add_argument("variant", help=f"variant name: {', '.join(_VARIANT_NAMES)} (or alias)")
+    p.add_argument("inputs", nargs="*", help="files or string literals (stdin if none)")
+    p.add_argument("--hex", action="store_true", help="print as 0xNN")
+    args = p.parse_args(argv)
+    if not args.inputs or args.inputs == ["-"]:
+        data = sys.stdin.buffer.read()
+    elif len(args.inputs) == 1 and _isfile(args.inputs[0]):
+        data = _read_file(args.inputs[0])
+    elif len(args.inputs) == 1:
+        data = args.inputs[0].encode("utf-8")
+    else:
+        parts = [_read_file(x) if _isfile(x) else x.encode("utf-8") for x in args.inputs]
+        data = b"".join(parts)
+    val = crc8(data, args.variant)
+    if args.hex:
+        print(f"0x{val:02x}")
+    else:
+        print(f"{val:02x}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(_main(sys.argv[1:]))
+
+
+def _cli_entry():
+    sys.exit(_main(sys.argv[1:]))

crc8_pure-0.1.0/crc8_pure/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m crc8_pure ...`` to invoke the CLI."""
+from .__init__ import _main
+import sys
+
+if __name__ == "__main__":
+    sys.exit(_main(sys.argv[1:]))

crc8_pure-0.1.0/crc8_pure/_class.py

@@ -0,0 +1,33 @@
+"""CRC8 incremental class for crc8-pure."""
+from __future__ import annotations
+
+from ._variants import VARIANTS, TABLES, normalize_variant, reflect8
+
+
+class CRC8:
+    """Incremental CRC-8 calculator. ``update(data)`` returns self for chaining."""
+
+    def __init__(self, variant: str = "crc-8", init=None):
+        self.variant = normalize_variant(variant)
+        _p, raw_init, self._refin, self._refout, self._xorout, _ = VARIANTS[self.variant]
+        self._table = TABLES[self.variant]
+        if init is None:
+            # Default initial register = raw_init XOR xorout (crcmod convention).
+            self._crc = (raw_init ^ self._xorout) & 0xFF
+        else:
+            # Resuming: ``init`` is the post-xorout digest of a previous step.
+            self._crc = (init ^ self._xorout) & 0xFF
+
+    def update(self, data) -> "CRC8":
+        for b in data:
+            self._crc = self._table[(self._crc ^ b) & 0xFF]
+        return self
+
+    def digest(self) -> bytes:
+        crc = self._crc
+        if self._refout and not self._refin:
+            crc = reflect8(crc)
+        return bytes([(crc ^ self._xorout) & 0xFF])
+
+    def hexdigest(self) -> str:
+        return f"{self.digest()[0]:02x}"

crc8_pure-0.1.0/crc8_pure/_variants.py

@@ -0,0 +1,70 @@
+"""Variant table + reflected-bit helper for crc8-pure.
+
+Defines the 7 RevEng-catalogued CRC-8 variants as a frozen dict of
+``(poly, init, refin, refout, xorout, check_on_123456789)`` tuples, plus
+alias table and the ``_reflect8`` bit-reversal helper. Imported by
+``crc8_pure.__init__`` and by ``crc8_pure._class`` (the CRC8 class).
+"""
+from __future__ import annotations
+
+# (poly, init, refin, refout, xorout, check_on_123456789)
+VARIANTS = {
+    "crc-8":        (0x07, 0x00, False, False, 0x00, 0xF4),
+    "crc-8-darc":   (0x39, 0x00, True,  True,  0x00, 0x15),
+    "crc-8-i-code": (0x1D, 0xFD, False, False, 0x00, 0x7E),
+    "crc-8-itu":    (0x07, 0x55, False, False, 0x55, 0xA1),
+    "crc-8-maxim":  (0x31, 0x00, True,  True,  0x00, 0xA1),
+    "crc-8-rohc":   (0x07, 0xFF, True,  True,  0x00, 0xD0),
+    "crc-8-wcdma":  (0x9B, 0x00, True,  True,  0x00, 0x25),
+}
+
+ALIASES = {
+    "CCITT": "crc-8-itu",
+    "MAXIM": "crc-8-maxim",
+    "DOW-CRC": "crc-8-maxim",
+}
+
+
+def normalize_variant(name: str) -> str:
+    key = name.strip().upper().replace("_", "-")
+    if key in ALIASES:
+        return ALIASES[key]
+    for v in VARIANTS:
+        if v.upper() == key:
+            return v
+    raise ValueError(f"unknown crc8 variant: {name!r}")
+
+
+def reflect8(x: int) -> int:
+    r = 0
+    for i in range(8):
+        if x & (1 << i):
+            r |= 1 << (7 - i)
+    return r & 0xFF
+
+
+def build_table(poly: int, refin: bool) -> tuple:
+    tbl = []
+    if refin:
+        rpoly = reflect8(poly)
+        for i in range(256):
+            crc = i
+            for _ in range(8):
+                crc = ((crc >> 1) ^ rpoly) if (crc & 1) else (crc >> 1)
+                crc &= 0xFF
+            tbl.append(crc)
+    else:
+        for i in range(256):
+            crc = i << 8
+            for _ in range(8):
+                if crc & 0x8000:
+                    crc = ((crc << 1) ^ (poly << 8)) & 0xFFFF
+                else:
+                    crc = (crc << 1) & 0xFFFF
+            tbl.append((crc >> 8) & 0xFF)
+    return tuple(tbl)
+
+
+TABLES = {
+    name: build_table(p, ri) for name, (p, _, ri, _, _, _) in VARIANTS.items()
+}

crc8_pure-0.1.0/crc8_pure.egg-info/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: crc8-pure
+Version: 0.1.0
+Summary: Zero-dependency, pure-Python CRC-8 over 7 RevEng-catalogued variants
+Author: crc8-pure contributors
+License: MIT
+Keywords: crc,crc8,checksum,pure-python,zero-dependency
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# crc8-pure
+
+Zero-dependency, pure-Python CRC-8 over 7 RevEng-catalogued variants.
+
+`crc8-pure` provides a single, self-contained implementation of seven widely
+used CRC-8 variants — `crc-8`, `crc-8-darc`, `crc-8-i-code`, `crc-8-itu`
+(CCITT), `crc-8-maxim` (DOW), `crc-8-rohc`, and `crc-8-wcdma` — together
+with a class-based incremental API and a command-line entry point. No
+C-extension dependencies; only the Python standard library is used at
+runtime.
+
+## Install
+
+```bash
+pip install crc8-pure
+```
+
+Or from a local checkout:
+
+```bash
+pip install -e .
+```
+
+Requires Python ≥ 3.8. There are no runtime dependencies.
+
+## Quickstart
+
+```python
+import crc8_pure
+
+# Functional API: returns an int 0–255
+crc8_pure.crc8(b"hello")                  # crc-8 variant (default)
+crc8_pure.crc8(b"hello", variant="crc-8-maxim")
+crc8_pure.crc8_maxim(b"hello")            # convenience wrapper
+
+# Incremental / streaming API
+crc8_pure.crc8(b"hel", init=0x00)
+crc8_pure.crc8(b"lo", init=<prev>)        # continues from previous state
+
+# Class API
+h = crc8_pure.CRC8(variant="crc-8-maxim")
+h.update(b"hello")
+h.digest()                                # -> bytes
+h.hexdigest()                             # -> "3b"
+```
+
+### CLI
+
+```bash
+# String input
+python -m crc8_pure crc8-maxim "123456789"
+
+# Hex-prefixed output
+python -m crc8_pure crc8 "123456789" --hex
+
+# File input
+python -m crc8_pure crc8-maxim path/to/file.bin
+
+# Read from stdin
+cat file.bin | python -m crc8_pure crc-8 -
+```
+
+## 7 Variants
+
+| Variant        | Polynomial | Init | RefIn | RefOut | XOR Out | Check (`"123456789"`) |
+|----------------|-----------:|-----:|:-----:|:------:|--------:|---------------------:|
+| `crc-8`        | `0x07`     | `0x00` |  no  |  no   | `0x00`  | `0xF4`              |
+| `crc-8-darc`   | `0x39`     | `0x00` | yes  |  yes  | `0x00`  | `0x15`              |
+| `crc-8-i-code` | `0x1D`     | `0xFD` |  no  |  no   | `0x00`  | `0x7E`              |
+| `crc-8-itu`    | `0x07`     | `0x55` |  no  |  no   | `0x55`  | `0xA1`              |
+| `crc-8-maxim`  | `0x31`     | `0x00` | yes  |  yes  | `0x00`  | `0xA1`              |
+| `crc-8-rohc`   | `0x07`     | `0xFF` | yes  |  yes  | `0x00`  | `0xD0`              |
+| `crc-8-wcdma`  | `0x9B`     | `0x00` | yes  |  yes  | `0x00`  | `0x25`              |
+
+Check values come from the
+[RevEng CRC Catalogue](https://reveng.sourceforge.io/crc-catalogue/all.htm)
+and have been verified byte-exact against `crcmod`.
+
+Aliases: `CCITT` → `crc-8-itu`, `MAXIM` → `crc-8-maxim`,
+`DOW-CRC` → `crc-8-maxim`.
+
+## API
+
+### `crc8(data=b"", variant="crc-8", init=None) -> int`
+
+Compute a CRC-8 checksum. `init` lets you resume from a previous partial
+result: `crc8(b"lo", init=crc8(b"hel"))` is equivalent to
+`crc8(b"hello")`.
+
+### `CRC8(variant="crc-8", init=None)`
+
+Incremental calculator. Use `update(data)` to feed bytes, then
+`digest()` (bytes) or `hexdigest()` (string).
+
+### CLI
+
+`python -m crc8_pure <variant> [FILE_OR_STRING...] [--hex]`
+
+If no input is given (or `-`), data is read from stdin. A single argument
+is treated as a file path if it exists, otherwise as a string literal.
+Multiple arguments are concatenated.
+
+## Tests
+
+```bash
+pip install pytest
+pytest -q
+```
+
+The test suite covers all 21 canonical vectors (3 inputs × 7 variants)
+plus boundary conditions, alias resolution, incremental equivalence,
+class API, and CLI smoke tests.
+
+Current test count: **126 tests**.
+
+## Known Issues / Limitations
+
+The following are honest documented limits of crc8-pure:
+
+- **CRC-8 is not cryptographic.** CRC-8 is for error-detection on trusted media; do not
+  use it as a cryptographic integrity check or MAC.
+- **CLI stdin/file materialization.** `python -m crc8_pure <variant> <file>` fully
+  materializes the file into RAM before processing. For multi-GB inputs this may
+  exhaust memory; no streaming boundary is applied.
+- **Thread-safety.** A `CRC8` instance is not safe for concurrent `update()` calls
+  from multiple threads; create one instance per thread.
+- **`data` accepts non-bytes silently.** Pass bytes-like objects (bytes/bytearray/
+  memoryview). Passing a non-bytes value will produce a non-canonical result
+  without raising an error.
+- **No `CRC8.copy()` / `CRC8.reset()`.** Re-using a `CRC8` instance requires
+  constructing a new one; there is no `copy()` or `reset()` method.
+
+## License
+
+MIT — see `LICENSE`.

crc8_pure-0.1.0/crc8_pure.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+crc8_pure/__init__.py
+crc8_pure/__main__.py
+crc8_pure/_class.py
+crc8_pure/_variants.py
+crc8_pure.egg-info/PKG-INFO
+crc8_pure.egg-info/SOURCES.txt
+crc8_pure.egg-info/dependency_links.txt
+crc8_pure.egg-info/entry_points.txt
+crc8_pure.egg-info/top_level.txt
+tests/test_crc8_pure.py

crc8_pure-0.1.0/crc8_pure.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

crc8_pure-0.1.0/crc8_pure.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+crc8-pure = crc8_pure:_cli_entry

crc8_pure-0.1.0/crc8_pure.egg-info/top_level.txt

@@ -0,0 +1 @@
+crc8_pure

crc8_pure-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "crc8-pure"
+version = "0.1.0"
+description = "Zero-dependency, pure-Python CRC-8 over 7 RevEng-catalogued variants"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [{name = "crc8-pure contributors"}]
+keywords = ["crc", "crc8", "checksum", "pure-python", "zero-dependency"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = []
+
+[project.scripts]
+crc8-pure = "crc8_pure:_cli_entry"
+
+[tool.setuptools]
+packages = ["crc8_pure"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

crc8_pure-0.1.0/setup.cfg

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

crc8_pure-0.1.0/tests/test_crc8_pure.py

@@ -0,0 +1,302 @@
+"""Tests for crc8_pure — covers all 21 canonical vectors + boundary cases.
+
+Test count target: ≥100 (achieved via parametrize across 7 variants x inputs).
+The 21-vector canonical table comes from the RevEng CRC Catalogue and was
+verified at orchestrator time via crcmod.predefined.mkPredefinedCrcFun.
+"""
+from __future__ import annotations
+import os
+import subprocess
+import sys
+import tempfile
+
+import pytest
+
+import crc8_pure as c
+
+
+# canonical (variant, input, expected) triples from spec.md table
+VARIANTS = [
+    "crc-8", "crc-8-darc", "crc-8-i-code",
+    "crc-8-itu", "crc-8-maxim", "crc-8-rohc", "crc-8-wcdma",
+]
+
+CANONICAL = [
+    # (variant, input_bytes, expected_hex)
+    ("crc-8",         b"",            0x00),
+    ("crc-8",         b"a",           0x20),
+    ("crc-8",         b"123456789",   0xF4),
+    ("crc-8-darc",    b"",            0x00),
+    ("crc-8-darc",    b"a",           0x1B),
+    ("crc-8-darc",    b"123456789",   0x15),
+    ("crc-8-i-code",  b"",            0xFD),
+    ("crc-8-i-code",  b"a",           0x77),
+    ("crc-8-i-code",  b"123456789",   0x7E),
+    ("crc-8-itu",     b"",            0x55),
+    ("crc-8-itu",     b"a",           0x75),
+    ("crc-8-itu",     b"123456789",   0xA1),
+    ("crc-8-maxim",   b"",            0x00),
+    ("crc-8-maxim",   b"a",           0x3B),
+    ("crc-8-maxim",   b"123456789",   0xA1),
+    ("crc-8-rohc",    b"",            0xFF),
+    ("crc-8-rohc",    b"a",           0x16),
+    ("crc-8-rohc",    b"123456789",   0xD0),
+    ("crc-8-wcdma",   b"",            0x00),
+    ("crc-8-wcdma",   b"a",           0xE6),
+    ("crc-8-wcdma",   b"123456789",   0x25),
+]
+
+
+# ───────────── 21 canonical vectors ─────────────
+
+@pytest.mark.parametrize("variant,data,expected", CANONICAL,
+                         ids=[f"{v}|{d or 'empty'}" for v, d, _ in CANONICAL])
+def test_canonical_vector(variant, data, expected):
+    assert c.crc8(data, variant) == expected
+
+
+# ───────────── Per-variant convenience functions ─────────────
+
+@pytest.mark.parametrize("variant,fn_name,expected", [
+    ("crc-8-darc",   "crc8_darc",   0x1B),
+    ("crc-8-i-code", "crc8_i_code", 0x77),
+    ("crc-8-itu",    "crc8_itu",    0x75),
+    ("crc-8-maxim",  "crc8_maxim",  0x3B),
+    ("crc-8-rohc",   "crc8_rohc",   0x16),
+    ("crc-8-wcdma",  "crc8_wcdma",  0xE6),
+])
+def test_per_variant_function_a(variant, fn_name, expected):
+    assert getattr(c, fn_name)(b"a") == expected
+
+
+@pytest.mark.parametrize("variant,fn_name", [
+    ("crc-8-darc",   "crc8_darc"),
+    ("crc-8-i-code", "crc8_i_code"),
+    ("crc-8-itu",    "crc8_itu"),
+    ("crc-8-maxim",  "crc8_maxim"),
+    ("crc-8-rohc",   "crc8_rohc"),
+    ("crc-8-wcdma",  "crc8_wcdma"),
+])
+def test_per_variant_canonical_123456789(variant, fn_name):
+    expected = c.crc8(b"123456789", variant)
+    assert getattr(c, fn_name)(b"123456789") == expected
+
+
+def test_per_variant_empty_maxim():
+    assert c.crc8_maxim(b"") == 0x00
+
+
+def test_per_variant_empty_rohc():
+    assert c.crc8_rohc(b"") == 0xFF
+
+
+# ───────────── Alias table ─────────────
+
+@pytest.mark.parametrize("alias,canonical", [
+    ("CCITT",   "crc-8-itu"),
+    ("MAXIM",   "crc-8-maxim"),
+    ("DOW-CRC", "crc-8-maxim"),
+])
+def test_alias_equivalence(alias, canonical):
+    assert c.crc8(b"hello", alias) == c.crc8(b"hello", canonical)
+
+
+def test_case_insensitive_variant_name():
+    assert c.crc8(b"a", "CRC-8") == c.crc8(b"a", "crc-8")
+
+
+def test_underscore_variant_name():
+    assert c.crc8(b"a", "crc_8") == c.crc8(b"a", "crc-8")
+
+
+def test_unknown_variant_raises():
+    with pytest.raises(ValueError):
+        c.crc8(b"a", "crc-99-unknown")
+
+
+# ───────────── Incremental update ─────────────
+
+@pytest.mark.parametrize("variant", VARIANTS)
+def test_incremental_matches_one_shot(variant):
+    full = b"hello world"
+    state = c.crc8(full[:5], variant)
+    state = c.crc8(full[5:], variant, init=state)
+    assert state == c.crc8(full, variant)
+
+
+@pytest.mark.parametrize("variant", VARIANTS)
+def test_incremental_byte_by_byte(variant):
+    data = b"the quick brown fox"
+    full = c.crc8(data, variant)
+    s = None
+    for b in data:
+        if s is None:
+            s = c.crc8(bytes([b]), variant)
+        else:
+            s = c.crc8(bytes([b]), variant, init=s)
+    assert s == full
+
+
+# ───────────── CRC8 class ─────────────
+
+@pytest.mark.parametrize("variant,expected", [
+    ("crc-8",        0xF4),
+    ("crc-8-darc",   0x15),
+    ("crc-8-i-code", 0x7E),
+    ("crc-8-itu",    0xA1),
+    ("crc-8-maxim",  0xA1),
+    ("crc-8-rohc",   0xD0),
+    ("crc-8-wcdma",  0x25),
+])
+def test_class_matches_function_on_123456789(variant, expected):
+    h = c.CRC8(variant=variant)
+    h.update(b"123456789")
+    assert c.crc8(b"123456789", variant) == expected
+    assert h.digest() == bytes([expected])
+    assert h.hexdigest() == f"{expected:02x}"
+
+
+def test_class_incremental_maxim():
+    expected = c.crc8(b"hello", "crc-8-maxim")
+    h = c.CRC8(variant="crc-8-maxim")
+    h.update(b"hel")
+    h.update(b"lo")
+    assert h.digest() == bytes([expected])
+
+
+def test_class_hexdigest_is_lowercase_two_chars():
+    h = c.CRC8(variant="crc-8")
+    h.update(b"\x00")
+    result = h.hexdigest()
+    assert len(result) == 2
+    assert result == result.lower()
+    assert all(ch in "0123456789abcdef" for ch in result)
+
+
+def test_class_empty_maxim():
+    h = c.CRC8(variant="crc-8-maxim")
+    assert h.digest() == b"\x00"
+
+
+def test_class_empty_rohc():
+    h = c.CRC8(variant="crc-8-rohc")
+    assert h.digest() == b"\xff"
+
+
+# ───────────── Range + boundary ─────────────
+
+@pytest.mark.parametrize("variant", VARIANTS)
+def test_single_byte_0x00(variant):
+    expected = c.crc8(b"\x00", variant)
+    assert 0 <= expected <= 255
+
+
+@pytest.mark.parametrize("variant", VARIANTS)
+def test_single_byte_0xff(variant):
+    expected = c.crc8(b"\xff", variant)
+    assert 0 <= expected <= 255
+
+
+@pytest.mark.parametrize("variant", VARIANTS)
+def test_returns_int_type(variant):
+    assert isinstance(c.crc8(b"abc", variant), int)
+
+
+@pytest.mark.parametrize("variant", VARIANTS)
+def test_large_input_1kb(variant):
+    data = b"x" * 1024
+    assert 0 <= c.crc8(data, variant) <= 255
+
+
+@pytest.mark.parametrize("variant", VARIANTS)
+def test_large_input_64kb(variant):
+    data = bytes(range(256)) * 256
+    assert 0 <= c.crc8(data, variant) <= 255
+
+
+# ───────────── Module metadata ─────────────
+
+def test_module_has_version():
+    assert hasattr(c, "__version__")
+    assert c.__version__ == "0.1.0"
+
+
+def test_module_importable():
+    import importlib
+    m = importlib.import_module("crc8_pure")
+    assert m is c
+
+
+def test_seven_variants_implemented():
+    expected = {"crc-8", "crc-8-darc", "crc-8-i-code", "crc-8-itu",
+                "crc-8-maxim", "crc-8-rohc", "crc-8-wcdma"}
+    assert set(c.VARIANTS.keys()) == expected
+
+
+# ───────────── CLI ─────────────
+
+@pytest.mark.parametrize("variant,data,expected", [
+    ("crc-8",        "123456789", "f4"),
+    ("crc-8-maxim",  "123456789", "a1"),
+    ("crc-8-darc",   "a",         "1b"),
+    ("crc-8-itu",    "123456789", "a1"),
+])
+def test_cli_string_input(variant, data, expected):
+    result = subprocess.run(
+        [sys.executable, "-m", "crc8_pure", variant, data],
+        capture_output=True, text=True, check=True,
+    )
+    assert result.stdout.strip() == expected
+
+
+def test_cli_hex_flag():
+    result = subprocess.run(
+        [sys.executable, "-m", "crc8_pure", "crc-8", "123456789", "--hex"],
+        capture_output=True, text=True, check=True,
+    )
+    assert result.stdout.strip() == "0xf4"
+
+
+def test_cli_file_input(tmp_path):
+    f = tmp_path / "data.bin"
+    f.write_bytes(b"123456789")
+    result = subprocess.run(
+        [sys.executable, "-m", "crc8_pure", "crc-8", str(f)],
+        capture_output=True, text=True, check=True,
+    )
+    assert result.stdout.strip() == "f4"
+
+
+def test_cli_stdin_input():
+    result = subprocess.run(
+        [sys.executable, "-m", "crc8_pure", "crc-8", "-"],
+        input=b"123456789", capture_output=True, check=True,
+    )
+    assert result.stdout == b"f4\n"
+
+
+def test_cli_help_exits_zero():
+    result = subprocess.run(
+        [sys.executable, "-m", "crc8_pure", "--help"],
+        capture_output=True, text=True,
+    )
+    assert result.returncode == 0
+    assert "variant" in result.stdout.lower()
+
+
+# ───────────── Determinism ─────────────
+
+@pytest.mark.parametrize("variant", VARIANTS)
+def test_deterministic_same_input(variant):
+    a = c.crc8(b"reproducibility-check", variant)
+    b = c.crc8(b"reproducibility-check", variant)
+    assert a == b
+
+
+# ───────────── Additional: bit-flips change output ─────────────
+
+@pytest.mark.parametrize("variant", VARIANTS)
+def test_bit_flip_changes_crc(variant):
+    base = c.crc8(b"hello", variant)
+    flipped = c.crc8(b"hellp", variant)  # 'o'=0x6F -> 'p'=0x70
+    assert base != flipped