scietex.hal.spi 0.1.0__tar.gz

scietex_hal_spi-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anton Bondarenko
+
+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.

scietex_hal_spi-0.1.0/PKG-INFO

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: scietex.hal.spi
+Version: 0.1.0
+Summary: SPI transport backends for scietex.hal devices
+Author-email: Anton Bondarenko <bond.anton@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Anton Bondarenko
+        
+        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.
+Project-URL: Homepage, https://github.com/bond-anton/scietex.hal.spi
+Project-URL: Bug Tracker, https://github.com/bond-anton/scietex.hal.spi/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: spi
+Requires-Dist: spidev>=3.6; extra == "spi"
+Provides-Extra: gpiozero
+Requires-Dist: gpiozero>=1.6.2; extra == "gpiozero"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: lint
+Requires-Dist: ruff==0.17.4; extra == "lint"
+Requires-Dist: ty==0.0.99; extra == "lint"
+Provides-Extra: dev
+Requires-Dist: tox>=4.46.0; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: spidev>=3.6; extra == "dev"
+Requires-Dist: gpiozero>=1.6.2; extra == "dev"
+Dynamic: license-file
+
+# scietex.hal.spi
+
+SPI transport backends shared by the `scietex.hal.*` device distributions.
+
+A transport is the narrow seam between a device driver and the bus. Devices
+send whole frames through `transfer()` and release the bus with `close()`, so
+the same driver works over `spidev`, over gpiozero's hardware SPI, or over a
+scripted fake in tests. The package ships no device code and has no runtime
+dependencies: the optional backends are imported only when they are used.
+
+## The protocol
+
+```python
+class SpiTransport(Protocol):
+    def transfer(self, tx: Sequence[int]) -> list[int]: ...
+    def close(self) -> None: ...
+```
+
+* `transfer(tx)` sends one frame of words in `0..255` and returns the received
+  words in the same order.
+* `close()` releases the bus handle; repeated calls have no effect. If the
+  underlying close fails, the transport stays open and `close()` can be
+  retried.
+* `closed` is `True` once `close()` has run. For a transport that wraps a
+  caller-supplied handle, it reports that the transport itself is closed, not
+  that the shared bus was closed.
+
+Any object with callable `transfer` and `close` methods is accepted. Use
+`is_spi_transport(obj)` for the check: unlike `isinstance(obj, SpiTransport)`,
+it rejects class objects. Use `SpiTransport` for typing only.
+
+Failures raise `TransportError`, which subclasses `OSError` so callers that
+already handle spidev or gpiozero I/O errors keep working. A transaction
+attempted after close raises `TransportClosed`, a `TransportError` subclass.
+
+## Backends
+
+| Transport | Install | Notes |
+| --- | --- | --- |
+| `SpiDevTransport` | `pip install 'scietex.hal.spi[spi]'` | Default. Opens `/dev/spidev<bus>.<device>` through `spidev`, Linux only. |
+| `GpiozeroSpiTransport` | `pip install 'scietex.hal.spi[gpiozero]'` | Wraps a gpiozero hardware SPI object. Resolved lazily as `scietex.hal.spi.GpiozeroSpiTransport`. |
+| `FakeSpiTransport` | none | In-memory backend with scripted responses, for tests without hardware. |
+
+```python
+from scietex.hal.spi import SpiDevTransport
+
+transport = SpiDevTransport(bus=0, device=0, max_speed_hz=500_000)
+transport.transfer([0x00, 43])
+transport.close()
+```
+
+`SpiDevTransport` transfers with `xfer2`, which keeps chip select asserted for
+the whole frame; `xfer` would deassert it between 8-bit words.
+
+`GpiozeroSpiTransport` builds a private shared gpiozero `SPIDevice` by default,
+or wraps one supplied with `spi=`. On a Raspberry Pi it also patches gpiozero so
+two hardware-SPI devices can share one port when they use different chip-select
+lines (`fix_gpiozero_dual_cs_spi`, also exported for callers that build their
+own gpiozero devices). Without the RPi pin backend the patch is a no-op.
+
+A bare install ships no hardware backend; constructing one raises `ImportError`
+naming the extra to install.
+
+## Default selection
+
+`build_default_transport` maps the legacy device keywords onto a backend:
+
+| Keyword | `SpiDevTransport` | `GpiozeroSpiTransport` |
+| --- | --- | --- |
+| `port` | `bus` | `port` |
+| `device` | `device` | `device` |
+| `clock_pin`, `mosi_pin`, `miso_pin`, `select_pin` | selects the gpiozero backend | forwarded as-is |
+
+```python
+from scietex.hal.spi import build_default_transport
+
+build_default_transport(port=0, device=1)  # SpiDevTransport(bus=0, device=1)
+build_default_transport(clock_pin=11, mosi_pin=10)  # GpiozeroSpiTransport(...)
+```
+
+Any pin keyword selects the gpiozero backend and requires the `gpiozero`
+extra; without pin keywords the spidev backend is built with `port or 0` and
+`device or 0`. `port` and `device` are accepted by both backends and are simply
+forwarded.
+
+The selector takes backend keywords only. Conflict rejection — passing backend
+keywords together with `transport=` or `spi=` — is the responsibility of each
+device constructor, which owns that argument surface; the selector itself raises
+`TypeError` when given a `transport=` keyword.
+
+## Ownership
+
+Create one transport per device; all channels of a device share it. The device's
+`close()` delegates to its transport.
+
+* `SpiDevTransport` always owns and closes its spidev handle.
+* `GpiozeroSpiTransport` closes only a handle it built. When it wraps a
+  caller-supplied `spi=` object, `close()` marks the transport closed but leaves
+  the shared bus open for its other users; the supplied handle's owner must
+  outlive the wrapper and close it. Once that owner closes the handle, transfers
+  through the wrapper raise `TransportClosed`.
+* `FakeSpiTransport` only flips its `closed` flag.
+
+## Linux permissions
+
+`SpiDevTransport` needs the kernel SPI device node and permission to open it.
+Enable kernel SPI first, for example with `dtparam=spi=on` in
+`/boot/firmware/config.txt` on current Raspberry Pi OS (the older path is
+`/boot/config.txt`).
+
+If the node exists but opening fails, add a udev rule. The development setup for
+these packages uses the `gpio` group; adjust the group to match your system::
+
+    SUBSYSTEM=="spidev", GROUP="gpio", MODE="0660"
+
+Install the rule under `/etc/udev/rules.d/`, reload the rules, and reconnect the
+device. The user running the process must be a member of the group named in the
+rule; on Fedora setups that group is `gpio`, because no `spi` group exists.
+
+## License
+
+This project is licensed under the **MIT License** - see the LICENSE file for details.

scietex_hal_spi-0.1.0/README.md

@@ -0,0 +1,122 @@
+# scietex.hal.spi
+
+SPI transport backends shared by the `scietex.hal.*` device distributions.
+
+A transport is the narrow seam between a device driver and the bus. Devices
+send whole frames through `transfer()` and release the bus with `close()`, so
+the same driver works over `spidev`, over gpiozero's hardware SPI, or over a
+scripted fake in tests. The package ships no device code and has no runtime
+dependencies: the optional backends are imported only when they are used.
+
+## The protocol
+
+```python
+class SpiTransport(Protocol):
+    def transfer(self, tx: Sequence[int]) -> list[int]: ...
+    def close(self) -> None: ...
+```
+
+* `transfer(tx)` sends one frame of words in `0..255` and returns the received
+  words in the same order.
+* `close()` releases the bus handle; repeated calls have no effect. If the
+  underlying close fails, the transport stays open and `close()` can be
+  retried.
+* `closed` is `True` once `close()` has run. For a transport that wraps a
+  caller-supplied handle, it reports that the transport itself is closed, not
+  that the shared bus was closed.
+
+Any object with callable `transfer` and `close` methods is accepted. Use
+`is_spi_transport(obj)` for the check: unlike `isinstance(obj, SpiTransport)`,
+it rejects class objects. Use `SpiTransport` for typing only.
+
+Failures raise `TransportError`, which subclasses `OSError` so callers that
+already handle spidev or gpiozero I/O errors keep working. A transaction
+attempted after close raises `TransportClosed`, a `TransportError` subclass.
+
+## Backends
+
+| Transport | Install | Notes |
+| --- | --- | --- |
+| `SpiDevTransport` | `pip install 'scietex.hal.spi[spi]'` | Default. Opens `/dev/spidev<bus>.<device>` through `spidev`, Linux only. |
+| `GpiozeroSpiTransport` | `pip install 'scietex.hal.spi[gpiozero]'` | Wraps a gpiozero hardware SPI object. Resolved lazily as `scietex.hal.spi.GpiozeroSpiTransport`. |
+| `FakeSpiTransport` | none | In-memory backend with scripted responses, for tests without hardware. |
+
+```python
+from scietex.hal.spi import SpiDevTransport
+
+transport = SpiDevTransport(bus=0, device=0, max_speed_hz=500_000)
+transport.transfer([0x00, 43])
+transport.close()
+```
+
+`SpiDevTransport` transfers with `xfer2`, which keeps chip select asserted for
+the whole frame; `xfer` would deassert it between 8-bit words.
+
+`GpiozeroSpiTransport` builds a private shared gpiozero `SPIDevice` by default,
+or wraps one supplied with `spi=`. On a Raspberry Pi it also patches gpiozero so
+two hardware-SPI devices can share one port when they use different chip-select
+lines (`fix_gpiozero_dual_cs_spi`, also exported for callers that build their
+own gpiozero devices). Without the RPi pin backend the patch is a no-op.
+
+A bare install ships no hardware backend; constructing one raises `ImportError`
+naming the extra to install.
+
+## Default selection
+
+`build_default_transport` maps the legacy device keywords onto a backend:
+
+| Keyword | `SpiDevTransport` | `GpiozeroSpiTransport` |
+| --- | --- | --- |
+| `port` | `bus` | `port` |
+| `device` | `device` | `device` |
+| `clock_pin`, `mosi_pin`, `miso_pin`, `select_pin` | selects the gpiozero backend | forwarded as-is |
+
+```python
+from scietex.hal.spi import build_default_transport
+
+build_default_transport(port=0, device=1)  # SpiDevTransport(bus=0, device=1)
+build_default_transport(clock_pin=11, mosi_pin=10)  # GpiozeroSpiTransport(...)
+```
+
+Any pin keyword selects the gpiozero backend and requires the `gpiozero`
+extra; without pin keywords the spidev backend is built with `port or 0` and
+`device or 0`. `port` and `device` are accepted by both backends and are simply
+forwarded.
+
+The selector takes backend keywords only. Conflict rejection — passing backend
+keywords together with `transport=` or `spi=` — is the responsibility of each
+device constructor, which owns that argument surface; the selector itself raises
+`TypeError` when given a `transport=` keyword.
+
+## Ownership
+
+Create one transport per device; all channels of a device share it. The device's
+`close()` delegates to its transport.
+
+* `SpiDevTransport` always owns and closes its spidev handle.
+* `GpiozeroSpiTransport` closes only a handle it built. When it wraps a
+  caller-supplied `spi=` object, `close()` marks the transport closed but leaves
+  the shared bus open for its other users; the supplied handle's owner must
+  outlive the wrapper and close it. Once that owner closes the handle, transfers
+  through the wrapper raise `TransportClosed`.
+* `FakeSpiTransport` only flips its `closed` flag.
+
+## Linux permissions
+
+`SpiDevTransport` needs the kernel SPI device node and permission to open it.
+Enable kernel SPI first, for example with `dtparam=spi=on` in
+`/boot/firmware/config.txt` on current Raspberry Pi OS (the older path is
+`/boot/config.txt`).
+
+If the node exists but opening fails, add a udev rule. The development setup for
+these packages uses the `gpio` group; adjust the group to match your system::
+
+    SUBSYSTEM=="spidev", GROUP="gpio", MODE="0660"
+
+Install the rule under `/etc/udev/rules.d/`, reload the rules, and reconnect the
+device. The user running the process must be a member of the group named in the
+rule; on Fedora setups that group is `gpio`, because no `spi` group exists.
+
+## License
+
+This project is licensed under the **MIT License** - see the LICENSE file for details.

scietex_hal_spi-0.1.0/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scietex.hal.spi"
+dynamic = ["version"]
+description = "SPI transport backends for scietex.hal devices"
+authors = [{ name = "Anton Bondarenko", email = "bond.anton@gmail.com" }]
+license = { file = "LICENSE" }
+readme = "README.md"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+requires-python = ">=3.10"
+dependencies = []
+
+[project.urls]
+"Homepage" = "https://github.com/bond-anton/scietex.hal.spi"
+"Bug Tracker" = "https://github.com/bond-anton/scietex.hal.spi/issues"
+
+[project.optional-dependencies]
+spi = ["spidev>=3.6"]
+gpiozero = ["gpiozero>=1.6.2"]
+test = ["pytest"]
+lint = ["ruff==0.17.4", "ty==0.0.99"]
+dev = ["tox>=4.46.0", "pytest", "spidev>=3.6", "gpiozero>=1.6.2"]
+
+[tool.setuptools.dynamic]
+version = { attr = "scietex.hal.spi.version.__version__" }
+
+[tool.setuptools.package-data]
+"scietex.hal.spi" = ["py.typed"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "src"
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E4","E7","E9","F","W","I","B","C4","SIM","UP","PLC0415","PLR0913","PLR0917"]
+ignore = ["E501","SLF001"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["PLC0415"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "auto"
+docstring-code-format = false
+
+[tool.ty.environment]
+python-version = "3.10"
+
+[tool.ty.analysis]
+replace-imports-with-any = ["gpiozero.**", "spidev.**"]

scietex_hal_spi-0.1.0/setup.cfg

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

scietex_hal_spi-0.1.0/src/scietex/hal/spi/__init__.py

@@ -0,0 +1,61 @@
+"""SPI bus transport backends for scietex.hal devices."""
+
+from typing import TYPE_CHECKING, Any
+
+from .base import (
+    I2cTransport,
+    SpiTransport,
+    TransportClosed,
+    TransportError,
+    is_spi_transport,
+)
+from .fake import FakeSpiTransport
+from .gpiozero_helpers import fix_gpiozero_dual_cs_spi
+from .selection import (
+    GPIOZERO_PIN_ARGS,
+    GPIOZERO_SPI_ARGS,
+    build_default_transport,
+)
+from .spidev_spi import SpiDevTransport
+from .version import __version__ as __version__
+
+if TYPE_CHECKING:
+    from .gpiozero_spi import GpiozeroSpiTransport  # noqa: F401
+
+#: Names resolved lazily by `__getattr__`; kept out of `__all__` so a star
+#: import works on a core install without the optional gpiozero package.
+_LAZY_ATTRIBUTES = ("GpiozeroSpiTransport",)
+
+__all__ = [
+    "FakeSpiTransport",
+    "GPIOZERO_PIN_ARGS",
+    "GPIOZERO_SPI_ARGS",
+    "I2cTransport",
+    "SpiDevTransport",
+    "SpiTransport",
+    "TransportClosed",
+    "TransportError",
+    "build_default_transport",
+    "fix_gpiozero_dual_cs_spi",
+    "is_spi_transport",
+]
+
+
+def __getattr__(name: str) -> Any:
+    """Resolve the optional gpiozero transport on first access."""
+    if name == "GpiozeroSpiTransport":
+        try:
+            from .gpiozero_spi import GpiozeroSpiTransport  # noqa: PLC0415
+        except ImportError as exc:
+            raise AttributeError(
+                "GpiozeroSpiTransport requires the optional 'gpiozero' package. "
+                "Install it with: pip install 'scietex.hal.spi[gpiozero]'"
+            ) from exc
+
+        return GpiozeroSpiTransport
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    """List the module attributes, including lazily resolved names."""
+    return sorted(set(__all__) | set(globals()) | set(_LAZY_ATTRIBUTES))

scietex_hal_spi-0.1.0/src/scietex/hal/spi/base.py

@@ -0,0 +1,72 @@
+"""Transport protocols and exceptions shared by all bus backends."""
+
+from collections.abc import Sequence
+from typing import Protocol, runtime_checkable
+
+
+class TransportError(OSError):
+    """Raised when a bus transaction fails.
+
+    Subclasses `OSError` so callers that already handle gpiozero or spidev I/O
+    errors keep catching transport failures without changes.
+    """
+
+
+class TransportClosed(TransportError):
+    """Raised when a transaction is attempted after close()."""
+
+
+@runtime_checkable
+class SpiTransport(Protocol):
+    """Full-duplex SPI backend.
+
+    Structurally satisfied by any non-class object with callable `transfer`
+    and `close` methods. Use `is_spi_transport` for the check: it rejects
+    class objects, which `isinstance` against this protocol accepts.
+    """
+
+    def transfer(self, tx: Sequence[int]) -> list[int]:
+        """Transfer one frame and return the received words."""
+        ...
+
+    def close(self) -> None:
+        """Release the bus handle."""
+        ...
+
+
+@runtime_checkable
+class I2cTransport(Protocol):
+    """I2C backend protocol for future chips.
+
+    No implementation or device uses it yet; it keeps the transport surface
+    consistent for chips with an I2C interface.
+    """
+
+    def write(self, data: Sequence[int]) -> None:
+        """Write one frame."""
+        ...
+
+    def read(self, nbytes: int) -> bytes:
+        """Read `nbytes` bytes."""
+        ...
+
+    def write_read(self, tx: Sequence[int], nbytes: int) -> bytes:
+        """Write a frame, then read `nbytes` bytes."""
+        ...
+
+    def close(self) -> None:
+        """Release the bus handle."""
+        ...
+
+
+def is_spi_transport(obj: object) -> bool:
+    """Check whether `obj` structurally satisfies `SpiTransport`.
+
+    Requires callable `transfer` and `close` attributes and rejects class
+    objects, so a transport class itself does not count.
+    """
+    if isinstance(obj, type):
+        return False
+    return callable(getattr(obj, "transfer", None)) and callable(
+        getattr(obj, "close", None)
+    )

scietex_hal_spi-0.1.0/src/scietex/hal/spi/fake.py

@@ -0,0 +1,96 @@
+"""Scripted SPI transport for tests."""
+
+from collections.abc import Sequence
+
+from .base import TransportClosed, TransportError
+
+
+class FakeSpiTransport:
+    """SPI transport that replays scripted response frames.
+
+    Responses are consumed FIFO. `default` is returned once the queue is
+    empty; with `strict=False` an empty queue yields zero-filled frames
+    instead of an error. Request words are validated to ints in 0..255.
+    Frames are copied on the way in and out so that mutating a caller's list
+    cannot change a scripted response or a recorded call.
+    """
+
+    def __init__(
+        self,
+        responses: list[list[int]] | None = None,
+        default: list[int] | None = None,
+        strict: bool = True,
+    ) -> None:
+        """
+        Build a scripted transport.
+
+        :param responses: Response frames consumed FIFO; each frame must have
+            the same length as the request that consumes it.
+        :param default: Frame returned once `responses` is exhausted; when
+            omitted, an exhausted queue follows `strict`.
+        :param strict: When True an empty queue with no `default` raises
+            `TransportError`; when False it returns a zero-filled frame.
+        """
+        self._responses = (
+            [list(frame) for frame in responses] if responses is not None else []
+        )
+        self._default = list(default) if default is not None else None
+        self._strict = strict
+        self.calls: list[list[int]] = []
+        self._closed = False
+
+    @property
+    def closed(self) -> bool:
+        """Return True once the transport has been closed."""
+        return self._closed
+
+    def queue(self, *responses: list[int]) -> None:
+        """Append scripted response frames."""
+        self._responses.extend(list(frame) for frame in responses)
+
+    def transfer(self, tx: Sequence[int]) -> list[int]:
+        """Return the next scripted frame for `tx`.
+
+        Request words must be ints in 0..255; a malformed word raises
+        `ValueError` before the call is recorded. A frame that fails validation
+        stays at the head of the queue and is not recorded as a call, so the
+        caller can retry with a matching request.
+
+        :param tx: Request frame.
+        :return: Response frame of the same length.
+        :raises TransportClosed: If the transport is closed.
+        :raises ValueError: If a request word is not an int in 0..255.
+        :raises TransportError: If no response is available in strict mode or
+            the scripted response length does not match the request.
+        """
+        if self._closed:
+            raise TransportClosed("FakeSpiTransport is closed")
+        frame = list(tx)
+        for word in frame:
+            if not isinstance(word, int) or not 0 <= word <= 0xFF:
+                raise ValueError(
+                    f"SPI frame words must be ints in the range 0..255, got {word!r}"
+                )
+        if self._responses:
+            rx = list(self._responses[0])
+            from_queue = True
+        elif self._default is not None:
+            rx = list(self._default)
+            from_queue = False
+        elif self._strict:
+            raise TransportError("FakeSpiTransport has no scripted response")
+        else:
+            self.calls.append(frame)
+            return [0] * len(frame)
+        if len(rx) != len(frame):
+            raise TransportError(
+                f"Response length {len(rx)} does not match request length {len(frame)}"
+            )
+        if from_queue:
+            self._responses.pop(0)
+        self.calls.append(frame)
+        return rx
+
+    def close(self) -> None:
+        """Close the transport. Repeated calls have no effect."""
+        self._closed = True