pyixblue 0.9.1__py3-none-any.whl

pyixblue/__init__.py

@@ -0,0 +1,15 @@
+"""Parse iXblue stdbin navigation and answer frames."""
+
+from pyixblue.decoder import StdBinDecoder
+from pyixblue.errors import StdBinError
+from pyixblue.models import MessageType, NavData, NavHeader
+
+__all__ = [
+    "MessageType",
+    "NavData",
+    "NavHeader",
+    "StdBinDecoder",
+    "StdBinError",
+]
+
+__version__ = "0.9.1"

pyixblue/blocks.py

@@ -0,0 +1,242 @@
+"""Declarative stdbin memory-block table.
+
+Sizes and bit positions match the reference ``MemoryBlockParser`` constructors.
+Blocks are stored in bit order, which is the order they are packed on the wire.
+Logbook is the 40 bytes the reference parser actually reads (``int32``,
+``uint32``, and 32 text bytes), not the 12-byte guard declared on that parser.
+``vehicle_attitude_heading_deviation`` is included even though the reference
+decoder constructs no parser for it, so a set extended-mask bit 4 is consumed.
+"""
+
+from collections.abc import Callable
+from dataclasses import dataclass, fields
+from struct import calcsize
+from typing import Any
+
+from pyixblue.models import (
+    AccelerationGeographicFrame,
+    AccelerationVesselFrame,
+    AccelerationVesselFrameDeviation,
+    AhrsAlgorithmStatus,
+    AhrsSystemStatus,
+    AhrsUserStatus,
+    AttitudeHeading,
+    AttitudeHeadingDeviation,
+    AttitudeQuaternion,
+    AttitudeQuaternionDeviation,
+    CourseSpeedOverGround,
+    CurrentGeographicFrame,
+    CurrentGeographicFrameDeviation,
+    Depth,
+    Dmi,
+    DvlGroundSpeed,
+    DvlWaterSpeed,
+    Emlog,
+    EventMarker,
+    Gnss,
+    HeadingRollPitchRate,
+    HeaveSurgeSwaySpeed,
+    InsAlgorithmStatus,
+    InsAlgorithmStatus1,
+    InsAlgorithmStatus2,
+    InsAlgorithmStatus3,
+    InsAlgorithmStatus4,
+    InsSystemStatus,
+    InsSystemStatus1,
+    InsSystemStatus2,
+    InsSystemStatus3,
+    InsUserStatus,
+    Lbl,
+    LogBook,
+    Position,
+    PositionDeviation,
+    RawAccelerationVesselFrame,
+    RawRotationRateVesselFrame,
+    RealTimeHeaveSurgeSway,
+    RotationAccelerationVesselFrame,
+    RotationAccelerationVesselFrameDeviation,
+    RotationRateVesselFrame,
+    RotationRateVesselFrameDeviation,
+    SensorStatus,
+    SmartHeave,
+    SoundVelocity,
+    SpeedGeographicFrame,
+    SpeedGeographicFrameDeviation,
+    SpeedVesselFrame,
+    SystemDate,
+    Temperatures,
+    TurretAngles,
+    Usbl,
+    Utc,
+    VehicleAttitudeHeading,
+    VehicleAttitudeHeadingDeviation,
+    VehiclePosition,
+    VehiclePositionDeviation,
+    Vtg,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class Block:
+    """One optional memory block identified by a mask bit."""
+
+    field: str
+    bit: int
+    fmt: str
+    build: Callable[[tuple[Any, ...]], Any]
+
+    @property
+    def size(self) -> int:
+        return calcsize(self.fmt)
+
+
+def _build(
+    cls: type[Any], converters: tuple[Callable[[int], Any] | None, ...] = ()
+) -> Callable[[tuple[Any, ...]], Any]:
+    names = tuple(item.name for item in fields(cls))
+
+    def build(values: tuple[Any, ...]) -> Any:
+        converted: list[Any] = []
+        for index, value in enumerate(values):
+            converter = converters[index] if index < len(converters) else None
+            converted.append(converter(value) if converter is not None else value)
+        return cls(**dict(zip(names, converted, strict=True)))
+
+    return build
+
+
+def _block(
+    field: str,
+    bit: int,
+    fmt: str,
+    cls: type[Any],
+    converters: tuple[Callable[[int], Any] | None, ...] = (),
+) -> Block:
+    return Block(field, bit, fmt, _build(cls, converters))
+
+
+def _sorted(blocks: tuple[Block, ...]) -> tuple[Block, ...]:
+    return tuple(sorted(blocks, key=lambda block: block.bit))
+
+
+NAVIGATION_BLOCKS = _sorted(
+    (
+        _block("attitude_heading", 0, ">fff", AttitudeHeading),
+        _block("attitude_heading_deviation", 1, ">fff", AttitudeHeadingDeviation),
+        _block("rt_heave_surge_sway", 2, ">ffff", RealTimeHeaveSurgeSway),
+        _block("smart_heave", 3, ">If", SmartHeave),
+        _block("heading_roll_pitch_rate", 4, ">fff", HeadingRollPitchRate),
+        _block("rotation_rate_vessel_frame", 5, ">fff", RotationRateVesselFrame),
+        _block("acceleration_vessel_frame", 6, ">fff", AccelerationVesselFrame),
+        _block("position", 7, ">ddBf", Position),
+        _block("position_deviation", 8, ">ffff", PositionDeviation),
+        _block("speed_geographic_frame", 9, ">fff", SpeedGeographicFrame),
+        _block("speed_geographic_frame_deviation", 10, ">fff", SpeedGeographicFrameDeviation),
+        _block("current_geographic_frame", 11, ">ff", CurrentGeographicFrame),
+        _block("current_geographic_frame_deviation", 12, ">ff", CurrentGeographicFrameDeviation),
+        _block("system_date", 13, ">BBH", SystemDate),
+        _block("sensor_status", 14, ">II", SensorStatus),
+        _block(
+            "ins_algorithm_status",
+            15,
+            ">IIII",
+            InsAlgorithmStatus,
+            (
+                InsAlgorithmStatus1,
+                InsAlgorithmStatus2,
+                InsAlgorithmStatus3,
+                InsAlgorithmStatus4,
+            ),
+        ),
+        _block(
+            "ins_system_status",
+            16,
+            ">III",
+            InsSystemStatus,
+            (InsSystemStatus1, InsSystemStatus2, InsSystemStatus3),
+        ),
+        _block("ins_user_status", 17, ">I", InsUserStatus),
+        _block("ahrs_algorithm_status", 18, ">I", AhrsAlgorithmStatus),
+        _block("ahrs_system_status", 19, ">III", AhrsSystemStatus),
+        _block("ahrs_user_status", 20, ">I", AhrsUserStatus),
+        _block("heave_surge_sway_speed", 21, ">fff", HeaveSurgeSwaySpeed),
+        _block("speed_vessel_frame", 22, ">fff", SpeedVesselFrame),
+        _block("acceleration_geographic_frame", 23, ">fff", AccelerationGeographicFrame),
+        _block("course_speed_over_ground", 24, ">ff", CourseSpeedOverGround),
+        _block("temperatures", 25, ">fff", Temperatures),
+        _block("attitude_quaternion", 26, ">ffff", AttitudeQuaternion),
+        _block("attitude_quaternion_deviation", 27, ">fff", AttitudeQuaternionDeviation),
+        _block("raw_acceleration_vessel_frame", 28, ">fff", RawAccelerationVesselFrame),
+        _block(
+            "acceleration_vessel_frame_deviation",
+            29,
+            ">fff",
+            AccelerationVesselFrameDeviation,
+        ),
+        _block(
+            "rotation_rate_vessel_frame_deviation",
+            30,
+            ">fff",
+            RotationRateVesselFrameDeviation,
+        ),
+    )
+)
+
+EXTENDED_BLOCKS = _sorted(
+    (
+        _block(
+            "rotation_acceleration_vessel_frame",
+            0,
+            ">fff",
+            RotationAccelerationVesselFrame,
+        ),
+        _block(
+            "rotation_acceleration_vessel_frame_deviation",
+            1,
+            ">fff",
+            RotationAccelerationVesselFrameDeviation,
+        ),
+        _block("raw_rotation_rate_vessel_frame", 2, ">fff", RawRotationRateVesselFrame),
+        _block("vehicle_attitude_heading", 3, ">fff", VehicleAttitudeHeading),
+        _block(
+            "vehicle_attitude_heading_deviation",
+            4,
+            ">fff",
+            VehicleAttitudeHeadingDeviation,
+        ),
+        _block("vehicle_position", 5, ">ddBf", VehiclePosition),
+        _block("vehicle_position_deviation", 6, ">ffff", VehiclePositionDeviation),
+    )
+)
+
+EXTERNAL_BLOCKS = _sorted(
+    (
+        _block("utc", 0, ">IB", Utc),
+        _block("gnss1", 1, ">iBBddffffff", Gnss),
+        _block("gnss2", 2, ">iBBddffffff", Gnss),
+        _block("gnss_manual", 3, ">iBBddffffff", Gnss),
+        _block("emlog1", 4, ">iBff", Emlog),
+        _block("emlog2", 5, ">iBff", Emlog),
+        _block("usbl1", 6, ">iB8sddfffff", Usbl),
+        _block("usbl2", 7, ">iB8sddfffff", Usbl),
+        _block("usbl3", 8, ">iB8sddfffff", Usbl),
+        _block("depth", 9, ">iff", Depth),
+        _block("dvl_ground_speed1", 10, ">iBffffffff", DvlGroundSpeed),
+        _block("dvl_water_speed1", 11, ">iBfffffff", DvlWaterSpeed),
+        _block("sound_velocity", 12, ">if", SoundVelocity),
+        _block("dmi", 13, ">ii", Dmi),
+        _block("lbl1", 14, ">iB8sddfff", Lbl),
+        _block("lbl2", 15, ">iB8sddfff", Lbl),
+        _block("lbl3", 16, ">iB8sddfff", Lbl),
+        _block("lbl4", 17, ">iB8sddfff", Lbl),
+        _block("event_marker_a", 18, ">iBI", EventMarker),
+        _block("event_marker_b", 19, ">iBI", EventMarker),
+        _block("event_marker_c", 20, ">iBI", EventMarker),
+        _block("dvl_ground_speed2", 21, ">iBffffffff", DvlGroundSpeed),
+        _block("dvl_water_speed2", 22, ">iBfffffff", DvlWaterSpeed),
+        _block("turret_angles", 24, ">ifff", TurretAngles),
+        _block("vtg1", 25, ">iBfff", Vtg),
+        _block("vtg2", 26, ">iBfff", Vtg),
+        _block("log_book", 27, ">iI32s", LogBook),
+    )
+)

pyixblue/decoder.py

@@ -0,0 +1,187 @@
+"""Streaming parser for iXblue stdbin output frames."""
+
+import struct
+from collections.abc import Iterable
+
+from pyixblue.blocks import EXTENDED_BLOCKS, EXTERNAL_BLOCKS, NAVIGATION_BLOCKS, Block
+from pyixblue.errors import StdBinError
+from pyixblue.models import MessageType, NavData, NavHeader
+
+_NAV_HEADER_SIZE = {2: 21, 3: 25, 4: 27, 5: 27}
+_ANSWER_HEADER_SIZE = 5
+_CHECKSUM_SIZE = 4
+_IX = b"IX"
+_AN = b"AN"
+
+
+class StdBinDecoder:
+    """Reassemble and decode stdbin frames from an arbitrary byte stream.
+
+    Feed whatever arrives from the socket or serial port. ``parse_next_frame``
+    returns true once a whole frame is available. A bad protocol version drops
+    one byte and raises; a bad checksum drops that frame and raises. The next
+    call continues with whatever is still buffered.
+    """
+
+    def __init__(self) -> None:
+        self._buffer = bytearray()
+        self.last_header: NavHeader | None = None
+        self.last_nav = NavData()
+        self.last_answer = b""
+
+    @property
+    def buffered_size(self) -> int:
+        """Bytes still waiting to be parsed."""
+        return len(self._buffer)
+
+    def add_new_data(self, data: bytes | bytearray | memoryview) -> None:
+        """Append bytes. ``data`` may be only part of a frame."""
+        if isinstance(data, str):
+            raise TypeError("stdbin data must be bytes, not str")
+        self._buffer.extend(data)
+
+    def parse_next_frame(self) -> bool:
+        """Parse one frame from the internal buffer.
+
+        Returns false when more bytes are needed. Raises ``StdBinError`` when
+        a frame header is recognized but the version or checksum is invalid.
+        """
+        if not self._find_header():
+            return False
+
+        header = self._parse_header()
+        if len(self._buffer) < header.telegram_size:
+            return False
+        self._compare_checksum(header.telegram_size)
+
+        if header.message_type is MessageType.NAV:
+            self.last_nav = self._parse_nav(header)
+            self.last_answer = b""
+        else:
+            payload_end = header.telegram_size - _CHECKSUM_SIZE
+            self.last_answer = bytes(self._buffer[_ANSWER_HEADER_SIZE:payload_end])
+
+        self.last_header = header
+        del self._buffer[: header.telegram_size]
+        return True
+
+    def _find_header(self) -> bool:
+        """Drop leading junk until a supported header is buffered, or wait."""
+        while len(self._buffer) > 3:
+            version = self._buffer[2]
+            magic = bytes(self._buffer[0:2])
+            if magic == _IX:
+                header_size = _NAV_HEADER_SIZE.get(version)
+                if header_size is None:
+                    del self._buffer[0]
+                    raise StdBinError("Unhandled protocol version")
+                return len(self._buffer) >= header_size
+            if magic == _AN:
+                if 3 <= version <= 5:
+                    return len(self._buffer) >= _ANSWER_HEADER_SIZE
+                del self._buffer[0]
+                raise StdBinError("Unhandled protocol version for an answer")
+            del self._buffer[0]
+        return False
+
+    def _parse_header(self) -> NavHeader:
+        magic = bytes(self._buffer[0:2])
+        version = self._buffer[2]
+        if magic == _IX:
+            if version not in _NAV_HEADER_SIZE:
+                raise StdBinError(
+                    "Unknown protocol version. Supported protocol are version 2->5"
+                )
+            if version == 2:
+                nav_mask, external_mask, telegram_size, validity, counter = struct.unpack_from(
+                    ">IIHII", self._buffer, 3
+                )
+                extended_mask = None
+                navigation_size = None
+            elif version == 3:
+                (
+                    nav_mask,
+                    extended_mask,
+                    external_mask,
+                    telegram_size,
+                    validity,
+                    counter,
+                ) = struct.unpack_from(">IIIHII", self._buffer, 3)
+                navigation_size = None
+            else:
+                (
+                    nav_mask,
+                    extended_mask,
+                    external_mask,
+                    navigation_size,
+                    telegram_size,
+                    validity,
+                    counter,
+                ) = struct.unpack_from(">IIIHHII", self._buffer, 3)
+            return NavHeader(
+                message_type=MessageType.NAV,
+                protocol_version=version,
+                telegram_size=telegram_size,
+                navigation_bit_mask=nav_mask,
+                extended_navigation_bit_mask=extended_mask,
+                external_sensor_bit_mask=external_mask,
+                navigation_size=navigation_size,
+                validity_time_100us=validity,
+                counter=counter,
+            )
+
+        if magic == _AN:
+            telegram_size = struct.unpack_from(">H", self._buffer, 3)[0]
+            return NavHeader(
+                message_type=MessageType.ANSWER,
+                protocol_version=version,
+                telegram_size=telegram_size,
+            )
+
+        raise StdBinError("Incorrect frame header, expected 'I', 'X' or 'A', 'N'")
+
+    def _compare_checksum(self, telegram_size: int) -> None:
+        if telegram_size < _CHECKSUM_SIZE:
+            del self._buffer[0]
+            raise StdBinError("Telegram is smaller than a checksum")
+        checksum_at = telegram_size - _CHECKSUM_SIZE
+        received = struct.unpack_from(">I", self._buffer, checksum_at)[0]
+        computed = sum(self._buffer[:checksum_at]) & 0xFFFFFFFF
+        if received != computed:
+            del self._buffer[:telegram_size]
+            raise StdBinError(
+                f"Bad checksum. Received: 0x{received:x}, computed: 0x{computed:x}"
+            )
+
+    def _parse_nav(self, header: NavHeader) -> NavData:
+        if header.navigation_bit_mask is None or header.external_sensor_bit_mask is None:
+            raise StdBinError("Navigation frame is missing its bit masks")
+        present: dict[str, object] = {}
+        offset = _NAV_HEADER_SIZE[header.protocol_version]
+        offset = self._apply_blocks(offset, header.navigation_bit_mask, NAVIGATION_BLOCKS, present)
+        if header.extended_navigation_bit_mask is not None:
+            offset = self._apply_blocks(
+                offset,
+                header.extended_navigation_bit_mask,
+                EXTENDED_BLOCKS,
+                present,
+            )
+        self._apply_blocks(offset, header.external_sensor_bit_mask, EXTERNAL_BLOCKS, present)
+        return NavData(**present)
+
+    def _apply_blocks(
+        self,
+        offset: int,
+        mask: int,
+        blocks: Iterable[Block],
+        present: dict[str, object],
+    ) -> int:
+        for block in blocks:
+            if (mask >> block.bit) & 1 == 0:
+                continue
+            if len(self._buffer) - offset < block.size:
+                raise StdBinError("Not enough bytes in buffer to parse this memory block")
+            values = struct.unpack_from(block.fmt, self._buffer, offset)
+            present[block.field] = block.build(values)
+            offset += block.size
+        return offset

pyixblue/errors.py

@@ -0,0 +1,5 @@
+"""Errors raised while parsing stdbin frames."""
+
+
+class StdBinError(Exception):
+    """A stdbin frame was recognized but could not be parsed."""

pyixblue/models.py

@@ -0,0 +1,741 @@
+"""Decoded stdbin header and navigation blocks.
+
+Status enums follow the bit indexes in the reference decoder. Each member is
+``1 << index``, so a parsed word compares equal to the raw integer.
+"""
+
+from dataclasses import dataclass
+from enum import FlagBoundary, IntFlag, StrEnum
+
+
+def _flag(name: str, members: dict[str, int]) -> type[IntFlag]:
+    """Build an IntFlag that keeps unnamed bits from the wire word."""
+    return IntFlag(name, members, boundary=FlagBoundary.KEEP)  # type: ignore[call-overload]
+
+
+class MessageType(StrEnum):
+    """Kind of stdbin frame."""
+
+    NAV = "nav"
+    ANSWER = "answer"
+
+
+InsAlgorithmStatus1 = _flag(
+    "InsAlgorithmStatus1",
+    {
+        "NAVIGATION": 1 << 0,
+        "ALIGNMENT": 1 << 1,
+        "FINE_ALIGNMENT": 1 << 2,
+        "DEAD_RECKONING": 1 << 3,
+        "GPS_ALTITUDE": 1 << 4,
+        "DEPTHSENSOR_ALTITUDE": 1 << 5,
+        "ZERO_ALTITUDE": 1 << 6,
+        "HYDRO_ALTITUDE": 1 << 7,
+        "LOG_RECEIVED": 1 << 8,
+        "LOG_VALID": 1 << 9,
+        "LOG_WAITING": 1 << 10,
+        "LOG_REJECTED": 1 << 11,
+        "GPS_RECEIVED": 1 << 12,
+        "GPS_VALID": 1 << 13,
+        "GPS_WAITING": 1 << 14,
+        "GPS_REJECTED": 1 << 15,
+        "USBL_RECEIVED": 1 << 16,
+        "USBL_VALID": 1 << 17,
+        "USBL_REJECTED": 1 << 18,
+        "DEPTH_RECEIVED": 1 << 19,
+        "DEPTH_VALID": 1 << 20,
+        "DEPTH_WAITING": 1 << 21,
+        "DEPTH_REJECTED": 1 << 22,
+        "LBL_RECEIVED": 1 << 23,
+        "LBL_VALID": 1 << 24,
+        "LBL_WAITING": 1 << 25,
+        "LBL_REJECTED": 1 << 26,
+        "ALTITUDE_SATURATION": 1 << 27,
+        "SPEED_SATURATION": 1 << 28,
+        "INTERPOLATION_MISSED": 1 << 29,
+        "HEAVE_INITIALISATION": 1 << 30,
+    },
+)
+
+InsAlgorithmStatus2 = _flag(
+    "InsAlgorithmStatus2",
+    {
+        "WATERTRACK_RECEIVED": 1 << 0,
+        "WATERTRACK_VALID": 1 << 1,
+        "WATERTRACK_WAITING": 1 << 2,
+        "WATERTRACK_REJECTED": 1 << 3,
+        "GPS2_RECEIVED": 1 << 4,
+        "GPS2_VALID": 1 << 5,
+        "GPS2_WAITING": 1 << 6,
+        "GPS2_REJECTED": 1 << 7,
+        "ALTITUDE_RECEIVED": 1 << 12,
+        "ALTITUDE_VALID": 1 << 13,
+        "ALTITUDE_WAITING": 1 << 14,
+        "ALTITUDE_REJECTED": 1 << 15,
+        "ZUPT_ACTIVATED": 1 << 16,
+        "ZUPT_VALID": 1 << 17,
+        "RO_ZUPT_ACTIVATED": 1 << 18,
+        "RO_ZUPT_VALID": 1 << 19,
+        "FAST_ALIGNEMENT": 1 << 22,
+        "EMULATION_MODE": 1 << 23,
+        "EMLOG_RECEIVED": 1 << 24,
+        "EMLOG_VALID": 1 << 25,
+        "EMLOG_WAITING": 1 << 26,
+        "EMLOG_REJECTED": 1 << 27,
+        "MANUALGPS_RECEIVED": 1 << 28,
+        "MANUALGPS_VALID": 1 << 29,
+        "MANUALGPS_WAITING": 1 << 30,
+        "MANUALGPS_REJECTED": 1 << 31,
+    },
+)
+
+InsAlgorithmStatus3 = _flag(
+    "InsAlgorithmStatus3",
+    {
+        "SVL_RECEIVED": 1 << 0,
+        "SVL_VALID": 1 << 1,
+        "SVL_WAITING": 1 << 2,
+        "SVL_REJECTED": 1 << 3,
+        "EMLOG2_RECEIVED": 1 << 4,
+        "EMLOG2_VALID": 1 << 5,
+        "EMLOG2_WAITING": 1 << 6,
+        "EMLOG2_REJECTED": 1 << 7,
+        "USBL2_RECEIVED": 1 << 8,
+        "USBL2_VALID": 1 << 9,
+        "USBL2_WAITING": 1 << 10,
+        "USBL2_REJECTED": 1 << 11,
+        "USBL3_RECEIVED": 1 << 12,
+        "USBL3_VALID": 1 << 13,
+        "USBL3_WAITING": 1 << 14,
+        "USBL3_REJECTED": 1 << 15,
+        "CALCHK": 1 << 17,
+        "RESTORE_ATTITUDE_FAILED": 1 << 18,
+        "REL_SPD_ZUPT_ACTIVATED": 1 << 19,
+        "REL_SPD_ZUPT_VALID": 1 << 20,
+        "EXT_SENSOR_OUTDATED": 1 << 21,
+        "SENSOR_USED_BEFORE_CALIB": 1 << 22,
+        "RESTORE_ATTITUDE_REJECTED": 1 << 23,
+        "POLAR_VALIDITY": 1 << 27,
+        "FIRM_INCOMPATIBLES": 1 << 28,
+        "IMO_ALIGNMENT": 1 << 29,
+        "OPTIMAL_ALIGNMENT": 1 << 30,
+        "STRATEGIC_ALIGNMENT": 1 << 31,
+    },
+)
+
+InsAlgorithmStatus4 = _flag(
+    "InsAlgorithmStatus4",
+    {
+        "LOG2_RECEIVED": 1 << 0,
+        "LOG2_VALID": 1 << 1,
+        "LOG2_WAITING": 1 << 2,
+        "LOG2_REJECTED": 1 << 3,
+        "WATERTRACK2_RECEIVED": 1 << 4,
+        "WATERTRACK2_VALID": 1 << 5,
+        "WATERTRACK2_WAITING": 1 << 6,
+        "WATERTRACK2_REJECTED": 1 << 7,
+        "DVL_DIST_TRAVELLED_VALID": 1 << 8,
+        "DVL_CALIBRATION_NONE": 1 << 9,
+        "DVL_ROUGH_CALIBRATION": 1 << 10,
+        "DVL_FINE_CALIBRATION": 1 << 11,
+        "DVL_CHECK_CALIBRATION": 1 << 12,
+        "MANUAL_ATT_RECEIVED": 1 << 13,
+        "MANUAL_ATT_VALID": 1 << 14,
+        "MANUAL_ATT_WAITING": 1 << 15,
+        "MANUAL_ATT_REJECTED": 1 << 16,
+        "FIXED_HEADING": 1 << 17,
+        "DEGRADED_MODE": 1 << 18,
+        "VTG_RECEIVED": 1 << 19,
+        "VTG_VALID": 1 << 20,
+        "VTG_WAITING": 1 << 21,
+        "VTG_REJECTED": 1 << 22,
+        "VTG2_RECEIVED": 1 << 23,
+        "VTG2_VALID": 1 << 24,
+        "VTG2_WAITING": 1 << 25,
+        "VTG2_REJECTED": 1 << 26,
+        "ALIX_SYST_SATURATION": 1 << 27,
+        "CINT_FLASH_MEMORY_WRERR": 1 << 28,
+        "CINT_FLASH_MEMORY_ERERR": 1 << 29,
+        "ODO_CALIBRATION_DONE": 1 << 30,
+        "INCONSISTENT_SENSOR_DATA": 1 << 31,
+    },
+)
+
+# The reference parser reads four status words (16 bytes). Status5 and status6
+# are named in the C++ struct but are not part of that block.
+InsAlgorithmStatus5 = _flag(
+    "InsAlgorithmStatus5",
+    {
+        "NAV_MODE_NONE": 1 << 0,
+        "TRAVELING_MODE": 1 << 1,
+        "FIRING_MODE": 1 << 2,
+        "FIRING_ON_MOVE": 1 << 3,
+        "AERO_TRANSPORTATION": 1 << 4,
+        "MANUAL_ALTITUD_VALID": 1 << 16,
+        "MANUAL_ALTITUDE_REJECTED": 1 << 17,
+        "SHOCK_ACTIVATED": 1 << 18,
+        "SHOCK_DETECTED": 1 << 19,
+        "TR_ZUPT_ACTIVATED": 1 << 20,
+        "TR_ZUPT_VALID": 1 << 21,
+        "PO_ZUPT_ACTIVATED": 1 << 22,
+        "PO_ZUPT_VALID": 1 << 23,
+        "RELATIVE_ATTITUDE_DEGRADED": 1 << 24,
+        "CDSP_FLASH_MEMORY_WRERR": 1 << 25,
+        "CDSP_FLASH_MEMORY_ERERR": 1 << 26,
+        "CINT_FLASH_MEMORY_VIRGIN": 1 << 27,
+        "CDSP_FLASH_MEMORY_VIRGIN": 1 << 28,
+        "CINT_FLASH_MEMORY_ERROR": 1 << 29,
+        "CDSP_FLASH_MEMORY_ERROR": 1 << 30,
+    },
+)
+
+InsSystemStatus1 = _flag(
+    "InsSystemStatus1",
+    {
+        "SERIAL_IN_R_ERR": 1 << 0,
+        "INPUT_A_ERR": 1 << 1,
+        "INPUT_B_ERR": 1 << 2,
+        "INPUT_C_ERR": 1 << 3,
+        "INPUT_D_ERR": 1 << 4,
+        "INPUT_E_ERR": 1 << 5,
+        "INPUT_R_ACTIVITY": 1 << 8,
+        "INPUT_A_ACTIVITY": 1 << 9,
+        "INPUT_B_ACTIVITY": 1 << 10,
+        "INPUT_C_ACTIVITY": 1 << 11,
+        "INPUT_D_ACTIVITY": 1 << 12,
+        "INPUT_E_ACTIVITY": 1 << 13,
+        "OUTPUT_R_FULL": 1 << 16,
+        "OUTPUT_A_FULL": 1 << 17,
+        "OUTPUT_B_FULL": 1 << 18,
+        "OUTPUT_C_FULL": 1 << 19,
+        "OUTPUT_D_FULL": 1 << 20,
+        "OUTPUT_E_FULL": 1 << 21,
+        "ETHERNET_PORT_FULL": 1 << 22,
+        "INTERNAL_TIME_USED": 1 << 24,
+        "ETHERNET_PORT_ACTIVITY": 1 << 26,
+        "PULSE_IN_A_ACTIVITY": 1 << 27,
+        "PULSE_IN_B_ACTIVITY": 1 << 28,
+    },
+)
+
+InsSystemStatus2 = _flag(
+    "InsSystemStatus2",
+    {
+        "GPS_DETECTED": 1 << 2,
+        "DMI_DETECTED": 1 << 8,
+        "UTC_DETECTED": 1 << 9,
+        "ALTITUDE_DETECTED": 1 << 10,
+        "PPS_DETECTED": 1 << 11,
+        "ZUPT_MODE_ACTIVATED": 1 << 12,
+        "MANUAL_GPS_DETECTED": 1 << 14,
+        "WAIT_FOR_POSITION": 1 << 21,
+        "INTERNAL_LOG": 1 << 24,
+        "MPC_OVERLOAD": 1 << 27,
+        "POWER_SUPPLY_FAILURE": 1 << 28,
+        "RD_MODE": 1 << 29,
+        "CONFIGURATION_SAVED": 1 << 30,
+    },
+)
+
+InsSystemStatus3 = _flag(
+    "InsSystemStatus3",
+    {
+        "VTG1_DETECTED": 1 << 13,
+        "MANUAL_ATT_DETECTED": 1 << 15,
+        "INPUT_CAN_ERR": 1 << 16,
+        "INPUT_CAN_ACTIVITY": 1 << 17,
+    },
+)
+
+
+@dataclass(frozen=True, slots=True)
+class AttitudeHeading:
+    heading_deg: float
+    roll_deg: float
+    pitch_deg: float
+
+
+@dataclass(frozen=True, slots=True)
+class AttitudeHeadingDeviation:
+    heading_stddev_deg: float
+    roll_stddev_deg: float
+    pitch_stddev_deg: float
+
+
+@dataclass(frozen=True, slots=True)
+class RealTimeHeaveSurgeSway:
+    rt_heave_without_bdl: float
+    rt_heave_at_bdl: float
+    rt_surge_at_bdl: float
+    rt_sway_at_bdl: float
+
+
+@dataclass(frozen=True, slots=True)
+class SmartHeave:
+    validity_time_100us: int
+    smart_heave_m: float
+
+
+@dataclass(frozen=True, slots=True)
+class HeadingRollPitchRate:
+    heading_rate: float
+    roll_rate: float
+    pitch_rate: float
+
+
+@dataclass(frozen=True, slots=True)
+class RotationRateVesselFrame:
+    xv1_degsec: float
+    xv2_degsec: float
+    xv3_degsec: float
+
+
+@dataclass(frozen=True, slots=True)
+class AccelerationVesselFrame:
+    xv1_msec2: float
+    xv2_msec2: float
+    xv3_msec2: float
+
+
+@dataclass(frozen=True, slots=True)
+class Position:
+    """WGS84 position at the selected lever arm."""
+
+    latitude_deg: float
+    longitude_deg: float
+    altitude_ref: int  # 0: geoid (mean sea level), 1: ellipsoid
+    altitude_m: float
+
+
+@dataclass(frozen=True, slots=True)
+class PositionDeviation:
+    north_stddev_m: float
+    east_stddev_m: float
+    north_east_corr: float
+    altitude_stddev_m: float
+
+
+@dataclass(frozen=True, slots=True)
+class SpeedGeographicFrame:
+    north_msec: float
+    east_msec: float
+    up_msec: float
+
+
+@dataclass(frozen=True, slots=True)
+class SpeedGeographicFrameDeviation:
+    north_stddev_msec: float
+    east_stddev_msec: float
+    up_stddev_msec: float
+
+
+@dataclass(frozen=True, slots=True)
+class CurrentGeographicFrame:
+    north_msec: float
+    east_msec: float
+
+
+@dataclass(frozen=True, slots=True)
+class CurrentGeographicFrameDeviation:
+    north_stddev_msec: float
+    east_stddev_msec: float
+
+
+@dataclass(frozen=True, slots=True)
+class SystemDate:
+    day: int
+    month: int
+    year: int
+
+
+@dataclass(frozen=True, slots=True)
+class SensorStatus:
+    status1: int
+    status2: int
+
+
+@dataclass(frozen=True, slots=True)
+class InsAlgorithmStatus:
+    status1: InsAlgorithmStatus1
+    status2: InsAlgorithmStatus2
+    status3: InsAlgorithmStatus3
+    status4: InsAlgorithmStatus4
+
+
+@dataclass(frozen=True, slots=True)
+class InsSystemStatus:
+    status1: InsSystemStatus1
+    status2: InsSystemStatus2
+    status3: InsSystemStatus3
+
+
+@dataclass(frozen=True, slots=True)
+class InsUserStatus:
+    status: int
+
+
+@dataclass(frozen=True, slots=True)
+class AhrsAlgorithmStatus:
+    status: int
+
+
+@dataclass(frozen=True, slots=True)
+class AhrsSystemStatus:
+    status1: int
+    status2: int
+    status3: int
+
+
+@dataclass(frozen=True, slots=True)
+class AhrsUserStatus:
+    status: int
+
+
+@dataclass(frozen=True, slots=True)
+class HeaveSurgeSwaySpeed:
+    realtime_heave_speed: float
+    surge_speed: float
+    sway_speed: float
+
+
+@dataclass(frozen=True, slots=True)
+class SpeedVesselFrame:
+    xv1_msec: float
+    xv2_msec: float
+    xv3_msec: float
+
+
+@dataclass(frozen=True, slots=True)
+class AccelerationGeographicFrame:
+    north_msec2: float
+    east_msec2: float
+    up_msec2: float
+
+
+@dataclass(frozen=True, slots=True)
+class CourseSpeedOverGround:
+    course_over_ground: float
+    speed_over_ground: float
+
+
+@dataclass(frozen=True, slots=True)
+class Temperatures:
+    mean_temp_fog: float
+    mean_temp_acc: float
+    board_temperature: float
+
+
+@dataclass(frozen=True, slots=True)
+class AttitudeQuaternion:
+    q0: float
+    q1: float
+    q2: float
+    q3: float
+
+
+@dataclass(frozen=True, slots=True)
+class AttitudeQuaternionDeviation:
+    quat_stddev_xi1: float
+    quat_stddev_xi2: float
+    quat_stddev_xi3: float
+
+
+@dataclass(frozen=True, slots=True)
+class RawAccelerationVesselFrame:
+    xv1_msec2: float
+    xv2_msec2: float
+    xv3_msec2: float
+
+
+@dataclass(frozen=True, slots=True)
+class AccelerationVesselFrameDeviation:
+    xv1_stddev_msec2: float
+    xv2_stddev_msec2: float
+    xv3_stddev_msec2: float
+
+
+@dataclass(frozen=True, slots=True)
+class RotationRateVesselFrameDeviation:
+    xv1_stddev_degsec: float
+    xv2_stddev_degsec: float
+    xv3_stddev_degsec: float
+
+
+@dataclass(frozen=True, slots=True)
+class RotationAccelerationVesselFrame:
+    xv1_degsec2: float
+    xv2_degsec2: float
+    xv3_degsec2: float
+
+
+@dataclass(frozen=True, slots=True)
+class RotationAccelerationVesselFrameDeviation:
+    xv1_stddev_degsec2: float
+    xv2_stddev_degsec2: float
+    xv3_stddev_degsec2: float
+
+
+@dataclass(frozen=True, slots=True)
+class RawRotationRateVesselFrame:
+    xv1_degsec: float
+    xv2_degsec: float
+    xv3_degsec: float
+
+
+@dataclass(frozen=True, slots=True)
+class VehicleAttitudeHeading:
+    heading_deg: float
+    roll_deg: float
+    pitch_deg: float
+
+
+@dataclass(frozen=True, slots=True)
+class VehicleAttitudeHeadingDeviation:
+    heading_stddev_deg: float
+    roll_stddev_deg: float
+    pitch_stddev_deg: float
+
+
+@dataclass(frozen=True, slots=True)
+class VehiclePosition:
+    latitude_deg: float
+    longitude_deg: float
+    altitude_ref: int
+    altitude_m: float
+
+
+@dataclass(frozen=True, slots=True)
+class VehiclePositionDeviation:
+    north_stddev_m: float
+    east_stddev_m: float
+    north_east_corr: float
+    altitude_stddev_m: float
+
+
+@dataclass(frozen=True, slots=True)
+class Utc:
+    validity_time_100us: int
+    source: int
+
+
+@dataclass(frozen=True, slots=True)
+class Gnss:
+    validity_time_100us: int
+    gnss_id: int
+    gnss_quality: int
+    latitude_deg: float
+    longitude_deg: float
+    altitude_m: float
+    latitude_stddev_m: float
+    longitude_stddev_m: float
+    altitude_stddev_m: float
+    lat_lon_stddev_m2: float
+    geoidal_separation_m: float
+
+
+@dataclass(frozen=True, slots=True)
+class Emlog:
+    validity_time_100us: int
+    emlog_id: int
+    xv1_water_speed_ms: float
+    xv1_speed_stddev_ms: float
+
+
+@dataclass(frozen=True, slots=True)
+class Usbl:
+    validity_time_100us: int
+    usbl_id: int
+    beacon_id: bytes
+    latitude_deg: float
+    longitude_deg: float
+    altitude_m: float
+    north_stddev_m: float
+    east_stddev_m: float
+    lat_lon_cov_m2: float
+    altitude_stddev_m: float
+
+
+@dataclass(frozen=True, slots=True)
+class Depth:
+    validity_time_100us: int
+    depth_m: float
+    depth_stddev_m: float
+
+
+@dataclass(frozen=True, slots=True)
+class DvlGroundSpeed:
+    validity_time_100us: int
+    dvl_id: int
+    xv1_ground_speed_ms: float
+    xv2_ground_speed_ms: float
+    xv3_ground_speed_ms: float
+    dvl_speed_of_sound_ms: float
+    dvl_altitude_m: float
+    xv1_stddev_ms: float
+    xv2_stddev_ms: float
+    xv3_stddev_ms: float
+
+
+@dataclass(frozen=True, slots=True)
+class DvlWaterSpeed:
+    validity_time_100us: int
+    dvl_id: int
+    xv1_water_speed_ms: float
+    xv2_water_speed_ms: float
+    xv3_water_speed_ms: float
+    dvl_speed_of_sound_ms: float
+    xv1_stddev_ms: float
+    xv2_stddev_ms: float
+    xv3_stddev_ms: float
+
+
+@dataclass(frozen=True, slots=True)
+class SoundVelocity:
+    validity_time_100us: int
+    ext_speed_of_sound_ms: float
+
+
+@dataclass(frozen=True, slots=True)
+class Dmi:
+    validity_time_100us: int
+    pulse_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class Lbl:
+    validity_time_100us: int
+    rfu: int
+    beacon_id: bytes
+    beacon_latitude_deg: float
+    beacon_longitude_deg: float
+    beacon_altitude_m: float
+    range_m: float
+    range_stddev_m: float
+
+
+@dataclass(frozen=True, slots=True)
+class EventMarker:
+    validity_time_100us: int
+    event_id: int
+    event_count: int
+
+
+@dataclass(frozen=True, slots=True)
+class TurretAngles:
+    validity_time_100us: int
+    heading_bearing_drift_angle_deg: float
+    roll_deg: float
+    elevation_pitch_deg: float
+
+
+@dataclass(frozen=True, slots=True)
+class Vtg:
+    validity_time_100us: int
+    vtg_id: int
+    true_course_deg: float
+    magnetic_course_deg: float
+    speed_over_ground_ms: float
+
+
+@dataclass(frozen=True, slots=True)
+class LogBook:
+    validity_time_100us: int
+    log_id: int
+    custom_text: bytes
+
+
+@dataclass(frozen=True, slots=True)
+class NavHeader:
+    """Parsed stdbin header.
+
+    ``extended_navigation_bit_mask`` is set on protocol versions 3 and later.
+    ``navigation_size`` is set on versions 4 and 5. Answer frames leave the
+    navigation fields unset. ``counter`` is the frame counter carried in the
+    navigation header.
+    """
+
+    message_type: MessageType
+    protocol_version: int
+    telegram_size: int
+    navigation_bit_mask: int | None = None
+    extended_navigation_bit_mask: int | None = None
+    external_sensor_bit_mask: int | None = None
+    navigation_size: int | None = None
+    validity_time_100us: int | None = None
+    counter: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class NavData:
+    """Navigation, extended-navigation, and external-sensor blocks.
+
+    A field is ``None`` when that block's mask bit was clear in the frame.
+    """
+
+    attitude_heading: AttitudeHeading | None = None
+    attitude_heading_deviation: AttitudeHeadingDeviation | None = None
+    rt_heave_surge_sway: RealTimeHeaveSurgeSway | None = None
+    smart_heave: SmartHeave | None = None
+    heading_roll_pitch_rate: HeadingRollPitchRate | None = None
+    rotation_rate_vessel_frame: RotationRateVesselFrame | None = None
+    acceleration_vessel_frame: AccelerationVesselFrame | None = None
+    position: Position | None = None
+    position_deviation: PositionDeviation | None = None
+    speed_geographic_frame: SpeedGeographicFrame | None = None
+    speed_geographic_frame_deviation: SpeedGeographicFrameDeviation | None = None
+    current_geographic_frame: CurrentGeographicFrame | None = None
+    current_geographic_frame_deviation: CurrentGeographicFrameDeviation | None = None
+    system_date: SystemDate | None = None
+    sensor_status: SensorStatus | None = None
+    ins_algorithm_status: InsAlgorithmStatus | None = None
+    ins_system_status: InsSystemStatus | None = None
+    ins_user_status: InsUserStatus | None = None
+    ahrs_algorithm_status: AhrsAlgorithmStatus | None = None
+    ahrs_system_status: AhrsSystemStatus | None = None
+    ahrs_user_status: AhrsUserStatus | None = None
+    heave_surge_sway_speed: HeaveSurgeSwaySpeed | None = None
+    speed_vessel_frame: SpeedVesselFrame | None = None
+    acceleration_geographic_frame: AccelerationGeographicFrame | None = None
+    course_speed_over_ground: CourseSpeedOverGround | None = None
+    temperatures: Temperatures | None = None
+    attitude_quaternion: AttitudeQuaternion | None = None
+    attitude_quaternion_deviation: AttitudeQuaternionDeviation | None = None
+    raw_acceleration_vessel_frame: RawAccelerationVesselFrame | None = None
+    acceleration_vessel_frame_deviation: AccelerationVesselFrameDeviation | None = None
+    rotation_rate_vessel_frame_deviation: RotationRateVesselFrameDeviation | None = None
+    rotation_acceleration_vessel_frame: RotationAccelerationVesselFrame | None = None
+    rotation_acceleration_vessel_frame_deviation: (
+        RotationAccelerationVesselFrameDeviation | None
+    ) = None
+    raw_rotation_rate_vessel_frame: RawRotationRateVesselFrame | None = None
+    vehicle_attitude_heading: VehicleAttitudeHeading | None = None
+    vehicle_attitude_heading_deviation: VehicleAttitudeHeadingDeviation | None = None
+    vehicle_position: VehiclePosition | None = None
+    vehicle_position_deviation: VehiclePositionDeviation | None = None
+    utc: Utc | None = None
+    gnss1: Gnss | None = None
+    gnss2: Gnss | None = None
+    gnss_manual: Gnss | None = None
+    emlog1: Emlog | None = None
+    emlog2: Emlog | None = None
+    usbl1: Usbl | None = None
+    usbl2: Usbl | None = None
+    usbl3: Usbl | None = None
+    depth: Depth | None = None
+    dvl_ground_speed1: DvlGroundSpeed | None = None
+    dvl_water_speed1: DvlWaterSpeed | None = None
+    sound_velocity: SoundVelocity | None = None
+    dmi: Dmi | None = None
+    lbl1: Lbl | None = None
+    lbl2: Lbl | None = None
+    lbl3: Lbl | None = None
+    lbl4: Lbl | None = None
+    event_marker_a: EventMarker | None = None
+    event_marker_b: EventMarker | None = None
+    event_marker_c: EventMarker | None = None
+    dvl_ground_speed2: DvlGroundSpeed | None = None
+    dvl_water_speed2: DvlWaterSpeed | None = None
+    turret_angles: TurretAngles | None = None
+    vtg1: Vtg | None = None
+    vtg2: Vtg | None = None
+    log_book: LogBook | None = None

pyixblue-0.9.1.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.5
+Name: pyixblue
+Version: 0.9.1
+Summary: Python parser for the iXblue stdbin protocol
+License: MIT License
+        
+        Copyright (c) 2026 pyixblue contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pyixblue
+
+Python parser for the iXblue stdbin output protocol (versions 2 through 5).
+
+stdbin is the binary navigation output of iXblue inertial systems. This package
+reassembles and decodes those frames. It does not open a socket or a serial
+port; pass in the bytes you receive over UDP, TCP, or serial.
+
+The block layout and checksum follow the MIT-licensed
+[ixblue_stdbin_decoder](https://github.com/ixblue/ixblue_stdbin_decoder).
+
+## Install
+
+```sh
+pip install .
+```
+
+From a checkout, with the development tests:
+
+```sh
+uv sync
+```
+
+## Usage
+
+```python
+from pyixblue import StdBinDecoder
+
+decoder = StdBinDecoder()
+decoder.add_new_data(chunk)  # bytes-like; a chunk may be a partial frame
+while decoder.parse_next_frame():  # False when more bytes are needed
+    header = decoder.last_header
+    if header.message_type == "nav":
+        nav = decoder.last_nav  # missing blocks are None
+        if nav.position is not None:
+            print(nav.position.latitude_deg, nav.position.longitude_deg)
+    else:
+        payload = decoder.last_answer
+```
+
+`parse_next_frame` raises `StdBinError` when a frame is recognized but its
+protocol version or checksum is invalid. The decoder drops the bad version
+byte, or the whole frame after a bad checksum, so the next call can resync.
+
+Navigation, extended-navigation, and external-sensor blocks are present only
+when their mask bit is set. INS algorithm and system status words are `IntFlag`
+values (`1 << bit`), so they compare equal to the raw integer:
+
+```python
+from pyixblue.models import InsAlgorithmStatus1
+
+if nav.ins_algorithm_status is not None:
+    status = nav.ins_algorithm_status.status1
+    if InsAlgorithmStatus1.NAVIGATION in status:
+        print(hex(status))
+```
+
+## Protocol
+
+Supported output frames:
+
+| Kind | Magic | Versions |
+| --- | --- | --- |
+| Navigation | `IX` | 2, 3, 4, 5 |
+| Answer | `AN` | 3, 4, 5 |
+
+Multi-byte fields are big-endian. The checksum is the low 32 bits of the sum of
+every preceding byte, stored as a big-endian `uint32`.
+
+Version 3 adds the extended-navigation mask. Versions 4 and 5 add the
+navigation-data size. The header also keeps the frame `counter`, which the
+reference C++ header discards.
+
+## License
+
+MIT. Sample frames under `tests/fixtures/` were converted from the
+ixblue_stdbin_decoder test logs (MIT, Copyright (c) 2019 iXblue SAS).

pyixblue-0.9.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+pyixblue/__init__.py,sha256=KpU2LKmNtJDEq0Yotng20qhTaD1UkwaaAEVFGk5fgLg,329
+pyixblue/blocks.py,sha256=WG3UBTIcN2FLKFMPxBftypEONM312A1J16NhHEosKPU,8376
+pyixblue/decoder.py,sha256=-CfLxC8pv12XMBwYi1FcEMNBzgv0rRW7z7bVbv-8Akg,7225
+pyixblue/errors.py,sha256=pdlekg_twMl_yixDsNEYhmusT2lUf8iHs23awiTit7E,146
+pyixblue/models.py,sha256=EcEYWIHNQGvCrEkt_2WV6KDSnyfDQdRNwLTaParLl90,20038
+pyixblue-0.9.1.dist-info/METADATA,sha256=Sy7xjajJJ7ZTqpCmv3Nbov_qciCg0pqSEvRGIdogQdQ,3845
+pyixblue-0.9.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pyixblue-0.9.1.dist-info/licenses/LICENSE,sha256=pU1irPeAPFXmO_KBMP6ZHVLQESMaGczfZuAAy-GLp54,1078
+pyixblue-0.9.1.dist-info/RECORD,,

pyixblue-0.9.1.dist-info/WHEEL

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

pyixblue-0.9.1.dist-info/licenses/LICENSE

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