bottomtime 0.3.0__tar.gz → 0.4.0__tar.gz

{bottomtime-0.3.0 → bottomtime-0.4.0}/.gitignore

@@ -4,7 +4,6 @@ __pycache__/
 dist/
 .pytest_cache/
 .mypy_cache/
-.claude/settings.local.json
 
 # Personal dive data lives outside version control
 data/

{bottomtime-0.3.0 → bottomtime-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bottomtime
-Version: 0.3.0
+Version: 0.4.0
 Summary: Lossless dive-log store: ingest, decode, and reconcile dives from Garmin (FIT) and Shearwater (Petrel Native Format) dive computers
 Project-URL: Homepage, https://github.com/snehankekre/bottomtime
 Project-URL: Issues, https://github.com/snehankekre/bottomtime/issues
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.10
 Requires-Dist: garmin-fit-sdk>=21.0
+Requires-Dist: pnf>=0.1.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == 'dev'
 Provides-Extra: plot

{bottomtime-0.3.0 → bottomtime-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bottomtime"
-version = "0.3.0"
+version = "0.4.0"
 description = "Lossless dive-log store: ingest, decode, and reconcile dives from Garmin (FIT) and Shearwater (Petrel Native Format) dive computers"
 readme = "README.md"
 license = "MIT"
@@ -18,7 +18,7 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Topic :: Scientific/Engineering",
 ]
-dependencies = ["garmin-fit-sdk>=21.0"]
+dependencies = ["garmin-fit-sdk>=21.0", "pnf>=0.1.0"]
 
 [project.optional-dependencies]
 plot = ["matplotlib>=3.5"]
@@ -33,3 +33,8 @@ Issues = "https://github.com/snehankekre/bottomtime/issues"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/bottomtime"]
+
+[tool.hatch.build.targets.sdist]
+# Positive allowlist: the sdist ships only the package, its tests, and the
+# standard metadata files, so local tooling and CI config stay out of releases.
+include = ["/src", "/tests", "/README.md", "/LICENSE"]

{bottomtime-0.3.0 → bottomtime-0.4.0}/src/bottomtime/__init__.py

@@ -1,6 +1,6 @@
 """bottomtime: lossless dive-log store for multi-computer divers."""
 
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 
 from .api import list_dives, load_dive
 

{bottomtime-0.3.0 → bottomtime-0.4.0}/src/bottomtime/api.py

@@ -11,7 +11,7 @@ import json
 import sqlite3
 from pathlib import Path
 
-from .decode.pnf import COMPUTER_MODELS
+from pnf import COMPUTER_MODELS
 
 _SAMPLE_TABLES = {"garmin": "garmin_samples", "shearwater": "shearwater_samples"}
 

{bottomtime-0.3.0 → bottomtime-0.4.0}/src/bottomtime/ingest/shearwater_db.py

@@ -1,10 +1,10 @@
 """Ingest a Shearwater Cloud database (dive_data.db / 'Export Database').
 
 Each dive's complete native log lives in log_data.data_bytes_1 as an sw-pnf
-blob (decoded by bottomtime.decode.pnf); dive_details supplies the metadata
-layer (gas plan JSON, EndGF99, site/notes when present). The blob is stored
-verbatim in source_dives.raw_blob in addition to the archived .db, so every
-Shearwater byte is preserved twice over.
+blob (decoded by the pnf package); dive_details supplies the metadata layer
+(gas plan JSON, EndGF99, site/notes when present). The blob is stored verbatim
+in source_dives.raw_blob in addition to the archived .db, so every Shearwater
+byte is preserved twice over.
 """
 
 from __future__ import annotations
@@ -15,10 +15,18 @@ import sqlite3
 from datetime import datetime, timezone
 from pathlib import Path
 
-from ..decode import pnf
+import pnf
+
 from ..store.db import source_dive_exists
 from .archive import archive_file
 
+# Decode-contract version stamped on each Shearwater source dive so that an
+# archive-first re-decode can find dives produced by an older decode. Bump this
+# whenever a pnf upgrade changes decoded output. History: 1 libdivecomputer
+# field set, 2 empirical ceiling/gf99/battery/@+5, 3 pnf reconciliation
+# (DCIEM branch, 16-bit battery, battery %, SAC, status bits).
+DECODER_VERSION = 3
+
 
 def _details_row(con: sqlite3.Connection, dive_id: str) -> dict:
     row = con.execute(
@@ -123,7 +131,7 @@ def _ingest_log(
             artifact_id,
             source_key,
             digest,
-            pnf.DECODER_VERSION,
+            DECODER_VERSION,
             start_local,
             dive.header.get("divetime_s"),
             dive.header.get("max_depth_m"),

bottomtime-0.4.0/tests/test_decoder_dependency.py

@@ -0,0 +1,40 @@
+"""Contract test for the pnf decoder dependency.
+
+The PNF decoder lives in the standalone `pnf` package (with its own full test
+suite). bottomtime depends on it and relies on a specific surface: the
+`decode` entry point, the `COMPUTER_MODELS` table, and a set of sample fields
+the Shearwater ingest inserts into `shearwater_samples`. This test pins that
+contract so a breaking pnf upgrade fails here rather than at ingest time.
+"""
+
+import pnf
+
+
+def test_decode_entry_points_exist():
+    assert callable(pnf.decode)
+    assert callable(pnf.decompress)
+    assert 11 in pnf.COMPUTER_MODELS  # Perdix 2, surfaced by api.computer_info
+
+
+def test_sample_has_fields_ingest_inserts():
+    # Every column bottomtime writes to shearwater_samples from a decoded
+    # sample (see ingest/shearwater_db.py).
+    fields = pnf.Sample.__dataclass_fields__
+    for name in (
+        "t_s", "depth_m", "temp_c", "stop_depth_m", "stop_or_ndl_min", "tts_min",
+        "in_deco", "avg_ppo2", "o2_pct", "he_pct", "setpoint", "cns_pct",
+        "gf99", "ceiling_m", "safe_ascent_depth_m", "battery_pct", "sac",
+        "sensor1_raw", "sensor2_raw", "sensor3_raw",
+        "sensor1_ppo2", "sensor2_ppo2", "sensor3_ppo2",
+        "battery_v", "status_flags", "solenoid_fired_count",
+        "tank0_psi", "tank1_psi", "gas_time_min", "extra",
+    ):
+        assert name in fields, f"pnf.Sample lost field {name!r}"
+
+
+def test_dive_shape_ingest_reads():
+    for attr in ("header", "samples", "gases", "events", "unknown_records",
+                 "sample_interval_ms"):
+        assert attr in pnf.Dive.__dataclass_fields__, f"pnf.Dive lost {attr!r}"
+    for attr in ("index", "o2_pct", "he_pct", "diluent", "enabled"):
+        assert attr in pnf.Gas.__dataclass_fields__, f"pnf.Gas lost {attr!r}"

bottomtime-0.3.0/.github/workflows/test.yml

@@ -1,20 +0,0 @@
-name: test
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.10", "3.14"]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-      - run: pip install -e .[dev]
-      - run: pytest -q

bottomtime-0.3.0/src/bottomtime/decode/pnf.py

@@ -1,503 +0,0 @@
-"""Pure-Python decoder for Shearwater's Petrel Native Format (PNF).
-
-Shearwater Cloud stores each dive as a `sw-pnf` blob: a 4-byte little-endian
-uncompressed-length prefix followed by a gzip stream. The decompressed payload
-is a sequence of 32-byte records; byte 0 of each record is its type:
-
-  0x01       dive sample            0x10-0x19  opening (config) records
-  0x02       freedive sample (4x8)  0x20-0x29  closing records
-  0x03       Avelo sample           0x30       info event
-  0xE1       extended dive sample   0xFF       final record
-
-Byte offsets follow libdivecomputer's shearwater_predator_parser.c: sample
-fields sit at legacy-offset + 1 (the PNF type byte), opening/closing record
-fields at the absolute offsets used for their legacy 128-byte block.
-
-Record types this decoder does not understand are returned raw in
-`PnfDive.unknown_records`; nothing is dropped.
-
-DECODER_VERSION history:
-  1  initial port of the libdivecomputer field set
-  2  adds ceiling_m (byte 24), gf99 (byte 25), battery_v (byte 18 / 100) and
-     @+5 TTS (bytes 26-27), identified empirically: byte 25 converges on
-     dive_details.EndGF99 and decays during surface offgassing; byte 24 sits
-     just below the 3 m-quantized stop depth and zeroes when deco clears;
-     byte 18 equals the XML export's batteryVoltage x 100
-  3  reconciled against Shearwater Cloud's own parser (DiveLogParser.dll,
-     class PetrelNativeLogV14Parser, read from the desktop app). Every sample
-     byte 0-31 is now named. Changes vs v2:
-     - bytes 24/25 are ceiling/gf99 only under gradient-factor deco models;
-       under DCIEM (deco model 3) they are a safe-ascent depth instead
-       (byte 24 integer metres, byte 25 hundredths), decoded to
-       safe_ascent_depth_m with ceiling_m/gf99 left None.
-     - battery_v is a 16-bit value: (byte 17 << 8 | byte 18) / 100, not byte 18
-       alone (byte 17 is zero only because a ~1.5 V cell never needs it; a
-       higher-voltage computer such as a Teric would overflow the old read).
-     - byte 11 is battery_pct (BATTERY_PERCENT_REMAINING).
-     - bytes 30-31 are sac (surface air consumption, u16 / 100; 0xFFFF = n/a).
-"""
-
-from __future__ import annotations
-
-import gzip
-import struct
-from dataclasses import dataclass, field
-
-DECODER_VERSION = 3
-
-RECORD_SIZE = 32
-
-DIVE_SAMPLE = 0x01
-FREEDIVE_SAMPLE = 0x02
-AVELO_SAMPLE = 0x03
-OPENING_0, OPENING_9 = 0x10, 0x19
-CLOSING_0, CLOSING_9 = 0x20, 0x29
-INFO_EVENT = 0x30
-DIVE_SAMPLE_EXT = 0xE1
-FINAL = 0xFF
-
-# Sample byte 12 is a packed status/mode byte. Bit meanings per Shearwater's
-# PetrelNativeLogV14Parser: 0 gas-switch-needed, 1 external ppO2, 2 setpoint
-# type (high/low), 3 circuit-switch type, 4 circuit mode (set = OC on this
-# family), 5 CCR mode, 6-7 solenoid-fired count.
-FLAG_GASSWITCH = 0x01
-FLAG_PPO2_EXTERNAL = 0x02
-FLAG_SETPOINT_HIGH = 0x04
-FLAG_SC = 0x08
-FLAG_OC = 0x10
-FLAG_CCR_MODE = 0x20
-SOLENOID_COUNT_SHIFT = 6
-
-DIVE_MODES = {
-    0: "cc",
-    1: "oc_tec",
-    2: "gauge",
-    3: "ppo2",
-    4: "sc",
-    5: "cc2",
-    6: "oc_rec",
-    7: "freedive",
-    12: "avelo",
-}
-
-DECO_MODELS = {0: "gf", 1: "vpmb", 2: "vpmb_gfs", 3: "dciem"}
-
-# Final-record byte 13 model ids, names per libdivecomputer's descriptors.
-# The PNF layout is shared across the family; bottomtime's field mappings are
-# validated so far on Petrel 3 (10) and Perdix 2 (11) logs.
-COMPUTER_MODELS = {
-    2: "Predator",
-    3: "Petrel",
-    4: "Nerd",
-    5: "Perdix",
-    6: "Perdix AI",
-    7: "Nerd 2",
-    8: "Teric",
-    9: "Peregrine",
-    10: "Petrel 3",
-    11: "Perdix 2",
-    12: "Tern",
-}
-
-# As of v3 every sample byte 0-31 is named (reconciled against Shearwater's
-# own PetrelNativeLogV14Parser), so no bytes are stashed raw in extra_json.
-SAC_SENTINEL = 0xFFFF  # bytes 30-31 when no air integration / no SAC
-
-
-def _u16be(data: bytes, off: int) -> int:
-    return struct.unpack_from(">H", data, off)[0]
-
-
-def _u24be(data: bytes, off: int) -> int:
-    return (data[off] << 16) | (data[off + 1] << 8) | data[off + 2]
-
-
-def _u32be(data: bytes, off: int) -> int:
-    return struct.unpack_from(">I", data, off)[0]
-
-
-def _bcd2dec(value: int) -> int:
-    return ((value >> 4) & 0x0F) * 10 + (value & 0x0F)
-
-
-def _bcd_bytes(data: bytes, off: int, n: int) -> int:
-    result = 0
-    for i in range(n):
-        result = result * 100 + _bcd2dec(data[off + i])
-    return result
-
-
-@dataclass
-class PnfSample:
-    t_s: float
-    depth_m: float | None = None
-    temp_c: float | None = None
-    stop_depth_m: float | None = None
-    stop_or_ndl_min: float | None = None
-    tts_min: float | None = None
-    in_deco: int | None = None
-    avg_ppo2: float | None = None
-    o2_pct: float | None = None
-    he_pct: float | None = None
-    setpoint: float | None = None
-    cns_pct: float | None = None
-    gf99: float | None = None
-    ceiling_m: float | None = None
-    safe_ascent_depth_m: float | None = None  # DCIEM only (bytes 24-25)
-    battery_pct: int | None = None
-    sac: float | None = None
-    sensor1_raw: int | None = None
-    sensor2_raw: int | None = None
-    sensor3_raw: int | None = None
-    sensor1_ppo2: float | None = None
-    sensor2_ppo2: float | None = None
-    sensor3_ppo2: float | None = None
-    battery_v: float | None = None
-    status_flags: int | None = None
-    gas_switch_needed: bool | None = None
-    ppo2_external: bool | None = None
-    setpoint_high: bool | None = None
-    circuit_switch: bool | None = None
-    circuit_mode: int | None = None
-    ccr_mode: int | None = None
-    solenoid_fired_count: int | None = None
-    tank0_psi: float | None = None
-    tank1_psi: float | None = None
-    gas_time_min: float | None = None
-    extra: dict = field(default_factory=dict)
-
-
-@dataclass
-class PnfGas:
-    index: int
-    o2_pct: int
-    he_pct: int
-    diluent: bool
-    enabled: bool
-
-
-@dataclass
-class PnfEvent:
-    t_s: float
-    event: int
-    timestamp: int
-    w1: int
-    w2: int
-    raw_hex: str
-
-
-@dataclass
-class PnfDive:
-    header: dict
-    samples: list[PnfSample]
-    gases: list[PnfGas]
-    events: list[PnfEvent]
-    unknown_records: list[tuple[str, int, bytes]]  # (type_key, seq, raw)
-    sample_interval_ms: int
-
-
-def decompress(blob: bytes) -> bytes:
-    """Strip the 4-byte LE length prefix and gunzip; verify the length."""
-    expected = struct.unpack_from("<I", blob, 0)[0]
-    data = gzip.decompress(blob[4:])
-    if len(data) != expected:
-        raise ValueError(f"PNF length mismatch: prefix {expected}, got {len(data)}")
-    if len(data) % RECORD_SIZE:
-        raise ValueError(f"PNF payload not a multiple of {RECORD_SIZE} bytes")
-    return data
-
-
-def decode(blob: bytes) -> PnfDive:
-    """Decode a raw sw-pnf blob (as stored in Shearwater Cloud's log_data)."""
-    data = decompress(blob)
-
-    opening: dict[int, int] = {}
-    closing: dict[int, int] = {}
-    final_off: int | None = None
-    raw_records: list[tuple[int, int]] = []  # (type, offset), stream order
-
-    for off in range(0, len(data), RECORD_SIZE):
-        rec = data[off : off + RECORD_SIZE]
-        if rec == b"\x00" * RECORD_SIZE:
-            continue
-        rtype = rec[0]
-        raw_records.append((rtype, off))
-        if OPENING_0 <= rtype <= OPENING_9:
-            opening[rtype - OPENING_0] = off
-        elif CLOSING_0 <= rtype <= CLOSING_9:
-            closing[rtype - CLOSING_0] = off
-        elif rtype == FINAL:
-            final_off = off
-
-    for i in range(5):
-        if i not in opening or i not in closing:
-            raise ValueError(f"missing opening/closing record {i}")
-
-    header = _parse_header(data, opening, closing, final_off)
-    interval_ms = header["sample_interval_ms"]
-    calibrated = header["sensor_calibrated_mask"]
-    calibration = header["sensor_calibration"]
-    imperial = header["imperial"]
-
-    gases = [
-        PnfGas(
-            index=i,
-            o2_pct=header["gas_o2"][i],
-            he_pct=header["gas_he"][i],
-            diluent=i >= 5,
-            enabled=bool(header["gas_enabled_mask"] & (1 << i)),
-        )
-        for i in range(10)
-    ]
-
-    samples: list[PnfSample] = []
-    events: list[PnfEvent] = []
-    unknown: list[tuple[str, int, bytes]] = []
-    seq = 0
-    t = 0.0
-
-    is_dciem = header["deco_model"] == "dciem"
-
-    for rtype, off in raw_records:
-        rec = data[off : off + RECORD_SIZE]
-        if rtype in (DIVE_SAMPLE, AVELO_SAMPLE):
-            samples.append(
-                _parse_sample(
-                    rec, t, imperial, calibrated, calibration, rtype, is_dciem
-                )
-            )
-            t += interval_ms / 1000.0
-        elif rtype == FREEDIVE_SAMPLE:
-            for i in range(4):
-                sub = rec[i * 8 : (i + 1) * 8]
-                if sub == b"\x00" * 8:
-                    break
-                pressure_mbar = _u16be(sub, 1)
-                depth = (
-                    (pressure_mbar - header["atmospheric_mbar"])
-                    * 100.0
-                    / (header["water_density"] * 9.80665)
-                )
-                temp = struct.unpack_from(">h", sub, 3)[0] / 10.0
-                samples.append(PnfSample(t_s=t, depth_m=round(depth, 2), temp_c=temp))
-                t += interval_ms / 1000.0
-        elif rtype == DIVE_SAMPLE_EXT:
-            s = samples[-1] if samples else None
-            for i, key in enumerate(("tank2_psi", "tank3_psi")):
-                v = _u16be(rec, 1 + i * 2)
-                if v < 0xFFF0 and (v & 0x0FFF) and s is not None:
-                    s.extra[key] = (v & 0x0FFF) * 2
-            for i, key in enumerate(("tank_dil_psi", "tank_o2_psi")):
-                v = _u16be(rec, 1 + 4 + i * 2)
-                if v and s is not None:
-                    s.extra[key] = v * 2
-        elif rtype == INFO_EVENT:
-            events.append(
-                PnfEvent(
-                    t_s=t,
-                    event=rec[1],
-                    timestamp=_u32be(rec, 4),
-                    w1=_u32be(rec, 8),
-                    w2=_u32be(rec, 12),
-                    raw_hex=rec.hex(),
-                )
-            )
-        elif OPENING_0 <= rtype <= OPENING_9 or CLOSING_0 <= rtype <= CLOSING_9 or rtype == FINAL:
-            pass  # consumed by _parse_header; raw copies kept in header dict
-        else:
-            unknown.append((f"0x{rtype:02x}", seq, rec))
-        seq += 1
-
-    return PnfDive(
-        header=header,
-        samples=samples,
-        gases=gases,
-        events=events,
-        unknown_records=unknown,
-        sample_interval_ms=interval_ms,
-    )
-
-
-def _parse_sample(
-    rec: bytes,
-    t: float,
-    imperial: bool,
-    calibrated: int,
-    calibration: list[float],
-    rtype: int,
-    is_dciem: bool,
-) -> PnfSample:
-    ft = 0.3048
-    depth = _u16be(rec, 1) / 10.0
-    stop_depth = float(_u16be(rec, 3))
-    if imperial:
-        depth *= ft
-        stop_depth *= ft
-
-    temp = struct.unpack_from("b", rec, 14)[0]
-    if temp < 0:
-        temp = min(temp + 102, 0)
-    if imperial:
-        temp = (temp - 32.0) * 5.0 / 9.0
-
-    status = rec[12] if rtype != AVELO_SAMPLE else 0
-    ccr = (status & FLAG_OC) == 0 if rtype != AVELO_SAMPLE else False
-    decoded_status = rtype != AVELO_SAMPLE
-
-    sample = PnfSample(
-        t_s=t,
-        depth_m=round(depth, 2),
-        temp_c=float(temp),
-        stop_depth_m=stop_depth,
-        tts_min=float(_u16be(rec, 5)),
-        stop_or_ndl_min=float(rec[10]),
-        in_deco=1 if _u16be(rec, 3) else 0,
-        avg_ppo2=rec[7] / 100.0,
-        o2_pct=float(rec[8]),
-        he_pct=float(rec[9]),
-        status_flags=status,
-        sensor1_raw=rec[13],
-        sensor2_raw=rec[15],
-        sensor3_raw=rec[16],
-        cns_pct=float(rec[23]),
-        battery_pct=rec[11],
-        battery_v=((rec[17] << 8) | rec[18]) / 100.0,
-    )
-
-    if decoded_status:
-        sample.gas_switch_needed = bool(status & FLAG_GASSWITCH)
-        sample.ppo2_external = bool(status & FLAG_PPO2_EXTERNAL)
-        sample.setpoint_high = bool(status & FLAG_SETPOINT_HIGH)
-        sample.circuit_switch = bool(status & FLAG_SC)
-        sample.circuit_mode = (status >> 4) & 1
-        sample.ccr_mode = (status >> 5) & 1
-        sample.solenoid_fired_count = (status >> SOLENOID_COUNT_SHIFT) & 3
-
-    # Bytes 24-25 are ceiling + GF99 under gradient-factor deco models. Under
-    # DCIEM (deco model 3) the same two bytes are a safe-ascent depth: byte 24
-    # whole metres, byte 25 hundredths, subtracted.
-    if is_dciem:
-        sample.safe_ascent_depth_m = rec[24] - rec[25] / 100.0
-    else:
-        if rec[24] != 0xFF:
-            sample.ceiling_m = float(rec[24])
-        if rec[25] != 0xFF:  # 0xFF = not available (still on-gassing)
-            sample.gf99 = float(rec[25])
-
-    sac_raw = _u16be(rec, 30)
-    if sac_raw != SAC_SENTINEL:
-        sample.sac = sac_raw / 100.0
-
-    if ccr:
-        sample.setpoint = rec[19] / 100.0
-        if not (status & FLAG_PPO2_EXTERNAL):
-            if calibrated & 0x01:
-                sample.sensor1_ppo2 = round(rec[13] * calibration[0], 3)
-            if calibrated & 0x02:
-                sample.sensor2_ppo2 = round(rec[15] * calibration[1], 3)
-            if calibrated & 0x04:
-                sample.sensor3_ppo2 = round(rec[16] * calibration[2], 3)
-
-    for idx, key in ((20, "tank1_psi"), (28, "tank0_psi")):
-        v = _u16be(rec, idx)
-        if v < 0xFFF0:
-            pressure = v & 0x0FFF
-            battery = (v >> 12) & 0x0F
-            if key == "tank1_psi":
-                sample.tank1_psi = pressure * 2.0
-            else:
-                sample.tank0_psi = pressure * 2.0
-            if battery:
-                sample.extra[key + "_battery"] = battery
-
-    if rec[22] < 0xF0:
-        sample.gas_time_min = float(rec[22])
-
-    # @+5: TTS if the diver stayed 5 more minutes (minutes, u16be)
-    at_plus_five = _u16be(rec, 26)
-    if at_plus_five != 0xFFFF:
-        sample.extra["at_plus_five_min"] = at_plus_five
-
-    return sample
-
-
-def _parse_header(
-    data: bytes,
-    opening: dict[int, int],
-    closing: dict[int, int],
-    final_off: int | None,
-) -> dict:
-    o = opening
-    c = closing
-
-    logversion = data[o[4] + 16]
-    imperial = data[o[0] + 8] == 1
-
-    gas_o2 = [data[o[0] + 20 + i] for i in range(10)]
-    gas_he = [data[o[0] + 30 + i] for i in range(2)] + [
-        data[o[1] + 1 + i] for i in range(8)
-    ]
-
-    calib_base = o[3] + 6
-    calibrated_mask = data[calib_base]
-    calibration = [
-        _u16be(data, calib_base + 1 + i * 2) / 100000.0 for i in range(3)
-    ]
-
-    interval_ms = 10000
-    if logversion >= 9 and 5 in o:
-        interval_ms = _u16be(data, o[5] + 23) or 10000
-
-    max_depth = _u16be(data, c[0] + 4) / 10.0
-    if imperial:
-        max_depth *= 0.3048
-
-    header = {
-        "logversion": logversion,
-        "imperial": imperial,
-        "divemode": DIVE_MODES.get(data[o[4] + 1], str(data[o[4] + 1])),
-        "gf_low": data[o[0] + 4],
-        "gf_high": data[o[0] + 5],
-        "deco_model": DECO_MODELS.get(data[o[2] + 18], str(data[o[2] + 18])),
-        "vpmb_conservatism": data[o[2] + 19],
-        "atmospheric_mbar": _u16be(data, o[1] + 16),
-        "water_density": _u16be(data, o[3] + 3),
-        "sensor_calibrated_mask": calibrated_mask,
-        "sensor_calibration": calibration,
-        "gas_o2": gas_o2,
-        "gas_he": gas_he,
-        "gas_enabled_mask": _u16be(data, o[4] + 17),
-        "ai_mode": data[o[4] + 28],
-        "sample_interval_ms": interval_ms,
-        "max_depth_m": round(max_depth, 2),
-        "divetime_s": _u24be(data, c[0] + 6),
-    }
-
-    if final_off is not None:
-        header["computer_serial"] = _u32be(data, final_off + 2)
-        header["computer_firmware"] = _bcd2dec(data[final_off + 10])
-        header["computer_model"] = data[final_off + 13]
-
-    if logversion >= 17:
-        for name, recs in (("gnss_start", o), ("gnss_end", c)):
-            if 9 in recs:
-                off = recs[9]
-                fix = data[off + 16]
-                if fix in (2, 3):  # 2D / 3D fix
-                    lat = struct.unpack_from(">i", data, off + 21)[0] / 100000.0
-                    lon = struct.unpack_from(">i", data, off + 25)[0] / 100000.0
-                    header[name] = {"fix": fix, "lat": lat, "lon": lon}
-
-    # Verbatim copies of every config record, keyed by record type.
-    header["raw_opening"] = {
-        f"0x{OPENING_0 + i:02x}": data[off : off + RECORD_SIZE].hex()
-        for i, off in sorted(o.items())
-    }
-    header["raw_closing"] = {
-        f"0x{CLOSING_0 + i:02x}": data[off : off + RECORD_SIZE].hex()
-        for i, off in sorted(c.items())
-    }
-    if final_off is not None:
-        header["raw_final"] = data[final_off : final_off + RECORD_SIZE].hex()
-
-    return header

bottomtime-0.3.0/src/bottomtime/verify/__init__.py

@@ -1 +0,0 @@
-

bottomtime-0.3.0/tests/test_pnf.py

@@ -1,188 +0,0 @@
-"""PNF decoder tests against a synthetic blob built record by record."""
-
-import gzip
-import struct
-
-import pytest
-
-from bottomtime.decode import pnf
-
-
-def _record(rtype: int, payload: dict[int, bytes] | None = None) -> bytearray:
-    rec = bytearray(32)
-    rec[0] = rtype
-    for offset, data in (payload or {}).items():
-        rec[offset : offset + len(data)] = data
-    return rec
-
-
-def _sample(depth_dm: int, **kw) -> bytearray:
-    rec = _record(pnf.DIVE_SAMPLE)
-    struct.pack_into(">H", rec, 1, depth_dm)
-    struct.pack_into(">H", rec, 3, kw.get("stop_m", 0))
-    struct.pack_into(">H", rec, 5, kw.get("tts_min", 0))
-    rec[7] = kw.get("ppo2_raw", 21)
-    rec[8] = kw.get("o2", 21)
-    rec[9] = kw.get("he", 0)
-    rec[10] = kw.get("ndl_min", 99)
-    rec[11] = kw.get("battery_pct", 100)
-    rec[12] = kw.get("flags", pnf.FLAG_OC)
-    rec[14] = kw.get("temp", 27) & 0xFF
-    rec[17] = kw.get("battery_msb", 0)
-    rec[18] = kw.get("battery_raw", 152)
-    struct.pack_into(">H", rec, 20, 0xFFFF)  # AI off
-    rec[22] = 0xFF  # gas time not paired
-    rec[23] = kw.get("cns", 0)
-    rec[24] = kw.get("ceiling", 0xFF)
-    rec[25] = kw.get("gf99", 0xFF)
-    struct.pack_into(">H", rec, 26, kw.get("at_plus_five", 0))
-    struct.pack_into(">H", rec, 28, 0xFFFF)  # AI off
-    struct.pack_into(">H", rec, 30, kw.get("sac_raw", 0xFFFF))  # SAC n/a
-    return rec
-
-
-def build_blob(samples=None, interval_ms=10000, extra_records=None, deco_model=0) -> bytes:
-    records = []
-
-    opening0 = _record(0x10)
-    opening0[4], opening0[5] = 40, 80  # GF low/high
-    opening0[8] = 0  # metric
-    opening0[20] = 21  # gas 0 O2
-    opening0[21] = 50  # gas 1 O2
-    records.append(opening0)
-
-    opening1 = _record(0x11)
-    struct.pack_into(">H", opening1, 16, 1013)  # atmospheric mbar
-    records.append(opening1)
-
-    opening2 = _record(0x12)
-    opening2[18] = deco_model  # 0=GF, 1=VPM-B, 2=VPM-B/GFS, 3=DCIEM
-    records.append(opening2)
-
-    opening3 = _record(0x13)
-    struct.pack_into(">H", opening3, 3, 1020)  # density
-    records.append(opening3)
-
-    opening4 = _record(0x14)
-    opening4[1] = 1  # OC tec
-    opening4[16] = 13  # log version
-    struct.pack_into(">H", opening4, 17, 0b11)  # gases 0,1 enabled
-    records.append(opening4)
-
-    opening5 = _record(0x15)
-    struct.pack_into(">H", opening5, 23, interval_ms)
-    records.append(opening5)
-
-    records.extend(samples or [])
-    records.extend(extra_records or [])
-
-    for i in range(5):
-        rec = _record(0x20 + i)
-        if i == 0:
-            struct.pack_into(">H", rec, 4, 528)  # max depth dm
-            rec[6:9] = (3374).to_bytes(3, "big")
-        records.append(rec)
-
-    final = _record(0xFF)
-    struct.pack_into(">I", final, 2, 0xA823C228)
-    final[13] = 11
-    records.append(final)
-
-    raw = b"".join(bytes(r) for r in records)
-    return struct.pack("<I", len(raw)) + gzip.compress(raw)
-
-
-def test_header():
-    dive = pnf.decode(build_blob(samples=[_sample(24)]))
-    h = dive.header
-    assert (h["gf_low"], h["gf_high"]) == (40, 80)
-    assert h["deco_model"] == "gf"
-    assert h["atmospheric_mbar"] == 1013
-    assert h["water_density"] == 1020
-    assert h["divemode"] == "oc_tec"
-    assert h["max_depth_m"] == 52.8
-    assert h["divetime_s"] == 3374
-    assert h["computer_serial"] == 0xA823C228
-    assert h["sample_interval_ms"] == 10000
-    assert [g for g in dive.gases if g.enabled and g.o2_pct] == dive.gases[:2]
-
-
-def test_samples():
-    dive = pnf.decode(
-        build_blob(
-            samples=[
-                _sample(24, ndl_min=99),
-                _sample(528, stop_m=9, tts_min=14, cns=4, ceiling=9, gf99=30, o2=21),
-            ]
-        )
-    )
-    assert len(dive.samples) == 2
-    s0, s1 = dive.samples
-    assert (s0.t_s, s1.t_s) == (0.0, 10.0)
-    assert s0.depth_m == 2.4
-    assert s0.gf99 is None and s0.ceiling_m is None  # 0xFF sentinel
-    assert s0.battery_v == 1.52
-    assert s0.tank0_psi is None and s0.gas_time_min is None
-    assert s1.depth_m == 52.8
-    assert (s1.stop_depth_m, s1.tts_min, s1.in_deco) == (9.0, 14.0, 1)
-    assert (s1.ceiling_m, s1.gf99, s1.cns_pct) == (9.0, 30.0, 4.0)
-    assert s0.battery_pct == 100
-    assert s0.sac is None  # 0xFFFF sentinel
-
-
-def test_battery_voltage_is_16bit():
-    # A higher-voltage computer (e.g. Teric rechargeable ~4.2 V) overflows a
-    # single byte, so the decoder must read bytes 17-18 together.
-    dive = pnf.decode(build_blob(samples=[_sample(24, battery_msb=1, battery_raw=164)]))
-    assert dive.samples[0].battery_v == round((1 << 8 | 164) / 100.0, 2)  # 4.20 V
-
-
-def test_sac_when_present():
-    dive = pnf.decode(build_blob(samples=[_sample(24, sac_raw=1234)]))
-    assert dive.samples[0].sac == 12.34
-
-
-def test_status_byte_bits_decoded():
-    flags = 0x01 | 0x20 | (2 << 6)  # gas-switch-needed + CCR mode + solenoid count 2
-    dive = pnf.decode(build_blob(samples=[_sample(24, flags=flags)]))
-    s = dive.samples[0]
-    assert s.gas_switch_needed is True
-    assert s.ccr_mode == 1
-    assert s.solenoid_fired_count == 2
-    assert s.circuit_mode == 0
-    assert s.setpoint_high is False
-    assert s.status_flags == flags
-
-
-def test_dciem_uses_safe_ascent_depth():
-    # Under DCIEM (deco model 3), bytes 24-25 are a safe-ascent depth, not
-    # ceiling/GF99: byte 24 whole metres minus byte 25 hundredths.
-    blob = build_blob(samples=[_sample(300, ceiling=6, gf99=50)], deco_model=3)
-    dive = pnf.decode(blob)
-    assert dive.header["deco_model"] == "dciem"
-    s = dive.samples[0]
-    assert s.ceiling_m is None and s.gf99 is None
-    assert s.safe_ascent_depth_m == 6 - 0.50  # 5.5 m
-
-
-def test_unknown_records_preserved():
-    mystery = _record(0x51, {1: b"\xde\xad\xbe\xef"})
-    dive = pnf.decode(build_blob(samples=[_sample(24)], extra_records=[mystery]))
-    assert len(dive.unknown_records) == 1
-    type_key, _seq, raw = dive.unknown_records[0]
-    assert type_key == "0x51"
-    assert raw == bytes(mystery)
-
-
-def test_length_prefix_validated():
-    blob = build_blob(samples=[_sample(24)])
-    corrupted = struct.pack("<I", 999999) + blob[4:]
-    with pytest.raises(ValueError, match="length mismatch"):
-        pnf.decode(corrupted)
-
-
-def test_imperial_units():
-    samples = [_sample(100)]  # 10.0 units
-    blob = build_blob(samples=samples)
-    dive = pnf.decode(blob)
-    assert dive.samples[0].depth_m == 10.0  # metric build