modbus-crc 1.3__tar.gz → 2.0__tar.gz

modbus_crc-2.0/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: modbus-crc
+Version: 2.0
+Summary: CRC-16 calculation for Modbus protocol
+Author-email: Alexey Kuznetsov <webtoucher@ya.ru>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/webtoucher/modbus-crc
+Project-URL: Repository, https://github.com/webtoucher/modbus-crc
+Project-URL: Issues, https://github.com/webtoucher/modbus-crc/issues
+Keywords: modbus,crc,crc16,checksum,serial,rtu
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# Modbus CRC-16
+
+![License](https://img.shields.io/badge/License-BSD%203--Clause-green)
+[![Downloads](https://img.shields.io/pypi/dm/modbus-crc.svg?color=orange)](https://pypi.python.org/pypi/modbus-crc)
+[![Latest Version](https://img.shields.io/pypi/v/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
+[![tests](https://github.com/webtoucher/modbus-crc/actions/workflows/tests.yml/badge.svg)](https://github.com/webtoucher/modbus-crc/actions/workflows/tests.yml)
+
+CRC-16 calculation library for Modbus protocol. Tiny, dependency-free and fast: a single
+256-entry lookup table, no runtime dependencies, type hints included.
+
+## Algorithm
+
+The checksum is **CRC-16/MODBUS**:
+
+| Parameter             | Value                                     |
+|-----------------------|-------------------------------------------|
+| Width                 | 16 bits                                   |
+| Polynomial            | `0x8005` (reflected: `0xA001`)            |
+| Initial value         | `0xFFFF`                                  |
+| Reflect in / out      | yes / yes                                 |
+| Final XOR             | `0x0000`                                  |
+| Check (`"123456789"`)  | `0x4B37`, transmitted as `b'\x37\x4B'`   |
+| Byte order on wire    | low byte first                            |
+
+## Installation
+
+Install it with pip:
+
+```shell
+$ pip install modbus-crc
+```
+
+Or you can add it as dependency in requirements.txt file of your python application:
+
+```
+modbus-crc~=2.0
+```
+
+## Usage
+
+For signing byte package use `add_crc`:
+
+```python
+from modbus_crc import add_crc
+
+signed_package = add_crc(b'\x00\x12\x34\xAB\xCD\xEF')
+```
+
+Result is `b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4'`. For validation signed package use `check_crc`:
+
+```python
+from modbus_crc import check_crc
+
+if not check_crc(b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4'):
+    raise SomeException()
+```
+
+To get the checksum alone (low byte first, exactly as it is transmitted on the wire), use `crc16`:
+
+```python
+from modbus_crc import crc16
+
+crc16(b'\x01\x03\x00\x00\x00\x0A')  # b'\xC5\xCD'
+```
+
+Here is a real Modbus RTU request — "read 10 holding registers from slave 1":
+
+```python
+add_crc(b'\x01\x03\x00\x00\x00\x0A')  # b'\x01\x03\x00\x00\x00\x0A\xC5\xCD'
+```
+
+`check_crc` validates the whole signed frame, so it works with data read straight from
+the serial port, without splitting off the trailing bytes:
+
+```python
+check_crc(b'\x01\x03\x00\x00\x00\x0A\xC5\xCD')  # True
+check_crc(b'\x01\x03\x00\x00\x00\x0A\xC5\xCE')  # False
+```
+
+## API
+
+All three functions accept `bytes`, `bytearray` and `memoryview` (declared as `BytesLike`).
+
+| Function                        | Returns | Description                                                     |
+|---------------------------------|---------|-----------------------------------------------------------------|
+| `crc16(data)`                   | `bytes` | 2-byte checksum of `data`, low byte first                       |
+| `add_crc(package)`              | `bytes` | `package` with the checksum appended; input type is normalized  |
+| `check_crc(package)`            | `bool`  | `True` if `package` carries a valid trailing checksum           |
+
+Notes:
+
+- `add_crc` always returns `bytes`, even for `bytearray` and `memoryview` input.
+- `check_crc(b'')` is `False`: an empty package has no valid checksum.
+- Functions are pure: they keep no state between calls. The lookup table is built once,
+  at import time.
+
+## Compatibility
+
+- Python **3.9 and newer**, including free-threaded builds. Tested on 3.9 and 3.15 and
+  in CI on every version from 3.9 to 3.15.
+- No runtime dependencies.
+- Type hints are shipped with the package (`py.typed`, PEP 561), so mypy and pyright
+  see real signatures instead of `Any`.
+
+## Development
+
+```shell
+$ python -m venv .venv
+$ .venv\Scripts\activate          # Windows; on POSIX: source .venv/bin/activate
+$ pip install -e ".[dev]"          # installs the package and pytest
+$ python -m pytest
+```
+
+The test suite covers:
+
+- canonical Modbus frames with published checksums,
+- an independent bit-by-bit implementation written from the specification, used as an
+  oracle against the fast table-driven code (including random payloads up to 1 KiB),
+- edge cases: empty package, one-byte packages, `bytearray` / `memoryview` input,
+- detection of every single-byte corruption of a signed frame.
+
+Project layout:
+
+```
+modbus_crc/__init__.py    the whole library
+tests/test_modbus_crc.py  test suite
+pyproject.toml            metadata, build config and pytest settings
+.github/workflows/        CI: tests on Python 3.9-3.15, sdist/wheel build check
+```
+
+To build and verify a release:
+
+```shell
+$ pip install build twine
+$ python -m build
+$ python -m twine check dist/*
+```
+
+## Migrating from 1.x
+
+The public API is unchanged, so most projects need no code changes. What did change:
+
+- **Python 3.9+ is required.** Python 2 support and the legacy `setup.py` / `setup.cfg`
+  are gone; metadata now lives in `pyproject.toml` (PEP 621).
+- **`LOW_BYTES` and `HIGH_BYTES` were removed.** Those were two 256-byte tables with
+  inverted naming that leaked from the implementation. The lookup table is now generated
+  at import time and is private — use the documented functions instead.
+- **`add_crc` always returns `bytes`.** Previously `add_crc(bytearray(...))` returned a
+  `bytearray`; the result type is now stable regardless of the input type.
+- **`modbus_crc.__version__` is available** and is the single source of truth for the
+  package version.
+- **The package ships `py.typed`**, so type checkers no longer treat it as untyped.
+- **Faster and clearer internals:** one table instead of two, a single 16-bit register
+  instead of two byte variables, no `int()` call per byte (over 20% faster per KB on
+  CPython 3.11).
+
+## License
+
+Distributed under the BSD 3-Clause license. See [LICENSE.md](LICENSE.md) for details.

modbus_crc-2.0/README.md

@@ -0,0 +1,160 @@
+# Modbus CRC-16
+
+![License](https://img.shields.io/badge/License-BSD%203--Clause-green)
+[![Downloads](https://img.shields.io/pypi/dm/modbus-crc.svg?color=orange)](https://pypi.python.org/pypi/modbus-crc)
+[![Latest Version](https://img.shields.io/pypi/v/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
+[![tests](https://github.com/webtoucher/modbus-crc/actions/workflows/tests.yml/badge.svg)](https://github.com/webtoucher/modbus-crc/actions/workflows/tests.yml)
+
+CRC-16 calculation library for Modbus protocol. Tiny, dependency-free and fast: a single
+256-entry lookup table, no runtime dependencies, type hints included.
+
+## Algorithm
+
+The checksum is **CRC-16/MODBUS**:
+
+| Parameter             | Value                                     |
+|-----------------------|-------------------------------------------|
+| Width                 | 16 bits                                   |
+| Polynomial            | `0x8005` (reflected: `0xA001`)            |
+| Initial value         | `0xFFFF`                                  |
+| Reflect in / out      | yes / yes                                 |
+| Final XOR             | `0x0000`                                  |
+| Check (`"123456789"`)  | `0x4B37`, transmitted as `b'\x37\x4B'`   |
+| Byte order on wire    | low byte first                            |
+
+## Installation
+
+Install it with pip:
+
+```shell
+$ pip install modbus-crc
+```
+
+Or you can add it as dependency in requirements.txt file of your python application:
+
+```
+modbus-crc~=2.0
+```
+
+## Usage
+
+For signing byte package use `add_crc`:
+
+```python
+from modbus_crc import add_crc
+
+signed_package = add_crc(b'\x00\x12\x34\xAB\xCD\xEF')
+```
+
+Result is `b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4'`. For validation signed package use `check_crc`:
+
+```python
+from modbus_crc import check_crc
+
+if not check_crc(b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4'):
+    raise SomeException()
+```
+
+To get the checksum alone (low byte first, exactly as it is transmitted on the wire), use `crc16`:
+
+```python
+from modbus_crc import crc16
+
+crc16(b'\x01\x03\x00\x00\x00\x0A')  # b'\xC5\xCD'
+```
+
+Here is a real Modbus RTU request — "read 10 holding registers from slave 1":
+
+```python
+add_crc(b'\x01\x03\x00\x00\x00\x0A')  # b'\x01\x03\x00\x00\x00\x0A\xC5\xCD'
+```
+
+`check_crc` validates the whole signed frame, so it works with data read straight from
+the serial port, without splitting off the trailing bytes:
+
+```python
+check_crc(b'\x01\x03\x00\x00\x00\x0A\xC5\xCD')  # True
+check_crc(b'\x01\x03\x00\x00\x00\x0A\xC5\xCE')  # False
+```
+
+## API
+
+All three functions accept `bytes`, `bytearray` and `memoryview` (declared as `BytesLike`).
+
+| Function                        | Returns | Description                                                     |
+|---------------------------------|---------|-----------------------------------------------------------------|
+| `crc16(data)`                   | `bytes` | 2-byte checksum of `data`, low byte first                       |
+| `add_crc(package)`              | `bytes` | `package` with the checksum appended; input type is normalized  |
+| `check_crc(package)`            | `bool`  | `True` if `package` carries a valid trailing checksum           |
+
+Notes:
+
+- `add_crc` always returns `bytes`, even for `bytearray` and `memoryview` input.
+- `check_crc(b'')` is `False`: an empty package has no valid checksum.
+- Functions are pure: they keep no state between calls. The lookup table is built once,
+  at import time.
+
+## Compatibility
+
+- Python **3.9 and newer**, including free-threaded builds. Tested on 3.9 and 3.15 and
+  in CI on every version from 3.9 to 3.15.
+- No runtime dependencies.
+- Type hints are shipped with the package (`py.typed`, PEP 561), so mypy and pyright
+  see real signatures instead of `Any`.
+
+## Development
+
+```shell
+$ python -m venv .venv
+$ .venv\Scripts\activate          # Windows; on POSIX: source .venv/bin/activate
+$ pip install -e ".[dev]"          # installs the package and pytest
+$ python -m pytest
+```
+
+The test suite covers:
+
+- canonical Modbus frames with published checksums,
+- an independent bit-by-bit implementation written from the specification, used as an
+  oracle against the fast table-driven code (including random payloads up to 1 KiB),
+- edge cases: empty package, one-byte packages, `bytearray` / `memoryview` input,
+- detection of every single-byte corruption of a signed frame.
+
+Project layout:
+
+```
+modbus_crc/__init__.py    the whole library
+tests/test_modbus_crc.py  test suite
+pyproject.toml            metadata, build config and pytest settings
+.github/workflows/        CI: tests on Python 3.9-3.15, sdist/wheel build check
+```
+
+To build and verify a release:
+
+```shell
+$ pip install build twine
+$ python -m build
+$ python -m twine check dist/*
+```
+
+## Migrating from 1.x
+
+The public API is unchanged, so most projects need no code changes. What did change:
+
+- **Python 3.9+ is required.** Python 2 support and the legacy `setup.py` / `setup.cfg`
+  are gone; metadata now lives in `pyproject.toml` (PEP 621).
+- **`LOW_BYTES` and `HIGH_BYTES` were removed.** Those were two 256-byte tables with
+  inverted naming that leaked from the implementation. The lookup table is now generated
+  at import time and is private — use the documented functions instead.
+- **`add_crc` always returns `bytes`.** Previously `add_crc(bytearray(...))` returned a
+  `bytearray`; the result type is now stable regardless of the input type.
+- **`modbus_crc.__version__` is available** and is the single source of truth for the
+  package version.
+- **The package ships `py.typed`**, so type checkers no longer treat it as untyped.
+- **Faster and clearer internals:** one table instead of two, a single 16-bit register
+  instead of two byte variables, no `int()` call per byte (over 20% faster per KB on
+  CPython 3.11).
+
+## License
+
+Distributed under the BSD 3-Clause license. See [LICENSE.md](LICENSE.md) for details.

modbus_crc-2.0/modbus_crc/__init__.py

@@ -0,0 +1,55 @@
+"""
+CRC-16 calculation for the Modbus protocol.
+
+The checksum is CRC-16/MODBUS: polynomial 0xA001 (reflected 0x8005),
+initial value 0xFFFF, no final XOR, transmitted low byte first.
+
+Copyright (c) 2026 webtoucher
+Distributed under the BSD 3-Clause license. See LICENSE for more info.
+"""
+
+from typing import Union
+
+__all__ = ["crc16", "add_crc", "check_crc"]
+
+__version__ = "2.0"
+
+BytesLike = Union[bytes, bytearray, memoryview]
+
+
+def _build_crc_table(polynomial: int = 0xA001) -> tuple:
+    """Build the 256-entry lookup table for CRC-16/MODBUS."""
+    table = []
+    for index in range(256):
+        crc = index
+        for _ in range(8):
+            crc = (crc >> 1) ^ polynomial if crc & 1 else crc >> 1
+        table.append(crc)
+    return tuple(table)
+
+
+_CRC_TABLE = _build_crc_table()
+
+
+def _crc_register(data: BytesLike) -> int:
+    """Return the raw 16-bit CRC register value of data."""
+    crc = 0xFFFF
+    for byte in data:
+        crc = (crc >> 8) ^ _CRC_TABLE[(crc ^ byte) & 0xFF]
+    return crc
+
+
+def crc16(data: BytesLike) -> bytes:
+    """Calculate CRC-16/MODBUS of data, low byte first as on the wire."""
+    crc = _crc_register(data)
+    return bytes((crc & 0xFF, crc >> 8))
+
+
+def add_crc(package: BytesLike) -> bytes:
+    """Return package with CRC-16/MODBUS appended."""
+    return bytes(package) + crc16(package)
+
+
+def check_crc(package: BytesLike) -> bool:
+    """Return True if package carries a valid trailing CRC-16/MODBUS."""
+    return _crc_register(package) == 0

modbus_crc-2.0/modbus_crc.egg-info/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: modbus-crc
+Version: 2.0
+Summary: CRC-16 calculation for Modbus protocol
+Author-email: Alexey Kuznetsov <webtoucher@ya.ru>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/webtoucher/modbus-crc
+Project-URL: Repository, https://github.com/webtoucher/modbus-crc
+Project-URL: Issues, https://github.com/webtoucher/modbus-crc/issues
+Keywords: modbus,crc,crc16,checksum,serial,rtu
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# Modbus CRC-16
+
+![License](https://img.shields.io/badge/License-BSD%203--Clause-green)
+[![Downloads](https://img.shields.io/pypi/dm/modbus-crc.svg?color=orange)](https://pypi.python.org/pypi/modbus-crc)
+[![Latest Version](https://img.shields.io/pypi/v/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
+[![tests](https://github.com/webtoucher/modbus-crc/actions/workflows/tests.yml/badge.svg)](https://github.com/webtoucher/modbus-crc/actions/workflows/tests.yml)
+
+CRC-16 calculation library for Modbus protocol. Tiny, dependency-free and fast: a single
+256-entry lookup table, no runtime dependencies, type hints included.
+
+## Algorithm
+
+The checksum is **CRC-16/MODBUS**:
+
+| Parameter             | Value                                     |
+|-----------------------|-------------------------------------------|
+| Width                 | 16 bits                                   |
+| Polynomial            | `0x8005` (reflected: `0xA001`)            |
+| Initial value         | `0xFFFF`                                  |
+| Reflect in / out      | yes / yes                                 |
+| Final XOR             | `0x0000`                                  |
+| Check (`"123456789"`)  | `0x4B37`, transmitted as `b'\x37\x4B'`   |
+| Byte order on wire    | low byte first                            |
+
+## Installation
+
+Install it with pip:
+
+```shell
+$ pip install modbus-crc
+```
+
+Or you can add it as dependency in requirements.txt file of your python application:
+
+```
+modbus-crc~=2.0
+```
+
+## Usage
+
+For signing byte package use `add_crc`:
+
+```python
+from modbus_crc import add_crc
+
+signed_package = add_crc(b'\x00\x12\x34\xAB\xCD\xEF')
+```
+
+Result is `b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4'`. For validation signed package use `check_crc`:
+
+```python
+from modbus_crc import check_crc
+
+if not check_crc(b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4'):
+    raise SomeException()
+```
+
+To get the checksum alone (low byte first, exactly as it is transmitted on the wire), use `crc16`:
+
+```python
+from modbus_crc import crc16
+
+crc16(b'\x01\x03\x00\x00\x00\x0A')  # b'\xC5\xCD'
+```
+
+Here is a real Modbus RTU request — "read 10 holding registers from slave 1":
+
+```python
+add_crc(b'\x01\x03\x00\x00\x00\x0A')  # b'\x01\x03\x00\x00\x00\x0A\xC5\xCD'
+```
+
+`check_crc` validates the whole signed frame, so it works with data read straight from
+the serial port, without splitting off the trailing bytes:
+
+```python
+check_crc(b'\x01\x03\x00\x00\x00\x0A\xC5\xCD')  # True
+check_crc(b'\x01\x03\x00\x00\x00\x0A\xC5\xCE')  # False
+```
+
+## API
+
+All three functions accept `bytes`, `bytearray` and `memoryview` (declared as `BytesLike`).
+
+| Function                        | Returns | Description                                                     |
+|---------------------------------|---------|-----------------------------------------------------------------|
+| `crc16(data)`                   | `bytes` | 2-byte checksum of `data`, low byte first                       |
+| `add_crc(package)`              | `bytes` | `package` with the checksum appended; input type is normalized  |
+| `check_crc(package)`            | `bool`  | `True` if `package` carries a valid trailing checksum           |
+
+Notes:
+
+- `add_crc` always returns `bytes`, even for `bytearray` and `memoryview` input.
+- `check_crc(b'')` is `False`: an empty package has no valid checksum.
+- Functions are pure: they keep no state between calls. The lookup table is built once,
+  at import time.
+
+## Compatibility
+
+- Python **3.9 and newer**, including free-threaded builds. Tested on 3.9 and 3.15 and
+  in CI on every version from 3.9 to 3.15.
+- No runtime dependencies.
+- Type hints are shipped with the package (`py.typed`, PEP 561), so mypy and pyright
+  see real signatures instead of `Any`.
+
+## Development
+
+```shell
+$ python -m venv .venv
+$ .venv\Scripts\activate          # Windows; on POSIX: source .venv/bin/activate
+$ pip install -e ".[dev]"          # installs the package and pytest
+$ python -m pytest
+```
+
+The test suite covers:
+
+- canonical Modbus frames with published checksums,
+- an independent bit-by-bit implementation written from the specification, used as an
+  oracle against the fast table-driven code (including random payloads up to 1 KiB),
+- edge cases: empty package, one-byte packages, `bytearray` / `memoryview` input,
+- detection of every single-byte corruption of a signed frame.
+
+Project layout:
+
+```
+modbus_crc/__init__.py    the whole library
+tests/test_modbus_crc.py  test suite
+pyproject.toml            metadata, build config and pytest settings
+.github/workflows/        CI: tests on Python 3.9-3.15, sdist/wheel build check
+```
+
+To build and verify a release:
+
+```shell
+$ pip install build twine
+$ python -m build
+$ python -m twine check dist/*
+```
+
+## Migrating from 1.x
+
+The public API is unchanged, so most projects need no code changes. What did change:
+
+- **Python 3.9+ is required.** Python 2 support and the legacy `setup.py` / `setup.cfg`
+  are gone; metadata now lives in `pyproject.toml` (PEP 621).
+- **`LOW_BYTES` and `HIGH_BYTES` were removed.** Those were two 256-byte tables with
+  inverted naming that leaked from the implementation. The lookup table is now generated
+  at import time and is private — use the documented functions instead.
+- **`add_crc` always returns `bytes`.** Previously `add_crc(bytearray(...))` returned a
+  `bytearray`; the result type is now stable regardless of the input type.
+- **`modbus_crc.__version__` is available** and is the single source of truth for the
+  package version.
+- **The package ships `py.typed`**, so type checkers no longer treat it as untyped.
+- **Faster and clearer internals:** one table instead of two, a single 16-bit register
+  instead of two byte variables, no `int()` call per byte (over 20% faster per KB on
+  CPython 3.11).
+
+## License
+
+Distributed under the BSD 3-Clause license. See [LICENSE.md](LICENSE.md) for details.

{modbus-crc-1.3 → modbus_crc-2.0}/modbus_crc.egg-info/SOURCES.txt

@@ -1,11 +1,12 @@
 LICENSE.md
-MANIFEST.in
 README.md
-setup.cfg
-setup.py
+pyproject.toml
 modbus_crc/__init__.py
+modbus_crc/py.typed
 modbus_crc.egg-info/PKG-INFO
 modbus_crc.egg-info/SOURCES.txt
 modbus_crc.egg-info/dependency_links.txt
 modbus_crc.egg-info/not-zip-safe
-modbus_crc.egg-info/top_level.txt
+modbus_crc.egg-info/requires.txt
+modbus_crc.egg-info/top_level.txt
+tests/test_modbus_crc.py

{modbus-crc-1.3 → modbus_crc-2.0}/modbus_crc.egg-info/not-zip-safe

@@ -1 +1 @@
-
+

modbus_crc-2.0/modbus_crc.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7

modbus_crc-2.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "modbus-crc"
+description = "CRC-16 calculation for Modbus protocol"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "BSD-3-Clause"
+license-files = ["LICENSE.md"]
+authors = [
+    { name = "Alexey Kuznetsov", email = "webtoucher@ya.ru" },
+]
+keywords = ["modbus", "crc", "crc16", "checksum", "serial", "rtu"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX",
+    "Operating System :: Unix",
+    "Operating System :: MacOS",
+    "Typing :: Typed",
+]
+dynamic = ["version"]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=7"]
+
+[project.urls]
+Homepage = "https://github.com/webtoucher/modbus-crc"
+Repository = "https://github.com/webtoucher/modbus-crc"
+Issues = "https://github.com/webtoucher/modbus-crc/issues"
+
+[tool.setuptools]
+packages = ["modbus_crc"]
+zip-safe = false
+
+[tool.setuptools.dynamic]
+version = { attr = "modbus_crc.__version__" }
+
+[tool.setuptools.package-data]
+modbus_crc = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"

modbus_crc-2.0/setup.cfg

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

modbus_crc-2.0/tests/test_modbus_crc.py

@@ -0,0 +1,80 @@
+"""Tests for the modbus_crc package."""
+
+import random
+
+import pytest
+
+from modbus_crc import __all__, add_crc, check_crc, crc16
+
+# Frame without checksum and the checksum exactly as it goes on the wire
+# (low byte first). The first three frames are canonical Modbus examples.
+KNOWN_FRAMES = [
+    (b"\x01\x03\x00\x00\x00\x0A", b"\xC5\xCD"),
+    (b"\x11\x03\x00\x6B\x00\x03", b"\x76\x87"),
+    (b"\x00\x12\x34\xAB\xCD\xEF", b"\xD2\xD4"),
+    (b"\xFF" * 8, b"\x01\x8F"),
+    (b"\x00", b"\xBF\x40"),
+    (b"\xFF", b"\xFF\x00"),
+    (b"", b"\xFF\xFF"),
+]
+
+
+def _reference_crc16(data: bytes) -> bytes:
+    """Bit-by-bit CRC-16/MODBUS, written straight from the protocol spec."""
+    crc = 0xFFFF
+    for byte in data:
+        crc ^= byte
+        for _ in range(8):
+            crc = (crc >> 1) ^ 0xA001 if crc & 1 else crc >> 1
+    return bytes((crc & 0xFF, crc >> 8))
+
+
+@pytest.mark.parametrize("frame, checksum", KNOWN_FRAMES)
+def test_known_frames(frame, checksum):
+    assert crc16(frame) == checksum
+    assert add_crc(frame) == frame + checksum
+    assert check_crc(frame + checksum)
+
+
+@pytest.mark.parametrize("frame, checksum", KNOWN_FRAMES)
+def test_reference_oracle_agrees_with_known_frames(frame, checksum):
+    assert _reference_crc16(frame) == checksum
+
+
+def test_table_matches_reference_implementation():
+    rng = random.Random(20231115)
+    for length in [0, 1, 2, 3, 8, 32, 255, 1024]:
+        data = bytes(rng.randrange(256) for _ in range(length))
+        assert crc16(data) == _reference_crc16(data)
+
+
+def test_empty_package_is_rejected():
+    assert not check_crc(b"")
+
+
+def test_corrupted_package_is_rejected():
+    signed = add_crc(b"\x01\x03\x00\x00\x00\x0A")
+    for index in range(len(signed)):
+        corrupted = bytearray(signed)
+        corrupted[index] ^= 0x01
+        assert not check_crc(corrupted), f"corruption at byte {index} not detected"
+
+
+def test_unsigned_package_is_rejected():
+    assert not check_crc(b"\x01\x03\x00\x00\x00\x0A")
+
+
+def test_accepts_bytes_like_objects():
+    payload = b"\x01\x03\x00\x00\x00\x0A"
+    assert crc16(bytearray(payload)) == crc16(payload)
+    assert crc16(memoryview(payload)) == crc16(payload)
+    assert isinstance(add_crc(bytearray(payload)), bytes)
+
+
+def test_checksum_is_two_bytes():
+    assert crc16(b"\x01\x03") == crc16(b"\x01\x03")
+    assert len(crc16(b"\x01\x03")) == 2
+
+
+def test_public_api_is_explicit():
+    assert __all__ == ["crc16", "add_crc", "check_crc"]

modbus-crc-1.3/MANIFEST.in

@@ -1,2 +0,0 @@
-include LICENSE.md
-include README.md

modbus-crc-1.3/PKG-INFO

@@ -1,67 +0,0 @@
-Metadata-Version: 2.1
-Name: modbus-crc
-Version: 1.3
-Summary: CRC-16 calculation for Modbus protocol
-Home-page: https://github.com/webtoucher/modbus-crc
-Author: Alexey Kuznetsov
-Author-email: mirakuru@webtoucher.ru
-License: BSD-3-Clause
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX
-Classifier: Operating System :: Unix
-Classifier: Operating System :: MacOS
-Description-Content-Type: text/markdown
-License-File: LICENSE.md
-
-# Modbus CRC-16
-
-![License](https://img.shields.io/badge/License-BSD%203--Clause-green)
-[![Downloads](https://img.shields.io/pypi/dm/modbus-crc.svg?color=orange)](https://pypi.python.org/pypi/modbus-crc)
-[![Latest Version](https://img.shields.io/pypi/v/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
-[![Supported Python versions](https://img.shields.io/pypi/pyversions/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
-
-CRC-16 calculation library for Modbus protocol
-
-## Installation
-
-Install it with pip:
-
-```shell
-$ pip install modbus-crc
-```
-
-Or you can add it as dependency in requirements.txt file of your python application:
-
-```
-modbus-crc~=1.3
-```
-
-## Usage
-
-For signing byte package use `add_crc`:
-
-```python
-from modbus_crc import add_crc
-
-signed_package = add_crc(b'\x00\x12\x34\xAB\xCD\xEF')
-```
-
-Result is `b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4`. For validation signed package use `check_crc`:
-
-```python
-from modbus_crc import check_crc
-
-if not check_crc(b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4'):
-    raise SomeException()
-```
-
-## Testing
-
-```shell
-$ python -m unittest discover -v -p "tests.py"
-```

modbus-crc-1.3/README.md

@@ -1,47 +0,0 @@
-# Modbus CRC-16
-
-![License](https://img.shields.io/badge/License-BSD%203--Clause-green)
-[![Downloads](https://img.shields.io/pypi/dm/modbus-crc.svg?color=orange)](https://pypi.python.org/pypi/modbus-crc)
-[![Latest Version](https://img.shields.io/pypi/v/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
-[![Supported Python versions](https://img.shields.io/pypi/pyversions/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
-
-CRC-16 calculation library for Modbus protocol
-
-## Installation
-
-Install it with pip:
-
-```shell
-$ pip install modbus-crc
-```
-
-Or you can add it as dependency in requirements.txt file of your python application:
-
-```
-modbus-crc~=1.3
-```
-
-## Usage
-
-For signing byte package use `add_crc`:
-
-```python
-from modbus_crc import add_crc
-
-signed_package = add_crc(b'\x00\x12\x34\xAB\xCD\xEF')
-```
-
-Result is `b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4`. For validation signed package use `check_crc`:
-
-```python
-from modbus_crc import check_crc
-
-if not check_crc(b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4'):
-    raise SomeException()
-```
-
-## Testing
-
-```shell
-$ python -m unittest discover -v -p "tests.py"
-```

modbus-crc-1.3/modbus_crc/__init__.py

@@ -1,69 +0,0 @@
-# coding=utf8
-"""
-CRC-16 calculation for Modbus protocol
-Copyright (c) 2023 webtoucher
-Distributed under the BSD 3-Clause license. See LICENSE for more info.
-"""
-
-LOW_BYTES = b'\
-\x00\xC0\xC1\x01\xC3\x03\x02\xC2\xC6\x06\x07\xC7\x05\xC5\xC4\x04\
-\xCC\x0C\x0D\xCD\x0F\xCF\xCE\x0E\x0A\xCA\xCB\x0B\xC9\x09\x08\xC8\
-\xD8\x18\x19\xD9\x1B\xDB\xDA\x1A\x1E\xDE\xDF\x1F\xDD\x1D\x1C\xDC\
-\x14\xD4\xD5\x15\xD7\x17\x16\xD6\xD2\x12\x13\xD3\x11\xD1\xD0\x10\
-\xF0\x30\x31\xF1\x33\xF3\xF2\x32\x36\xF6\xF7\x37\xF5\x35\x34\xF4\
-\x3C\xFC\xFD\x3D\xFF\x3F\x3E\xFE\xFA\x3A\x3B\xFB\x39\xF9\xF8\x38\
-\x28\xE8\xE9\x29\xEB\x2B\x2A\xEA\xEE\x2E\x2F\xEF\x2D\xED\xEC\x2C\
-\xE4\x24\x25\xE5\x27\xE7\xE6\x26\x22\xE2\xE3\x23\xE1\x21\x20\xE0\
-\xA0\x60\x61\xA1\x63\xA3\xA2\x62\x66\xA6\xA7\x67\xA5\x65\x64\xA4\
-\x6C\xAC\xAD\x6D\xAF\x6F\x6E\xAE\xAA\x6A\x6B\xAB\x69\xA9\xA8\x68\
-\x78\xB8\xB9\x79\xBB\x7B\x7A\xBA\xBE\x7E\x7F\xBF\x7D\xBD\xBC\x7C\
-\xB4\x74\x75\xB5\x77\xB7\xB6\x76\x72\xB2\xB3\x73\xB1\x71\x70\xB0\
-\x50\x90\x91\x51\x93\x53\x52\x92\x96\x56\x57\x97\x55\x95\x94\x54\
-\x9C\x5C\x5D\x9D\x5F\x9F\x9E\x5E\x5A\x9A\x9B\x5B\x99\x59\x58\x98\
-\x88\x48\x49\x89\x4B\x8B\x8A\x4A\x4E\x8E\x8F\x4F\x8D\x4D\x4C\x8C\
-\x44\x84\x85\x45\x87\x47\x46\x86\x82\x42\x43\x83\x41\x81\x80\x40'
-
-HIGH_BYTES = b'\
-\x00\xC1\x81\x40\x01\xC0\x80\x41\x01\xC0\x80\x41\x00\xC1\x81\x40\
-\x01\xC0\x80\x41\x00\xC1\x81\x40\x00\xC1\x81\x40\x01\xC0\x80\x41\
-\x01\xC0\x80\x41\x00\xC1\x81\x40\x00\xC1\x81\x40\x01\xC0\x80\x41\
-\x00\xC1\x81\x40\x01\xC0\x80\x41\x01\xC0\x80\x41\x00\xC1\x81\x40\
-\x01\xC0\x80\x41\x00\xC1\x81\x40\x00\xC1\x81\x40\x01\xC0\x80\x41\
-\x00\xC1\x81\x40\x01\xC0\x80\x41\x01\xC0\x80\x41\x00\xC1\x81\x40\
-\x00\xC1\x81\x40\x01\xC0\x80\x41\x01\xC0\x80\x41\x00\xC1\x81\x40\
-\x01\xC0\x80\x41\x00\xC1\x81\x40\x00\xC1\x81\x40\x01\xC0\x80\x41\
-\x01\xC0\x80\x41\x00\xC1\x81\x40\x00\xC1\x81\x40\x01\xC0\x80\x41\
-\x00\xC1\x81\x40\x01\xC0\x80\x41\x01\xC0\x80\x41\x00\xC1\x81\x40\
-\x00\xC1\x81\x40\x01\xC0\x80\x41\x01\xC0\x80\x41\x00\xC1\x81\x40\
-\x01\xC0\x80\x41\x00\xC1\x81\x40\x00\xC1\x81\x40\x01\xC0\x80\x41\
-\x00\xC1\x81\x40\x01\xC0\x80\x41\x01\xC0\x80\x41\x00\xC1\x81\x40\
-\x01\xC0\x80\x41\x00\xC1\x81\x40\x00\xC1\x81\x40\x01\xC0\x80\x41\
-\x01\xC0\x80\x41\x00\xC1\x81\x40\x00\xC1\x81\x40\x01\xC0\x80\x41\
-\x00\xC1\x81\x40\x01\xC0\x80\x41\x01\xC0\x80\x41\x00\xC1\x81\x40'
-
-
-def crc16(data: bytes) -> bytes:
-    """Calculate CRC-16 for Modbus."""
-    crc_high = 0xFF
-    crc_low = 0xFF
-
-    for byte in data:
-        index = crc_high ^ int(byte)
-        crc_high = crc_low ^ HIGH_BYTES[index]
-        crc_low = LOW_BYTES[index]
-
-    return bytes([crc_high, crc_low])
-
-
-def add_crc(package: bytes) -> bytes:
-    """Add CRC-16 to bytes package."""
-    return package + crc16(package)
-
-
-def check_crc(package: bytes) -> bool:
-    """Validate signed bytes package."""
-    return crc16(package) == b'\x00\x00'
-
-
-if __name__ == "__main__":
-    pass

modbus-crc-1.3/modbus_crc.egg-info/PKG-INFO

@@ -1,67 +0,0 @@
-Metadata-Version: 2.1
-Name: modbus-crc
-Version: 1.3
-Summary: CRC-16 calculation for Modbus protocol
-Home-page: https://github.com/webtoucher/modbus-crc
-Author: Alexey Kuznetsov
-Author-email: mirakuru@webtoucher.ru
-License: BSD-3-Clause
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: POSIX
-Classifier: Operating System :: Unix
-Classifier: Operating System :: MacOS
-Description-Content-Type: text/markdown
-License-File: LICENSE.md
-
-# Modbus CRC-16
-
-![License](https://img.shields.io/badge/License-BSD%203--Clause-green)
-[![Downloads](https://img.shields.io/pypi/dm/modbus-crc.svg?color=orange)](https://pypi.python.org/pypi/modbus-crc)
-[![Latest Version](https://img.shields.io/pypi/v/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
-[![Supported Python versions](https://img.shields.io/pypi/pyversions/modbus-crc.svg)](https://pypi.python.org/pypi/modbus-crc)
-
-CRC-16 calculation library for Modbus protocol
-
-## Installation
-
-Install it with pip:
-
-```shell
-$ pip install modbus-crc
-```
-
-Or you can add it as dependency in requirements.txt file of your python application:
-
-```
-modbus-crc~=1.3
-```
-
-## Usage
-
-For signing byte package use `add_crc`:
-
-```python
-from modbus_crc import add_crc
-
-signed_package = add_crc(b'\x00\x12\x34\xAB\xCD\xEF')
-```
-
-Result is `b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4`. For validation signed package use `check_crc`:
-
-```python
-from modbus_crc import check_crc
-
-if not check_crc(b'\x00\x12\x34\xAB\xCD\xEF\xD2\xD4'):
-    raise SomeException()
-```
-
-## Testing
-
-```shell
-$ python -m unittest discover -v -p "tests.py"
-```

modbus-crc-1.3/setup.cfg

@@ -1,8 +0,0 @@
-[nosetests]
-verbose = 1
-nocapture = 1
-
-[egg_info]
-tag_build = 
-tag_date = 0
-

modbus-crc-1.3/setup.py

@@ -1,24 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(name='modbus-crc',
-      version='1.3',
-      url='https://github.com/webtoucher/modbus-crc',
-      license='BSD-3-Clause',
-      author='Alexey Kuznetsov',
-      author_email='mirakuru@webtoucher.ru',
-      description='CRC-16 calculation for Modbus protocol',
-      classifiers=[
-          'Development Status :: 5 - Production/Stable',
-          'Intended Audience :: Developers',
-          'Topic :: Software Development :: Libraries',
-          'License :: OSI Approved :: BSD License',
-          'Programming Language :: Python :: 3',
-          'Operating System :: Microsoft :: Windows',
-          'Operating System :: POSIX',
-          'Operating System :: Unix',
-          'Operating System :: MacOS',
-      ],
-      packages=['modbus_crc'],
-      long_description=open('README.md').read(),
-      long_description_content_type='text/markdown',
-      zip_safe=False)