serialforge 0.0.1__py3-none-any.whl

serialforge/testing/simulated_device.py

@@ -0,0 +1,67 @@
+"""Scriptable device description used by the fake serial backend."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, field
+
+ResponseScript = Callable[[bytes], bytes | Sequence[bytes] | None]
+
+
+@dataclass
+# pylint: disable=too-many-instance-attributes
+class SimulatedDevice:
+    """Describe a fake port and its deterministic wire behavior.
+
+    ``responses`` maps request bytes to response chunks. ``script`` can
+    provide dynamic behavior and takes precedence.
+    """
+
+    vid: int
+    pid: int
+    port: str = "SIM1"
+    serial_number: str | None = None
+    location: str | None = None
+    description: str = "serialforge simulated device"
+    responses: Mapping[bytes | str, bytes | Sequence[bytes]] = field(
+        default_factory=dict
+    )
+    script: ResponseScript | None = None
+    latency_s: float = 0.0
+    chunk_size: int | None = None
+    echo: bool = False
+    disconnect_after_writes: int | None = None
+    baudrate: int | None = None
+
+    @property
+    def device(self) -> str:
+        """Return the pyserial-style port name."""
+        return self.port
+
+    def response_for(self, data: bytes) -> list[bytes]:
+        """Return scripted response chunks for a transmitted request."""
+        if self.script is not None:
+            result = self.script(data)
+        else:
+            key = data.decode("utf-8", errors="replace")
+            result = self.responses.get(data, self.responses.get(key))
+        if result is None:
+            chunks: list[bytes] = []
+        elif isinstance(result, bytes):
+            chunks = [result]
+        else:
+            chunks = [bytes(item) for item in result]
+        if self.echo:
+            chunks.insert(0, data)
+        if self.chunk_size is None or self.chunk_size <= 0:
+            return chunks
+        split: list[bytes] = []
+        for chunk in chunks:
+            split.extend(
+                chunk[index : index + self.chunk_size]
+                for index in range(0, len(chunk), self.chunk_size)
+            )
+        return split
+
+
+__all__ = ["SimulatedDevice", "ResponseScript"]

serialforge/transport/__init__.py

@@ -0,0 +1,19 @@
+"""Transport-layer implementations and test injection points."""
+
+from .backend_switch import BackendSwitch
+from .checksum_calculator import ChecksumCalculator
+from .frame_splitter import FrameSplitter
+from .latency_tracker import LatencyTracker
+from .port_options import PortOptions
+from .port_registry import PortRegistry
+from .serial_transport import SerialTransport
+
+__all__ = [
+    "BackendSwitch",
+    "ChecksumCalculator",
+    "FrameSplitter",
+    "LatencyTracker",
+    "PortRegistry",
+    "PortOptions",
+    "SerialTransport",
+]

serialforge/transport/backend_switch.py

@@ -0,0 +1,36 @@
+"""Process-wide selection of the serial port backend."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+from ..protocols import PortBackend
+from .serial_transport import SerialTransport
+
+
+class BackendSwitch:
+    """Select a port backend and restore it safely after a test."""
+
+    _backend: PortBackend | None = None
+
+    @classmethod
+    def current(cls) -> PortBackend:
+        """Return the active backend, creating the real backend lazily."""
+        if cls._backend is None:
+            cls._backend = SerialTransport()
+        return cls._backend
+
+    @classmethod
+    @contextmanager
+    def use(cls, backend: PortBackend) -> Iterator[PortBackend]:
+        """Temporarily replace the active backend."""
+        previous = cls._backend
+        cls._backend = backend
+        try:
+            yield backend
+        finally:
+            cls._backend = previous
+
+
+__all__ = ["BackendSwitch"]

serialforge/transport/checksum_calculator.py

@@ -0,0 +1,77 @@
+"""Checksum calculation and verification for binary frames."""
+
+from __future__ import annotations
+
+import binascii
+from collections.abc import Callable
+
+from ..enums import Checksum
+
+
+class ChecksumCalculator:
+    """Calculate or verify supported checksums with a stable byte order."""
+
+    # The explicit branches keep algorithm-specific byte order visible.
+    # pylint: disable=too-many-return-statements
+
+    @staticmethod
+    def calculate(
+        data: bytes,
+        algorithm: Checksum,
+        custom: Callable[[bytes], bytes] | None = None,
+    ) -> bytes:
+        """Return the checksum bytes for ``data``."""
+        if custom is not None:
+            return bytes(custom(data))
+        if algorithm is Checksum.NONE:
+            return b""
+        if algorithm is Checksum.SUM8:
+            return bytes((sum(data) & 0xFF,))
+        if algorithm is Checksum.XOR:
+            value = 0
+            for item in data:
+                value ^= item
+            return bytes((value,))
+        if algorithm is Checksum.CRC16_MODBUS:
+            return ChecksumCalculator.crc16(data, 0xA001, 0xFFFF)
+        if algorithm is Checksum.CRC16_CCITT:
+            return ChecksumCalculator.crc16_ccitt(data)
+        if algorithm is Checksum.CRC32:
+            return (binascii.crc32(data) & 0xFFFFFFFF).to_bytes(4, "little")
+        raise ValueError(f"unsupported checksum algorithm: {algorithm}")
+
+    @staticmethod
+    def verify(
+        data: bytes,
+        expected: bytes,
+        algorithm: Checksum,
+        custom: Callable[[bytes], bytes] | None = None,
+    ) -> bool:
+        """Return whether ``expected`` matches the calculated checksum."""
+        return ChecksumCalculator.calculate(data, algorithm, custom) == expected
+
+    @staticmethod
+    def crc16(data: bytes, polynomial: int, initial: int) -> bytes:
+        """Calculate reflected CRC-16 and return little-endian bytes."""
+        value = initial
+        for item in data:
+            value ^= item
+            for _ in range(8):
+                value = (value >> 1) ^ polynomial if value & 1 else value >> 1
+        return value.to_bytes(2, "little")
+
+    @staticmethod
+    def crc16_ccitt(data: bytes) -> bytes:
+        """Calculate CRC-16/CCITT-FALSE and return big-endian bytes."""
+        value = 0xFFFF
+        for item in data:
+            value ^= item << 8
+            for _ in range(8):
+                if value & 0x8000:
+                    value = ((value << 1) ^ 0x1021) & 0xFFFF
+                else:
+                    value = (value << 1) & 0xFFFF
+        return value.to_bytes(2, "big")
+
+
+__all__ = ["ChecksumCalculator"]

serialforge/transport/frame_splitter.py

@@ -0,0 +1,134 @@
+"""Incremental byte framing for text and binary serial protocols."""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+
+from ..advanced import FramingConfig
+from ..enums import FramingMode
+from ..errors import FramingError
+
+
+class FrameSplitter:
+    """Split arbitrary byte chunks into complete frames without decoding."""
+
+    _config: FramingConfig
+    _buffer: bytearray
+    _last_byte_at: float | None
+
+    def __init__(
+        self,
+        config: FramingConfig | None = None,
+        *,
+        clock: Callable[[], float] = time.monotonic,
+    ) -> None:
+        """Create a splitter with bounded buffering."""
+        self._config = config or FramingConfig()
+        self._buffer = bytearray()
+        self._last_byte_at = None
+        self._clock: Callable[[], float] = clock
+
+    def feed(self, data: bytes) -> list[bytes]:
+        """Append bytes and return every complete frame now available."""
+        if data:
+            self._buffer.extend(data)
+            self._last_byte_at = self._clock()
+        if len(self._buffer) > self._config.max_buffer_bytes:
+            self._resynchronise()
+            raise FramingError("receive buffer exceeded max_buffer_bytes")
+        if self._config.mode is FramingMode.LINE:
+            return self.split_terminator(self._config.terminator)
+        if self._config.mode is FramingMode.DELIMITED:
+            return self.split_delimited()
+        if self._config.mode is FramingMode.LENGTH_PREFIX:
+            return self.split_length_prefix()
+        return self.split_silence_gap()
+
+    def flush(self, *, now: float | None = None) -> list[bytes]:
+        """Emit a silence-gap frame after the configured idle period."""
+        if self._config.mode is not FramingMode.SILENCE_GAP:
+            return []
+        if not self._buffer or self._last_byte_at is None:
+            return []
+        current = self._clock() if now is None else now
+        gap = self._config.silence_gap_s
+        # FramingConfig validates SILENCE_GAP at construction.
+        assert gap is not None
+        if current - self._last_byte_at < gap:
+            return []
+        frame = bytes(self._buffer)
+        self._buffer.clear()
+        return [self.limit_frame(frame)]
+
+    def split_terminator(self, terminator: bytes) -> list[bytes]:
+        """Split line-style frames, preserving no terminator bytes."""
+        frames: list[bytes] = []
+        while terminator:
+            index = self._buffer.find(terminator)
+            if index < 0:
+                break
+            frames.append(self.limit_frame(bytes(self._buffer[:index])))
+            del self._buffer[: index + len(terminator)]
+        return frames
+
+    def split_delimited(self) -> list[bytes]:
+        """Split frames enclosed by start and end markers."""
+        start = self._config.start_marker
+        end = self._config.end_marker
+        frames: list[bytes] = []
+        while start and end:
+            begin = self._buffer.find(start)
+            if begin < 0:
+                self._resynchronise()
+                break
+            if begin:
+                del self._buffer[:begin]
+            finish = self._buffer.find(end, len(start))
+            if finish < 0:
+                break
+            stop = finish + len(end)
+            frames.append(self.limit_frame(bytes(self._buffer[:stop])))
+            del self._buffer[:stop]
+        return frames
+
+    def split_length_prefix(self) -> list[bytes]:
+        """Split frames whose length is encoded in the header."""
+        offset = self._config.length_offset
+        width = self._config.length_size
+        frames: list[bytes] = []
+        while len(self._buffer) >= offset + width:
+            length_start = offset
+            length_end = length_start + width
+            payload_length = int.from_bytes(
+                self._buffer[length_start:length_end],
+                "little" if self._config.byteorder == "little" else "big",
+            )
+            frame_length = length_end + payload_length
+            if frame_length > self._config.max_frame_length:
+                self._resynchronise()
+                raise FramingError("frame exceeded max_frame_length")
+            if len(self._buffer) < frame_length:
+                break
+            frames.append(self.limit_frame(bytes(self._buffer[:frame_length])))
+            del self._buffer[:frame_length]
+        return frames
+
+    def split_silence_gap(self) -> list[bytes]:
+        """Return no frames until ``flush`` observes a gap."""
+        return []
+
+    def limit_frame(self, frame: bytes) -> bytes:
+        """Validate one frame against the configured maximum."""
+        if len(frame) > self._config.max_frame_length:
+            raise FramingError("frame exceeded max_frame_length")
+        return frame
+
+    def _resynchronise(self) -> None:
+        """Drop bounded garbage while retaining possible marker prefixes."""
+        limit = self._config.max_frame_length
+        if len(self._buffer) > limit:
+            del self._buffer[:-limit]
+
+
+__all__ = ["FrameSplitter"]

serialforge/transport/latency_tracker.py

@@ -0,0 +1,65 @@
+"""EWMA latency and adaptive read interval tracking."""
+
+from __future__ import annotations
+
+from ..advanced import HandlerStats, ReadLoopConfig
+
+
+class LatencyTracker:
+    """Track uncontended round trips and derive a bounded poll interval."""
+
+    _config: ReadLoopConfig
+    _sample_count: int
+    _srtt_s: float | None
+    _rttvar_s: float | None
+    _rto_s: float | None
+
+    def __init__(self, config: ReadLoopConfig | None = None) -> None:
+        """Create a cold-start tracker."""
+        self._config = config or ReadLoopConfig()
+        self._sample_count = 0
+        self._srtt_s = None
+        self._rttvar_s = None
+        self._rto_s = None
+
+    def observe(self, latency_s: float) -> None:
+        """Record one positive uncontended round-trip sample."""
+        if latency_s <= 0:
+            raise ValueError("latency_s must be positive")
+        if self._srtt_s is None or self._rttvar_s is None:
+            self._srtt_s = latency_s
+            self._rttvar_s = latency_s / 2
+        else:
+            self._rttvar_s = 0.75 * self._rttvar_s + 0.25 * abs(
+                self._srtt_s - latency_s
+            )
+            self._srtt_s = 0.875 * self._srtt_s + 0.125 * latency_s
+        self._rto_s = self._srtt_s + 4 * self._rttvar_s
+        self._sample_count += 1
+
+    def reset(self) -> None:
+        """Forget all samples after reconnect or device changes."""
+        self._sample_count = 0
+        self._srtt_s = None
+        self._rttvar_s = None
+        self._rto_s = None
+
+    def poll_interval_s(self) -> float:
+        """Return the cold-start or adaptive bounded read interval."""
+        if self._sample_count < self._config.min_samples:
+            return self._config.poll_initial_s
+        assert self._srtt_s is not None
+        value = self._srtt_s * self._config.poll_factor
+        return min(self._config.poll_max_s, max(self._config.poll_min_s, value))
+
+    def stats(self) -> HandlerStats:
+        """Return a frozen snapshot for the public diagnostics API."""
+        return HandlerStats(
+            srtt_s=self._srtt_s,
+            rttvar_s=self._rttvar_s,
+            poll_interval_s=self.poll_interval_s(),
+            rto_s=self._rto_s,
+        )
+
+
+__all__ = ["LatencyTracker"]

serialforge/transport/port_options.py

@@ -0,0 +1,31 @@
+"""Translate immutable device serial settings into pyserial options."""
+
+from __future__ import annotations
+
+from ..advanced import SerialConfig
+from ..enums import FlowControl
+
+# This utility intentionally exposes one static conversion operation.
+# pylint: disable=too-few-public-methods
+
+
+class PortOptions:
+    """Translate one serial configuration for either opening path."""
+
+    @staticmethod
+    def build(config: SerialConfig, baudrate: int) -> dict[str, object]:
+        """Build pyserial options for a known baudrate."""
+        return {
+            "baudrate": baudrate,
+            "bytesize": int(config.data_bits),
+            "parity": config.parity.value,
+            "stopbits": float(config.stop_bits.value),
+            "xonxoff": config.flow_control is FlowControl.XON_XOFF,
+            "rtscts": config.flow_control is FlowControl.RTS_CTS,
+            "dsrdtr": config.flow_control is FlowControl.DSR_DTR,
+            "write_timeout": config.write_timeout_s,
+            "timeout": 0.05,
+        }
+
+
+__all__ = ["PortOptions"]

serialforge/transport/port_registry.py

@@ -0,0 +1,57 @@
+"""Process-local exclusive ownership of serial ports."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from threading import RLock
+
+from ..errors import PortBusyError
+
+
+class PortRegistry:
+    """Track port ownership with re-entrant, process-local leases."""
+
+    _owners: dict[str, object] = {}
+    _lock = RLock()
+
+    @classmethod
+    def acquire(cls, port: str, owner: object) -> None:
+        """Claim ``port`` or raise ``PortBusyError``."""
+        with cls._lock:
+            current = cls._owners.get(port)
+            if current is not None and current is not owner:
+                raise PortBusyError(f"serial port is busy: {port}")
+            cls._owners[port] = owner
+
+    @classmethod
+    def release(cls, port: str, owner: object) -> None:
+        """Release a port only when owned by ``owner``."""
+        with cls._lock:
+            if cls._owners.get(port) is owner:
+                del cls._owners[port]
+
+    @classmethod
+    def is_owned(cls, port: str) -> bool:
+        """Return whether the port is currently leased."""
+        with cls._lock:
+            return port in cls._owners
+
+    @classmethod
+    @contextmanager
+    def lease(cls, port: str, owner: object) -> Iterator[object]:
+        """Acquire a port for a context and release it afterwards."""
+        cls.acquire(port, owner)
+        try:
+            yield owner
+        finally:
+            cls.release(port, owner)
+
+    @classmethod
+    def clear(cls) -> None:
+        """Clear all leases; intended for isolated test cleanup."""
+        with cls._lock:
+            cls._owners.clear()
+
+
+__all__ = ["PortRegistry"]

serialforge/transport/serial_transport.py

@@ -0,0 +1,90 @@
+"""pyserial-backed port backend and byte transport."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any, cast
+
+import serial
+from serial.tools import list_ports
+
+from ..protocols import TransportProtocol
+
+
+class SerialTransport:
+    """Provide the replaceable backend and one opened serial connection."""
+
+    _serial: serial.Serial | None
+
+    def __init__(self, connection: serial.Serial | None = None) -> None:
+        """Create a backend or wrap an already opened connection."""
+        self._serial = connection
+
+    def list_ports(self) -> Sequence[Any]:
+        """Return pyserial port descriptors."""
+        return tuple(list_ports.comports())
+
+    def open(
+        self, port: str, params: Mapping[str, object]
+    ) -> TransportProtocol:
+        """Open ``port`` with a mapping of pyserial keyword arguments."""
+        values = dict(params)
+        values["port"] = port
+        return SerialTransport(serial.Serial(**values))
+
+    def read(self, size: int, timeout_s: float) -> bytes:
+        """Read up to ``size`` bytes with a bounded timeout."""
+        connection = self._require_connection()
+        connection.timeout = timeout_s
+        return bytes(connection.read(size))
+
+    def write(self, data: bytes) -> int:
+        """Write bytes and return the accepted byte count."""
+        return cast(int, self._require_connection().write(data))
+
+    def close(self) -> None:
+        """Close the connection if it is open."""
+        if self._serial is not None:
+            self._serial.close()
+
+    def cancel_read(self) -> None:
+        """Interrupt a read where the pyserial platform supports it."""
+        connection = self._serial
+        if connection is not None and hasattr(connection, "cancel_read"):
+            connection.cancel_read()
+
+    def cancel_write(self) -> None:
+        """Interrupt a write where the pyserial platform supports it."""
+        connection = self._serial
+        if connection is not None and hasattr(connection, "cancel_write"):
+            connection.cancel_write()
+
+    def reset_input_buffer(self) -> None:
+        """Discard queued input after an exclusive command timeout."""
+        self._require_connection().reset_input_buffer()
+
+    def set_buffer_size(self, rx_size: int) -> None:
+        """Request a driver receive buffer size."""
+        connection = self._require_connection()
+        setter = getattr(connection, "set_buffer_size", None)
+        if setter is not None:
+            setter(rx_size=rx_size)
+
+    def set_control_lines(
+        self, *, dtr: bool | None = None, rts: bool | None = None
+    ) -> None:
+        """Set DTR/RTS only when the caller explicitly supplied them."""
+        connection = self._require_connection()
+        if dtr is not None:
+            connection.dtr = dtr
+        if rts is not None:
+            connection.rts = rts
+
+    def _require_connection(self) -> serial.Serial:
+        """Return the wrapped connection or fail before touching pyserial."""
+        if self._serial is None:
+            raise RuntimeError("serial transport is not open")
+        return self._serial
+
+
+__all__ = ["SerialTransport"]

serialforge-0.0.1.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.5
+Name: serialforge
+Version: 0.0.1
+Summary: PySide6 serial communication toolkit for Windows
+License: MIT
+License-File: LICENSE
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Terminals :: Serial
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: loguru>=0.7
+Requires-Dist: pyserial>=3.5
+Requires-Dist: pyside6-essentials>=6.5
+Description-Content-Type: text/markdown
+
+# serialforge
+
+> 适用版本: 0.0.1  |  当前里程碑: M1
+
+`serialforge` 是面向 Windows 10/11 64 位应用的 PySide6 串口通讯库。设计目标是用 QtCore 信号槽和线程封装设备发现、命令调度、自动重连、流量日志和无硬件测试后端。
+
+当前版本完成包骨架与定义层，真实串口传输和调度将在后续里程碑实现。设计契约见 `串口通讯模块_方案_v10定稿.md`，AI 协作入口见 `AGENTS.md`。
+
+## 开发
+
+```powershell
+uv sync
+uv run python scripts/ci.py --fast
+uv run python scripts/ci.py
+```
+
+项目仅支持 Windows 10/11 64 位；当前未执行 PyPI 上传或真实硬件验证。

serialforge-0.0.1.dist-info/RECORD

@@ -0,0 +1,41 @@
+serialforge/__init__.py,sha256=EQzlRJq8K1jPVdIU9eXGYKyOxEcfY6YlVt1OwwKsIdo,1189
+serialforge/advanced.py,sha256=Q-_qALa_vkODd_-BLIkQupBd4u4zGNgY4RhwBBp7lL4,9224
+serialforge/enums.py,sha256=v1ZNPYPciMS40KowAV-GN76tJ7btcB3cPXF7rHrOHjE,2381
+serialforge/errors.py,sha256=UCkppyxCsX8VKytCqw0X4D5Vti0gq8hwb_iKpGievhA,1072
+serialforge/models.py,sha256=5K0VP2NyA8kfYsBqXVL0SocDH1wVylqY5AOEBN5O_rY,15854
+serialforge/protocols.py,sha256=YQOeLxFZdDqowrdEN2lfDVnmMswRKtP6H0KN-lnwCEs,1581
+serialforge/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+serialforge/settings.py,sha256=Dy2JfDbfNU2z1qyVKDvYsXMo5MGgXSRml6NrBsYUC1g,357
+serialforge/connection/__init__.py,sha256=6PZGXCoW79Kf5EUU_UNTNOGCOCQYsWfMeilpELTN780,105
+serialforge/connection/command_dispatcher.py,sha256=rn20zJN7olRTkdotRIiD54qwC3-_X4BD8gM8UXWGi4Q,27159
+serialforge/connection/command_registry.py,sha256=DntLWB83wE2MYResIBQnwi_Bu856BdMq32PW2eKzVl8,7221
+serialforge/connection/connection_worker.py,sha256=m2q_GI5veuJTSok9ibacKhilkD4GCb-TuUMMXM4J0n8,14726
+serialforge/connection/pending_command.py,sha256=rZYFXIQmJrJDWHJo4hGQRWQg6e3TgIs_RK3m7Mnfjik,1067
+serialforge/connection/read_thread.py,sha256=yvqMvBhnFM1aT7swjvEgRi19-kFidIkw9bkm3cjMftg,2421
+serialforge/connection/response_parser.py,sha256=ZxPdTtoe2wgetMotkZhAHIuXo2Qb_KDu1DxndinNB7M,3560
+serialforge/connection/serial_handler.py,sha256=WabGF7m4Rs7JNJKIlg7ad-yL8YXP4baDr6-elOzKZ_0,11135
+serialforge/diagnostics/__init__.py,sha256=0HmHZGXcf4nRsMCRzvucQL7PLKJTdNyygJF0IalTK4Q,197
+serialforge/diagnostics/log_file_manager.py,sha256=uxB0q8mWIXqHxuWhOsdYNjxIw7p0G4Q7KZxED97JXGs,12864
+serialforge/diagnostics/traffic_logger.py,sha256=dmEvDbBn1ChgeqpvCFwKaE16dD-jX21R1Vhe_3Vvf_g,10083
+serialforge/discovery/__init__.py,sha256=c6Qs5uB52P__gtryKQnVK_GCJipnHSEk1xj5HvqzOJA,101
+serialforge/discovery/async_scan_thread.py,sha256=epn2UPiVw7dnJzNih19xZRemTtgFE5w7vKgoK9-fTQg,1054
+serialforge/discovery/baud_cache.py,sha256=-bAAmy9-9HOYdJrk4rFfHbNvmawkoxxWerDMuuvT15E,4019
+serialforge/discovery/baud_prober.py,sha256=Yo2rwE_CwkzESwigYKVSN_G4j50WBRO3GJPeExX-mFc,7008
+serialforge/discovery/device_finder.py,sha256=OQaKDBd6q5ej6ZDf_SDws_-9ORIpBkE9AnXvEtVQfLY,6120
+serialforge/discovery/port_scanner.py,sha256=vLPIbmN5gvxofS7ePN0VlorN3SlOO9n5788NdrcsYf4,1811
+serialforge/testing/__init__.py,sha256=x0lpcoUm3Q6LFz1PNJtUbfpx3EcefrrW-LKwSCMDdQE,307
+serialforge/testing/fake_backend.py,sha256=Q_uOTXfb1gKO3BApqeGAvO1_720rASNhGfRu6IUCRVY,1804
+serialforge/testing/fake_transport.py,sha256=nAyECllGz8kPzBJ2MgcU0EEwka9BWxLmBspofzutrz8,4330
+serialforge/testing/simulated_device.py,sha256=tXqAzGirAfPuRBm2yQrSRkYrTLiEGUml1t8xMaLwMzA,2139
+serialforge/transport/__init__.py,sha256=xGN_JfA2BSgILiNQAcZ6yOommBKpyyRfnjBluVgUxgE,537
+serialforge/transport/backend_switch.py,sha256=hRk7Vc2wDSgOaEVCItl0YLISXFs3-BEXjcWbmxQQ8NM,962
+serialforge/transport/checksum_calculator.py,sha256=4DjKej_PaaEbZj2BuaOJRIAxrVrIywTvpsDcWXtbR0I,2614
+serialforge/transport/frame_splitter.py,sha256=p6Pq4Spn8TPWy7pjvMlVBveXQtv5vTeKiWvNu-hjbYI,5060
+serialforge/transport/latency_tracker.py,sha256=Pe0x6SkD-u-jfFrk3wgv3WZsyjNR8yg88NvWkUiRToY,2226
+serialforge/transport/port_options.py,sha256=62NOq30vn_0Pu6TAq3Wpq6dRvBCuUwCYDwei67rrzEE,1047
+serialforge/transport/port_registry.py,sha256=GHJfRI0EsubvhXlOfAWUQ9v5596tP1oaKaFnuKUYgAk,1669
+serialforge/transport/serial_transport.py,sha256=rwK90-WJFED-aowUsTEZ_Tyav69F0r5n75C5C0sPMR4,3172
+serialforge-0.0.1.dist-info/METADATA,sha256=ewJTgk0VlfSLiFI0gkV3evsiE3oPc8CDJVKfWSssvZ0,1378
+serialforge-0.0.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+serialforge-0.0.1.dist-info/licenses/LICENSE,sha256=s6YNvjBbs8bqr2t4zQUyYysyU-iiVnJQtTGJNzw3tTE,1081
+serialforge-0.0.1.dist-info/RECORD,,

serialforge-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any