pydigi 1.0.0__tar.gz

pydigi-1.0.0/LICENSE

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

pydigi-1.0.0/PKG-INFO

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: pydigi
+Version: 1.0.0
+Summary: Read weight, price and status from DIGI scales over RS-232.
+Author-email: Pavel Kim <hello@pavelkim.com>
+License: MIT
+Project-URL: Homepage, https://github.com/for-digi/pydigi
+Keywords: digi,scale,rs232,serial,weight,ds-781,measuring,pos,point-of-sale
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyserial<4,>=3.0
+Provides-Extra: test
+Requires-Dist: pytest<10,>=7.0; extra == "test"
+Requires-Dist: PyYAML<7,>=6; extra == "test"
+Provides-Extra: hil
+Requires-Dist: PyYAML<7,>=6; extra == "hil"
+Dynamic: license-file
+
+# PyDIGI — read DIGI scales from Python
+
+`pydigi` reads weight, price and status from DIGI retail scales over RS-232.
+
+- **Supported models:** DIGI DS-781 (Type B / Standard command protocol).
+- **Python:** 3.8+ (see [DESIGN.md §8](DESIGN.md) for why 2.x is out of scope).
+- **Dependency:** [pyserial](https://pypi.org/project/pyserial/) (only for real ports).
+- Layered so more models, protocol types, and transports slot in **without
+  rewrites** — see [Extending](#extending) and [DESIGN.md](DESIGN.md).
+
+## Install
+
+```bash
+pip install .                 # library + pyserial
+pip install '.[test]'         # + pytest, PyYAML (to run the test suite)
+pip install '.[hil]'          # + PyYAML (for the hardware-in-the-loop tooling)
+```
+
+Or build a wheel/sdist (see [Development](#development)) and
+`pip install dist/pydigi-*.whl`. Not published to PyPI.
+
+## Quick start
+
+```python
+from pydigi import DigiDS781
+
+with DigiDS781.open("/dev/ttyUSB0") as scale:      # COM3 on Windows
+    r = scale.read()
+    print(r.weight_net_kg, "kg", "stable" if r.is_stable else "moving")
+```
+
+`DigiDS781.open(port, baudrate=..., parity=..., stopbits=..., timeout=...,
+rtscts=...)` — extra keywords pass through to the serial config. `open()`
+returns a ready scale and is also a context manager.
+
+## What a reading contains
+
+`scale.read()` returns an immutable `ScaleReading`:
+
+| Field | Meaning |
+|---|---|
+| `weight_net_kg` / `weight_tare_kg` | net (post-tare) and stored tare weight |
+| `weight_gross_kg` | derived `net + tare` (always consistent) |
+| `unit_price` / `total_price` | price per `price_base`, and net × unit |
+| `price_base` | `PriceBase` enum (`$/kg`, `$/100g`, `$/lb`, `$/(1/4)lb`) |
+| `is_stable` `is_net` `is_zero` `is_negative` | condition booleans |
+| `weight_overflow` `weight_underflow` `total_price_overflow` | range flags |
+| `raw_hex` | the source frame, for diagnostics |
+
+Values the scale did not send (overflow, underflow, no PLU) are **`None`**,
+never a fake `0.0`. `reading.as_dict()` gives a JSON-friendly view.
+
+## Continuous reading & change-watch
+
+```python
+for reading in scale.stream(interval=0.2):          # every poll
+    print(reading.weight_gross_kg)
+```
+
+`watch()` yields only when a field you care about changes — you **tick the
+fields** with a `ChangeFilter`:
+
+```python
+from pydigi import ChangeFilter, Field
+
+watch_weight = ChangeFilter.weight(min_delta_kg=0.005, stable_only=True)  # the default
+for reading in scale.watch(interval=0.2, change_filter=watch_weight):
+    print("weight ->", reading.weight_gross_kg, "kg")
+
+ChangeFilter([Field.NET, Field.TARE, Field.UNIT_PRICE])   # several fields
+ChangeFilter.everything()                                 # any field, flags included
+```
+
+For long-running loops, `stream(..., ignore_errors=True, on_error=cb)` keeps
+going through transient timeouts instead of raising.
+
+Runnable examples: [single_reading.py](examples/single_reading.py),
+[continuous_reading.py](examples/continuous_reading.py), and
+[offline_demo.py](examples/offline_demo.py) (no hardware).
+
+## Errors
+
+All exceptions derive from `PyDigiError`:
+
+```
+PyDigiError
+├── TransportError        # port open/read/write failed
+│   └── ScaleTimeout      # no response within timeout / after retries
+└── FrameError            # a frame arrived but was malformed
+    ├── ShortFrameError · HeaderError · FieldParseError · ParityError
+```
+
+Catch `PyDigiError` broadly, `ScaleTimeout` to retry, or `FrameError` to
+log-and-skip a garbled frame in a stream without tearing down the port.
+
+## Testing without hardware
+
+The serial layer is a pluggable `Transport`. Swap in `LoopbackTransport` (which
+replays canned bytes) and `bind()` to a scale — no port required:
+
+```python
+from pydigi import DigiDS781, LoopbackTransport
+
+with DigiDS781.bind(LoopbackTransport(my_frame_bytes)) as scale:
+    print(scale.read().weight_net_kg)
+```
+
+This is exactly how the test suite runs. A complete, runnable version (which
+synthesises frames) is [examples/offline_demo.py](examples/offline_demo.py); the
+testing workflow is in [TESTING.md](TESTING.md).
+
+## Command line
+
+```bash
+pydigi --port /dev/ttyUSB0 read                       # one reading
+pydigi --port /dev/ttyUSB0 read --json                # machine-readable
+pydigi --port /dev/ttyUSB0 stream --interval 0.5 --count 10
+pydigi --port /dev/ttyUSB0 watch --stable-only        # weight changes only
+pydigi --port /dev/ttyUSB0 watch --field tare --field unit-price
+pydigi --port /dev/ttyUSB0 watch --all-fields
+pydigi --model ds781 --port COM3 read                 # -v / -vv for logging
+pydigi list-models
+```
+
+## Extending
+
+The library is three seams; a new device touches only one and needs **no changes
+to existing code**:
+
+- **New model** (same protocol, different defaults) — subclass `ScaleModel`,
+  set the class attributes, `@register`:
+
+  ```python
+  from pydigi import ScaleModel, register
+  from pydigi import TypeBProtocol
+
+  @register
+  class DigiDS782(ScaleModel):
+      name = "ds782"
+      protocol_class = TypeBProtocol
+      default_baudrate = 9600
+      max_weight_kg = 15.0
+  ```
+  `DigiDS782.open(port)` and `pydigi --model ds782` work immediately.
+
+- **New protocol** (Type A/C, another vendor) — subclass `Protocol`
+  (`poll_request` / `read_frame` / `parse`) and point a model at it.
+- **New transport** (TCP bridge, USB HID) — subclass `Transport` and pass it to
+  `Model.bind(transport)`.
+
+Details and rationale in [DESIGN.md](DESIGN.md).
+
+> `Scale` is not thread-safe — a serial port is a single shared resource. Use one
+> `Scale` per thread, or guard it with your own lock.
+
+## Development
+
+```bash
+make test           # hardware-free test suite
+make build          # sdist + wheel into ./dist
+make docker-build   # same, isolated in Docker
+```
+
+Testing (hardware-free **and** on a real scale) is documented in
+[TESTING.md](TESTING.md); architecture in [DESIGN.md](DESIGN.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pydigi-1.0.0/README.md

@@ -0,0 +1,169 @@
+# PyDIGI — read DIGI scales from Python
+
+`pydigi` reads weight, price and status from DIGI retail scales over RS-232.
+
+- **Supported models:** DIGI DS-781 (Type B / Standard command protocol).
+- **Python:** 3.8+ (see [DESIGN.md §8](DESIGN.md) for why 2.x is out of scope).
+- **Dependency:** [pyserial](https://pypi.org/project/pyserial/) (only for real ports).
+- Layered so more models, protocol types, and transports slot in **without
+  rewrites** — see [Extending](#extending) and [DESIGN.md](DESIGN.md).
+
+## Install
+
+```bash
+pip install .                 # library + pyserial
+pip install '.[test]'         # + pytest, PyYAML (to run the test suite)
+pip install '.[hil]'          # + PyYAML (for the hardware-in-the-loop tooling)
+```
+
+Or build a wheel/sdist (see [Development](#development)) and
+`pip install dist/pydigi-*.whl`. Not published to PyPI.
+
+## Quick start
+
+```python
+from pydigi import DigiDS781
+
+with DigiDS781.open("/dev/ttyUSB0") as scale:      # COM3 on Windows
+    r = scale.read()
+    print(r.weight_net_kg, "kg", "stable" if r.is_stable else "moving")
+```
+
+`DigiDS781.open(port, baudrate=..., parity=..., stopbits=..., timeout=...,
+rtscts=...)` — extra keywords pass through to the serial config. `open()`
+returns a ready scale and is also a context manager.
+
+## What a reading contains
+
+`scale.read()` returns an immutable `ScaleReading`:
+
+| Field | Meaning |
+|---|---|
+| `weight_net_kg` / `weight_tare_kg` | net (post-tare) and stored tare weight |
+| `weight_gross_kg` | derived `net + tare` (always consistent) |
+| `unit_price` / `total_price` | price per `price_base`, and net × unit |
+| `price_base` | `PriceBase` enum (`$/kg`, `$/100g`, `$/lb`, `$/(1/4)lb`) |
+| `is_stable` `is_net` `is_zero` `is_negative` | condition booleans |
+| `weight_overflow` `weight_underflow` `total_price_overflow` | range flags |
+| `raw_hex` | the source frame, for diagnostics |
+
+Values the scale did not send (overflow, underflow, no PLU) are **`None`**,
+never a fake `0.0`. `reading.as_dict()` gives a JSON-friendly view.
+
+## Continuous reading & change-watch
+
+```python
+for reading in scale.stream(interval=0.2):          # every poll
+    print(reading.weight_gross_kg)
+```
+
+`watch()` yields only when a field you care about changes — you **tick the
+fields** with a `ChangeFilter`:
+
+```python
+from pydigi import ChangeFilter, Field
+
+watch_weight = ChangeFilter.weight(min_delta_kg=0.005, stable_only=True)  # the default
+for reading in scale.watch(interval=0.2, change_filter=watch_weight):
+    print("weight ->", reading.weight_gross_kg, "kg")
+
+ChangeFilter([Field.NET, Field.TARE, Field.UNIT_PRICE])   # several fields
+ChangeFilter.everything()                                 # any field, flags included
+```
+
+For long-running loops, `stream(..., ignore_errors=True, on_error=cb)` keeps
+going through transient timeouts instead of raising.
+
+Runnable examples: [single_reading.py](examples/single_reading.py),
+[continuous_reading.py](examples/continuous_reading.py), and
+[offline_demo.py](examples/offline_demo.py) (no hardware).
+
+## Errors
+
+All exceptions derive from `PyDigiError`:
+
+```
+PyDigiError
+├── TransportError        # port open/read/write failed
+│   └── ScaleTimeout      # no response within timeout / after retries
+└── FrameError            # a frame arrived but was malformed
+    ├── ShortFrameError · HeaderError · FieldParseError · ParityError
+```
+
+Catch `PyDigiError` broadly, `ScaleTimeout` to retry, or `FrameError` to
+log-and-skip a garbled frame in a stream without tearing down the port.
+
+## Testing without hardware
+
+The serial layer is a pluggable `Transport`. Swap in `LoopbackTransport` (which
+replays canned bytes) and `bind()` to a scale — no port required:
+
+```python
+from pydigi import DigiDS781, LoopbackTransport
+
+with DigiDS781.bind(LoopbackTransport(my_frame_bytes)) as scale:
+    print(scale.read().weight_net_kg)
+```
+
+This is exactly how the test suite runs. A complete, runnable version (which
+synthesises frames) is [examples/offline_demo.py](examples/offline_demo.py); the
+testing workflow is in [TESTING.md](TESTING.md).
+
+## Command line
+
+```bash
+pydigi --port /dev/ttyUSB0 read                       # one reading
+pydigi --port /dev/ttyUSB0 read --json                # machine-readable
+pydigi --port /dev/ttyUSB0 stream --interval 0.5 --count 10
+pydigi --port /dev/ttyUSB0 watch --stable-only        # weight changes only
+pydigi --port /dev/ttyUSB0 watch --field tare --field unit-price
+pydigi --port /dev/ttyUSB0 watch --all-fields
+pydigi --model ds781 --port COM3 read                 # -v / -vv for logging
+pydigi list-models
+```
+
+## Extending
+
+The library is three seams; a new device touches only one and needs **no changes
+to existing code**:
+
+- **New model** (same protocol, different defaults) — subclass `ScaleModel`,
+  set the class attributes, `@register`:
+
+  ```python
+  from pydigi import ScaleModel, register
+  from pydigi import TypeBProtocol
+
+  @register
+  class DigiDS782(ScaleModel):
+      name = "ds782"
+      protocol_class = TypeBProtocol
+      default_baudrate = 9600
+      max_weight_kg = 15.0
+  ```
+  `DigiDS782.open(port)` and `pydigi --model ds782` work immediately.
+
+- **New protocol** (Type A/C, another vendor) — subclass `Protocol`
+  (`poll_request` / `read_frame` / `parse`) and point a model at it.
+- **New transport** (TCP bridge, USB HID) — subclass `Transport` and pass it to
+  `Model.bind(transport)`.
+
+Details and rationale in [DESIGN.md](DESIGN.md).
+
+> `Scale` is not thread-safe — a serial port is a single shared resource. Use one
+> `Scale` per thread, or guard it with your own lock.
+
+## Development
+
+```bash
+make test           # hardware-free test suite
+make build          # sdist + wheel into ./dist
+make docker-build   # same, isolated in Docker
+```
+
+Testing (hardware-free **and** on a real scale) is documented in
+[TESTING.md](TESTING.md); architecture in [DESIGN.md](DESIGN.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pydigi-1.0.0/pydigi/__init__.py

@@ -0,0 +1,71 @@
+"""pydigi — read weight, price and status from DIGI scales over RS-232.
+
+Typical use::
+
+    from pydigi import DigiDS781
+
+    with DigiDS781.open("/dev/ttyUSB0") as scale:
+        print(scale.read().weight_net_kg)
+
+See ``DESIGN.md`` for the architecture and ``examples/`` for runnable scripts.
+"""
+
+from .version import __version__
+from .exceptions import (
+    PyDigiError,
+    TransportError,
+    ScaleTimeout,
+    FrameError,
+    ShortFrameError,
+    HeaderError,
+    FieldParseError,
+    ParityError,
+)
+from .reading import (
+    ScaleReading,
+    StatusFlag,
+    WeightConditionFlag,
+    PriceBase,
+)
+from .config import SerialConfig
+from .transport import Transport, SerialTransport, LoopbackTransport
+from .protocol import Protocol, TypeBProtocol
+from .scale import Scale, PollPolicy
+from .watch import ChangeFilter, Field
+from .models import ScaleModel, DigiDS781, get_model, available_models, register
+
+__all__ = [
+    "__version__",
+    # errors
+    "PyDigiError",
+    "TransportError",
+    "ScaleTimeout",
+    "FrameError",
+    "ShortFrameError",
+    "HeaderError",
+    "FieldParseError",
+    "ParityError",
+    # data model
+    "ScaleReading",
+    "StatusFlag",
+    "WeightConditionFlag",
+    "PriceBase",
+    # config / transport / protocol
+    "SerialConfig",
+    "Transport",
+    "SerialTransport",
+    "LoopbackTransport",
+    "Protocol",
+    "TypeBProtocol",
+    # client
+    "Scale",
+    "PollPolicy",
+    "ChangeFilter",
+    "Field",
+    # models
+    "ScaleModel",
+    "DigiDS781",
+    "get_model",
+    "available_models",
+    "register",
+]

pydigi-1.0.0/pydigi/cli.py

@@ -0,0 +1,163 @@
+"""The ``pydigi`` command-line interface.
+
+    pydigi --port /dev/ttyUSB0 read
+    pydigi --port /dev/ttyUSB0 read --json
+    pydigi --port /dev/ttyUSB0 watch --stable-only
+    pydigi --port /dev/ttyUSB0 watch --field tare --field unit-price
+    pydigi --port /dev/ttyUSB0 watch --all-fields
+    pydigi --port COM3 stream --interval 0.5 --count 10
+    pydigi list-models
+
+Thin by design: it parses arguments, builds a scale from the model registry, and
+prints readings. All real work lives in the library.
+"""
+
+import argparse
+import json
+import logging
+import sys
+
+from . import __version__
+from .exceptions import PyDigiError
+from .models import get_model, available_models
+from .watch import ChangeFilter, Field
+
+# Short CLI names -> ChangeFilter field constants.
+_WATCH_FIELDS = {
+    "net": Field.NET,
+    "tare": Field.TARE,
+    "gross": Field.GROSS,
+    "unit-price": Field.UNIT_PRICE,
+    "total-price": Field.TOTAL_PRICE,
+    "price-base": Field.PRICE_BASE,
+    "stable": Field.STABLE,
+    "zero": Field.ZERO,
+    "net-mode": Field.NET_MODE,
+    "negative": Field.NEGATIVE,
+    "overflow": Field.WEIGHT_OVERFLOW,
+    "underflow": Field.WEIGHT_UNDERFLOW,
+    "total-price-overflow": Field.TOTAL_PRICE_OVERFLOW,
+}
+
+
+def _build_parser():
+    parser = argparse.ArgumentParser(
+        prog="pydigi",
+        description="Read weight and price from DIGI scales over RS-232.",
+    )
+    parser.add_argument("--version", action="version", version="pydigi " + __version__)
+    parser.add_argument(
+        "--model", default="ds781",
+        help="scale model (default: ds781). See 'pydigi list-models'.",
+    )
+    parser.add_argument("--port", help="serial device, e.g. /dev/ttyUSB0 or COM3")
+    parser.add_argument("--baudrate", type=int, default=None, help="override baud rate")
+    parser.add_argument("--json", action="store_true", help="emit readings as JSON lines")
+    parser.add_argument(
+        "-v", "--verbose", action="count", default=0,
+        help="-v for info, -vv for debug logging",
+    )
+
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("read", help="take a single reading and exit")
+
+    watch = sub.add_parser("watch", help="print a reading only when it changes")
+    watch.add_argument("--interval", type=float, default=0.2, help="seconds between polls")
+    watch.add_argument("--min-delta", type=float, default=0.0,
+                       help="weight change (kg) needed to report")
+    watch.add_argument("--stable-only", action="store_true",
+                       help="report only stable readings")
+    watch.add_argument("--field", action="append", dest="fields",
+                       choices=sorted(_WATCH_FIELDS),
+                       help="field to watch for changes (repeatable); default: net")
+    watch.add_argument("--all-fields", action="store_true",
+                       help="watch every field, not just weight")
+    watch.add_argument("--count", type=int, default=None,
+                       help="stop after N reported changes")
+
+    stream = sub.add_parser("stream", help="print every reading continuously")
+    stream.add_argument("--interval", type=float, default=0.2, help="seconds between polls")
+    stream.add_argument("--count", type=int, default=None, help="stop after N readings")
+
+    sub.add_parser("list-models", help="list known scale models and exit")
+
+    return parser
+
+
+def _configure_logging(verbosity):
+    level = logging.WARNING
+    if verbosity == 1:
+        level = logging.INFO
+    elif verbosity >= 2:
+        level = logging.DEBUG
+    logging.basicConfig(level=level, format="%(levelname)s %(name)s: %(message)s")
+
+
+def _emit(reading, as_json):
+    if as_json:
+        print(json.dumps(reading.as_dict()))
+    else:
+        print(reading)
+    sys.stdout.flush()
+
+
+def _open_scale(args):
+    model = get_model(args.model)
+    return model.open(args.port, baudrate=args.baudrate)
+
+
+def _build_filter(args):
+    if args.all_fields:
+        return ChangeFilter.everything(min_delta_kg=args.min_delta, stable_only=args.stable_only)
+    if args.fields:
+        fields = [_WATCH_FIELDS[name] for name in args.fields]
+        return ChangeFilter(fields, min_delta_kg=args.min_delta, stable_only=args.stable_only)
+    return ChangeFilter.weight(min_delta_kg=args.min_delta, stable_only=args.stable_only)
+
+
+def main(argv=None):
+    """Entry point. Returns a process exit code."""
+    args = _build_parser().parse_args(argv)
+    _configure_logging(args.verbose)
+
+    if args.command == "list-models":
+        print("Available models: %s" % ", ".join(available_models()))
+        return 0
+    if args.command is None:
+        print("No command given. Try 'pydigi --port PORT read'.", file=sys.stderr)
+        return 2
+    if not args.port:
+        print("--port is required for '%s'." % args.command, file=sys.stderr)
+        return 2
+    try:
+        get_model(args.model)  # validate up front so an unknown model isn't a traceback
+    except KeyError as error:
+        print("Error: %s" % error, file=sys.stderr)
+        return 2
+
+    try:
+        with _open_scale(args) as scale:
+            if args.command == "read":
+                _emit(scale.read(), args.json)
+            elif args.command == "stream":
+                for reading in scale.stream(interval=args.interval, count=args.count):
+                    _emit(reading, args.json)
+            elif args.command == "watch":
+                for reading in scale.watch(
+                    interval=args.interval,
+                    change_filter=_build_filter(args),
+                    count=args.count,
+                ):
+                    _emit(reading, args.json)
+    except KeyboardInterrupt:
+        print("Interrupted.", file=sys.stderr)
+        return 130
+    except PyDigiError as error:
+        print("Error: %s" % error, file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pydigi-1.0.0/pydigi/config.py

@@ -0,0 +1,37 @@
+"""Serial-link configuration.
+
+The defaults are the DIGI DS-781 factory settings (9600 8N1, no flow control).
+Values are the literal constants pyserial accepts, so importing this module does
+not require pyserial to be installed.
+"""
+
+from dataclasses import dataclass
+
+
+# pyserial constant values, inlined so config stays import-light:
+#   parity 'N' = none, bytesize 8, stopbits 1
+PARITY_NONE = "N"
+PARITY_EVEN = "E"
+PARITY_ODD = "O"
+EIGHT_BITS = 8
+SEVEN_BITS = 7
+STOP_BITS_ONE = 1
+STOP_BITS_TWO = 2
+
+
+@dataclass
+class SerialConfig:
+    """Everything needed to open an RS-232 link to a scale.
+
+    :param port: OS device name, e.g. ``/dev/ttyUSB0`` or ``COM3``.
+    :param baudrate: DS-781 supports 1200/2400/4800/9600/19200/38400.
+    :param timeout: per-read timeout in seconds.
+    """
+
+    port: str
+    baudrate: int = 9600
+    bytesize: int = EIGHT_BITS
+    parity: str = PARITY_NONE
+    stopbits: float = STOP_BITS_ONE
+    timeout: float = 1.0
+    rtscts: bool = False  # RTS/CTS only when SPEC3.3 = 0; default is 3-wire