oep-client-python 0.0.46__tar.gz → 0.0.48__tar.gz

{oep_client_python-0.0.46 → oep_client_python-0.0.48}/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## Unreleased
 
+## 0.0.48
+- (EN) Fixed: a stream's segments join bit by bit, so a stream is one part unless data was lost. A segment whose
+  samples did not fill whole bytes of each line (the ESP32-P4's 65332 samples of 2 lines at 5 and 10 MS/s) started a new
+  part every time: 300 to 550 parts, none lost. A format 1 segment whose samples are not a multiple of every D still
+  starts a new part (its ticks restart, capture §1.3).
+- (JA) 修正: stream の区画を 1 bit ずつつなぐ。欠損がなければ、stream は 1 つの部分になる。線ごとに標本がバイトの切れ目で
+  終わらない区画（ESP32-P4 の 2 本の線の 65332 標本、5 MS/s と 10 MS/s）では、そのたびに新しい部分を始めていて、欠損なしで
+  300〜550 の部分に分かれていた。format 1 で標本数がどの D の倍数でもない区画は、今までどおり新しい部分を始める
+  （その刻みが始め直しになるため、capture §1.3）。
+
+## 0.0.47
+- (EN) Added: `acquire.Request(during=steps)` for a stream in place of `seconds`: it streams until `steps(wait)`
+  returns, `wait(seconds)` collecting while it waits, so a script marks sections and sends ops or console commands on
+  the same session (no second thread or session) while one long capture runs. A loss with on_loss "stop" raises
+  `acquire.StreamStopped` out of `wait`; the stream ends there. An exception of the steps stops the capture and comes out.
+- (JA) 追加: stream の `acquire.Request(during=steps)`（`seconds` の代わり）。`steps(wait)` が戻るまで取り込み、
+  `wait(秒)` の間に受け取る。1 本の長い取り込みの間に、同じセッションで区間の見出しを書き、op やコンソールの命令を送れる
+  （別のスレッドもセッションも要らない）。on_loss "stop" で欠損があると、`wait` から `acquire.StreamStopped` が出て、
+  そこで取り込みを終える。steps の例外は、取り込みを止めてから外に出る。
+- (EN) Added: acquire's channels take a port's line by the target pin, `S@P` (host guide §5.3; `x035@pb9`), besides
+  `S.N` and the probe's channel names.
+- (JA) 追加: acquire のチャネルに、口の線を相手のピンで指す `S@P`（host ガイド §5.3、`x035@pb9`）も使える。`S.N` と
+  プローブのチャネル名に加えて。
+- (EN) CI and the release run the tests four at a time by file (pytest-xdist, a dev dependency): most tests wait on real
+  timeouts, so the run drops from about 6 minutes to about 2.
+- (JA) CI とリリースは、試験をファイルごとに並べて流す（pytest-xdist、開発用の依存）。多くの試験は実際の時間切れを待つので、約 6 分が約 2 分になる。
+
 ## 0.0.46
 - (EN) Changed (oep-spec 4d28f24): `SpiController.transfer` and `Pwm.set` read the answer's count n(u8) first, and the
   virtual bench sends it; the memo's max_objects is read as u16. Registry, documents and vectors synced; the checkers'

{oep_client_python-0.0.46 → oep_client_python-0.0.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: oep-client-python
-Version: 0.0.46
+Version: 0.0.48
 Summary: Open Embedded Probe (OEP) v1 host: serial / USB / TCP transports, the session rules, the standard interfaces, and a virtual bench
 Project-URL: Homepage, https://github.com/Open-Embedded-Probe/oep-client-python
 Project-URL: Repository, https://github.com/Open-Embedded-Probe/oep-client-python

{oep_client_python-0.0.46 → oep_client_python-0.0.48}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "oep-client-python"
-version = "0.0.46"
+version = "0.0.48"
 description = "Open Embedded Probe (OEP) v1 host: serial / USB / TCP transports, the session rules, the standard interfaces, and a virtual bench"
 readme = "README.md"
 license = "MIT"
@@ -42,7 +42,7 @@ packages = ["src/oep_client"]
 only-include = ["src/oep_client", "tests", "docs", "udev", "README.md", "README.ja.md", "CHANGELOG.md", "LICENSE", "pyproject.toml"]
 
 [dependency-groups]
-dev = ["pytest>=8"]
+dev = ["pytest>=8", "pytest-xdist>=3"]
 
 [tool.pytest.ini_options]
 markers = ["hw: needs a probe board (OEP_HW_BOARDS=<board-identify ids>); skipped otherwise (tests/hw/README.md)",

{oep_client_python-0.0.46 → oep_client_python-0.0.48}/src/oep_client/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.0.46"
+__version__ = "0.0.48"

{oep_client_python-0.0.46 → oep_client_python-0.0.48}/src/oep_client/acquire.py

@@ -11,14 +11,25 @@ probe's facts out.
 
 Logic channels go to oep.fixture.logic, analog ones to oep.fixture.analog; with both, oep.fixture.capture-group
 starts them together, a trigger on either track as the group's trigger source (capture §4.4). A line is named as a
-script keeps it - the probe's channel name (fn 0's channel_name, core §7.5) or a port's line label (S.N, host guide
-§5.3) - and looked up on the session (a channel number holds for one boot only); a track's channels are its plan roles
+script keeps it - the probe's channel name (fn 0's channel_name, core §7.5) or a port's line label (host guide §5.3:
+S.N by its role, S@P by the target pin) - and looked up on the session (a channel number holds for one boot only); a track's channels are its plan roles
 0..C-1 in the order given. The plans are released afterwards.
 
 Modes: "oneshot" (the probe's memory), "repeat" (`segments` acquisitions read and released as they come: with a
 trigger one part each, layout "segments"; without, a timeline), "stream" (for `seconds`, sent as taken,
 put together on disk while it runs: a timeline, cut where data was lost).
 
+A stream can run while the script does its steps on the same session (marking sections, sending console commands):
+`during=steps` in place of `seconds` streams until steps(wait) returns, `wait(seconds)` collecting while it waits.
+Steps should call wait often (the probe holds only its stream buffer meanwhile); a loss with on_loss "stop" raises
+StreamStopped out of wait, and the stream ends there.
+
+    def steps(wait):
+        for duty in (64, 128):
+            with rec.section(2, f"duty={duty}"):
+                console.write(f"PWM {duty}\n".encode()); wait(0.5)
+    res = acquire.capture(hst, acquire.Request(chans, 1_000_000, 0, mode="stream", during=steps))
+
 Times: tick 0 of a part is its first logic sample, `start_ns` on the probe's clock; an analog channel starts at
 t0_ticks = (its segment's start_ns - that) plus its skew_ns, in ticks. These are the probe's estimates; each track's
 uncertainty is kept. ADC values are kept raw with the probe's linear conversion; the input range, reference, Vrefint
@@ -37,13 +48,14 @@ import array
 import math
 import struct
 import sys
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from fractions import Fraction
 from pathlib import Path
 
 from . import registry as _reg
 
-__all__ = ["Analog", "Bits", "Changes", "OnDisk", "Part", "Request", "Result", "capture", "capture_at"]
+__all__ = ["Analog", "Bits", "Changes", "OnDisk", "Part", "Request", "Result", "StreamStopped", "capture", "capture_at"]
 
 TRIGGERS = ("high", "low", "rise", "fall", "both")
 ANALOG_TRIGGERS = ("high", "low", "rise", "fall")
@@ -52,7 +64,8 @@ ANALOG_TRIGGERS = ("high", "low", "rise", "fall")
 @dataclass
 class Request:
     channels: list[tuple[str, str]]          # logic: (name to record, the line): the probe's channel name (fn 0's
-                                             # channel_name, GPIO47) or a port's line label (S.N, x035.swdio), in order
+                                             # channel_name, GPIO47) or a port's line label (S.N, x035.swdio; S@P,
+                                             # x035@pb9), in order
     rate: int                                # logic samples per second asked for (the probe may answer another)
     samples: int
     trigger: tuple | None = None             # (logic channel, one of TRIGGERS) or (analog channel, rise / fall / high /
@@ -69,6 +82,8 @@ class Request:
     segments: int | None = None              # repeat: how many acquisitions
     on_loss: str = "stop"                    # stream: "stop" at the first loss, or "continue" to the end
     spool_dir: str | None = None             # stream: where its channels are put together on disk while it runs
+    during: Callable[[Callable[[float], None]], None] | None = None   # stream: instead of `seconds`, runs until this
+                                             # returns - called with wait(seconds), which collects while it waits
 
     def __post_init__(self):
         names = [n for n, _ in self.channels] + [n for n, *_ in self.analog]
@@ -92,8 +107,10 @@ class Request:
                 raise ValueError("repeat: logic channels only")
         elif self.segments is not None:
             raise ValueError("segments is for repeat only")
-        if self.mode == "stream" and not (self.seconds and self.seconds > 0):
-            raise ValueError("a stream needs seconds (how long)")
+        if self.during is not None and (self.mode != "stream" or self.seconds is not None):
+            raise ValueError("during is for a stream, in place of seconds")
+        if self.mode == "stream" and self.during is None and not (self.seconds and self.seconds > 0):
+            raise ValueError("a stream needs seconds (how long) or during")
         if self.arm not in ("pretrigger", "now"):
             raise ValueError(f"arm {self.arm!r}: pretrigger or now")
         logic = {n for n, _ in self.channels}
@@ -567,7 +584,8 @@ def _describe(core, hst, fn: int) -> list[tuple[int, bytes]]:
 
 def _channels(core, hst, lines: list[str]) -> list[int]:
     """The probe's channel numbers (valid for this boot) of lines named as kept in scripts: a channel name (fn 0's
-    channel_name, core §7.5; GPIO47) or a port's line label (S.N, host guide §5.3; x035.swdio). ASCII case aside."""
+    channel_name, core §7.5; GPIO47) or a port's line label (host guide §5.3: S.N by its role, x035.swdio; S@P by the target pin, x035@pb9). ASCII
+    case aside."""
     if not lines:
         return []
     from . import registry, settings
@@ -581,11 +599,13 @@ def _channels(core, hst, lines: list[str]) -> list[int]:
     labels = None
     out = []
     for line in lines:
-        port_line = settings.port_line(line)
-        if port_line is not None:
+        label = settings.parse_label(line)
+        if label is not None:
             if labels is None:
                 labels = settings.labels(hst)
-            ch = settings.line_from_labels(labels, port_line[1], port_line[0])
+            port, role, pin = label
+            ch = (settings.line_from_labels(labels, role, port) if role
+                  else settings.pin_from_labels(labels, pin, port))
             if ch is None:
                 raise ValueError(f"{line}: no channel carries that label (host guide §5.3)")
         else:
@@ -1133,6 +1153,35 @@ STREAM_MAX_DELAY_MS = 20  # ... or after this long. With (0, 0) the P4X sent eac
                           # quiet lines) as a transfer of its own, 2000 a second, and dropped 35 % it could not send
 
 
+class StreamStopped(Exception):
+    """Raised by a stream's `wait` (Request.during) when data was lost and on_loss is "stop": the stream stops there."""
+
+
+def _drive(req: Request, poll, lost) -> None:
+    """Collect a started stream: for req.seconds, or while req.during(wait) runs - its `wait(seconds)` collecting
+    meanwhile. poll(seconds) takes what comes, lost() says whether anything was lost; with on_loss "stop" a loss ends
+    it (a StreamStopped out of wait, caught here)."""
+    import time
+
+    def wait(seconds: float) -> None:
+        deadline = time.monotonic() + seconds
+        while True:
+            now = time.monotonic()
+            if now >= deadline:
+                return
+            poll(min(STREAM_POLL_S, deadline - now))
+            if req.on_loss == "stop" and lost():
+                raise StreamStopped("data was lost while streaming")
+
+    try:
+        if req.during is None:
+            wait(req.seconds)
+        else:
+            req.during(wait)
+    except StreamStopped:
+        pass
+
+
 def _collect_group(group, tracks, link, req: Request, oc, spool=None):
     """_collect for a group's streaming tracks (capture §4.1: each subscribed, started at once): -> ({fn: Received},
     seconds). The first track's Received goes to the spool as it comes; a loss in any track stops it with "stop"."""
@@ -1141,20 +1190,22 @@ def _collect_group(group, tracks, link, req: Request, oc, spool=None):
         t.subscribe(STREAM_MIN_BYTES, STREAM_MAX_DELAY_MS)
     group.start(tracks)
     t_read = time.monotonic()
-    deadline, got = t_read + req.seconds, {t.fn: oc.Received() for t in tracks}
+    got = {t.fn: oc.Received() for t in tracks}
     lead = tracks[0].fn
-    while True:
-        now = time.monotonic()
-        if now >= deadline:
-            break
-        got = group.stream(link, tracks, seconds=min(STREAM_POLL_S, deadline - now), into=got)
+
+    def poll(seconds):
+        group.stream(link, tracks, seconds=seconds, into=got)
         if spool is not None:
             spool.take(got[lead])
-        lost = (spool is not None and spool.lost) or any(
+
+    def lost():
+        return (spool is not None and spool.lost) or any(
             g.gaps or (g.start or 0) > 0 for fn, g in got.items() if spool is None or fn != lead)
-        if req.on_loss == "stop" and lost:
-            break
-    group.stop()
+
+    try:
+        _drive(req, poll, lost)
+    finally:
+        group.stop()                             # also when the caller's `during` raised: the probe is left stopped
     got = group.finish(link, tracks, got)
     return got, time.monotonic() - t_read
 
@@ -1182,25 +1233,26 @@ def _analog_runs(an, acfg, got) -> tuple[list, list]:
 
 
 def _collect(track, link, req: Request, oc, spool=None):
-    """Subscribe, start, collect for req.seconds, stop and collect the rest -> (Received, seconds). A loss stops it
-    at once with on_loss "stop"."""
+    """Subscribe, start, collect for req.seconds (or while req.during runs), stop and collect the rest -> (Received,
+    seconds). A loss stops it at once with on_loss "stop"."""
     import time
     track.subscribe(STREAM_MIN_BYTES, STREAM_MAX_DELAY_MS)   # batched: a capture wants bandwidth, not a frame per block
     track.start()
     t_read = time.monotonic()
-    deadline, got = t_read + req.seconds, oc.Received()
-    while True:                                  # stream() renews the lease across calls on the same Received
-        now = time.monotonic()
-        if now >= deadline:
-            break
-        got = track.stream(link, seconds=min(STREAM_POLL_S, deadline - now), into=got)
+    got = oc.Received()
+
+    def poll(seconds):                           # stream() renews the lease across calls on the same Received
+        track.stream(link, seconds=seconds, into=got)
         if spool is not None:                    # put together as it comes: memory holds a poll's worth, not the stream
             spool.take(got)
-            if req.on_loss == "stop" and spool.lost:
-                break
-        elif req.on_loss == "stop" and (got.gaps or (got.start or 0) > 0):
-            break
-    track.stop()
+
+    def lost():
+        return spool.lost if spool is not None else bool(got.gaps or (got.start or 0) > 0)
+
+    try:
+        _drive(req, poll, lost)
+    finally:
+        track.stop()
     got = track.finish(link, got)
     return got, time.monotonic() - t_read
 
@@ -1603,14 +1655,14 @@ class _Spool:
             p, nxt = ready[k][0], ready[j][1]
             x = self.segs[p]
             samples = sum(self.segs.pop(q).samples for q, _ in ready[k:j + 1])
-            if self.cur is not None and (self.cur["samples"] % 8 or any(self.cur["samples"] % d for d in self.ds)):
+            if self.cur is not None and any(self.cur["samples"] % d for d in self.ds):
                 self._close(follows=True)      # a grid restart (format 1) is not a loss: the next part follows on
             self._open(p, x)
             data = bytes(self.pending[p - self.at:nxt - self.at])
             cols = _segment_columns(self.cap, data, samples, len(self.names), self.cfg)
-            for col, f, ev in zip(cols, self.cur["files"], self.cur["events"]):
-                if isinstance(col, bytes):
-                    f.write(col[:(samples + 7) // 8])
+            for j, (col, f, ev) in enumerate(zip(cols, self.cur["files"], self.cur["events"])):
+                if isinstance(col, bytes):           # joined bit by bit: a segment need not end on a whole byte
+                    self.cur["carry"][j] = _write_bits(f, self.cur["carry"][j], col, samples)
                 else:
                     ev[0].append(col[0] + self.cur["samples"] // col[4])
                     ev[1].append(col[1])
@@ -1641,7 +1693,7 @@ class _Spool:
         k = len(self.parts)
         files = [open(os.path.join(self.dir, f"p{k}-{j}.bits"), "wb") for j in range(len(self.names))]
         self.cur = {"tick0": tick0, "meta": _seg_meta(seg) if seg is not None else {}, "samples": 0, "files": files,
-                    "events": [[[], [], [], None] for _ in self.names]}
+                    "events": [[[], [], [], None] for _ in self.names], "carry": [None] * len(self.names)}
         self._follows = False
 
     _last_samples, _last_end, _follows = 0, None, False
@@ -1653,6 +1705,7 @@ class _Spool:
         cur, n = self.cur, self.cur["samples"]
         chans = []
         for role, (name, ch, f, ev) in enumerate(zip(self.names, self.ids, cur["files"], cur["events"])):
+            _flush_bits(f, cur["carry"][role])
             f.close()
             d = self.cfg.event_d.get(role) if self.blocks else None
             if d is not None:
@@ -1739,7 +1792,7 @@ def _stream_parts(cap, cfg, got, names, ids, req: Request) -> tuple[list, list]:
                 chans = from_interleaved(data, names, cfg.width, cfg.positions, samples)
             else:
                 chans = _from_blocks(cap, data, names, samples, cfg)
-            restart = acc is not None and (acc_samples % 8 or any(acc_samples % d for d in ds))
+            restart = acc is not None and any(acc_samples % d for d in ds)
             if acc is None or restart:           # a grid restart (format 1) is not a loss: the next part follows on
                 if acc is not None:
                     parts.append(_part(_built(acc, acc_samples, ids), acc_meta, tick0))
@@ -1813,10 +1866,41 @@ def _samples_at_once(run, names, ids, cfg, samples: int) -> list:
             for name, ch, bits in zip(names, ids, packed)]
 
 
+def _write_bits(f, carry, col: bytes, samples: int):
+    """Append `samples` bits of `col` (sample i at bit i % 8 of byte i // 8) to file `f` after the `carry` bits not
+    yet written (None: none): whole bytes go to the file, the bits left over (fewer than 8) come back as the carry."""
+    if carry is None and samples % 8 == 0:
+        f.write(col[:samples // 8])
+        return None
+    import numpy as np
+    bits = np.unpackbits(np.frombuffer(col, np.uint8, (samples + 7) // 8), bitorder="little")[:samples]
+    if carry is not None:
+        bits = np.concatenate([carry, bits])
+    whole = len(bits) // 8 * 8
+    f.write(np.packbits(bits[:whole], bitorder="little").tobytes())
+    return bits[whole:] if whole < len(bits) else None
+
+
+def _flush_bits(f, carry) -> None:
+    """The last carry of _write_bits: its bits in one byte, the rest 0."""
+    if carry is not None and len(carry):
+        import numpy as np
+        f.write(np.packbits(carry, bitorder="little").tobytes())
+
+
+def _join_bits(pieces) -> bytes:
+    """Pieces (bits, n) joined bit by bit: n need not be a multiple of 8."""
+    if all(n % 8 == 0 for _, n in pieces[:-1]):
+        return b"".join(b[:(n + 7) // 8] for b, n in pieces)
+    import numpy as np
+    return np.packbits(np.concatenate([np.unpackbits(np.frombuffer(b, np.uint8, (n + 7) // 8), bitorder="little")[:n]
+                                       for b, n in pieces]), bitorder="little").tobytes()
+
+
 class _Acc:
-    """One channel of a part being joined from its segments (bits: whole bytes, the part's samples so far a multiple
-    of 8; events: quanta offset by the samples so far, a multiple of D). A segment that follows on carries the level
-    before it as its start (§1.3), so its changes join the part's as they are."""
+    """One channel of a part being joined from its segments (bits: joined bit by bit; events: quanta offset by the
+    samples so far, a multiple of D). A segment that follows on carries the level before it as its start (§1.3), so
+    its changes join the part's as they are."""
     def __init__(self, c):
         self.first, self.pieces = c, []
         self.start = getattr(c, "start_level", None)
@@ -1842,8 +1926,7 @@ def _built(acc: list, samples: int, ids) -> list:
                 ct += c_
             out.append(changes(c.name, ks, lv, ct, -(-samples // c.step), c.step, 0, a.start, pin=ch))
         else:
-            out.append(Bits(c.name, b"".join(b for b, _ in a.pieces)[:(samples + 7) // 8], samples, 1, 0,
-                                          {"pin": ch}))
+            out.append(Bits(c.name, _join_bits(a.pieces)[:(samples + 7) // 8], samples, 1, 0, {"pin": ch}))
     return out
 
 

{oep_client_python-0.0.46 → oep_client_python-0.0.48}/tests/test_acquire.py

@@ -86,6 +86,35 @@ def test_a_stream_is_put_together_on_a_timeline(probe, tmp_path):
     assert n > 0 and all(isinstance(c, acquire.Bits) for p in res.parts for c in p.channels)
 
 
+def test_a_stream_runs_while_the_caller_works_on_the_same_session(probe, tmp_path):
+    hst = link.open_host(probe())
+    try:
+        core.take(hst, 30_000, owner="test")
+        seen = []
+
+        def steps(wait):                                   # sections: a request on the session, then collect meanwhile
+            for _ in range(3):
+                seen.append(hst.clock_best(2).uptime_ns)
+                wait(0.1)
+        req = acquire.Request([("A", "GPIO10")], 1_000_000, 0, mode="stream", during=steps, spool_dir=str(tmp_path))
+        res = acquire.capture(hst, req)
+        assert res.complete and res.parts and len(seen) == 3 and seen == sorted(seen)
+        assert sum(p.channels[0].n for p in res.parts) > 0
+        with pytest.raises(RuntimeError):                  # the caller's own failure stops the stream and comes out
+            acquire.capture(hst, acquire.Request([("A", "GPIO10")], 1_000_000, 0, mode="stream",
+                                                 during=lambda wait: (wait(0.05), (_ for _ in ()).throw(RuntimeError()))))
+        assert acquire.capture(hst, acquire.Request([("A", "GPIO10")], 1_000_000, 0, mode="stream", seconds=0.1)).complete
+    finally:
+        hst.end()
+        hst.link.close()
+
+
+def test_during_is_for_a_stream_in_place_of_seconds():
+    for kw in ({"mode": "oneshot"}, {"mode": "stream", "seconds": 1.0}):
+        with pytest.raises(ValueError):
+            acquire.Request([("A", "GPIO10")], 1_000_000, 100, during=lambda wait: None, **kw)
+
+
 def test_format_1_lines_as_their_changes(probe):
     req = acquire.Request([("A", "GPIO10"), ("B", "GPIO11")], 20_000_000, 1000, resolution={"B": 1})
     res = acquire.capture_at(probe(), req)
@@ -128,11 +157,51 @@ def test_probe_clock_against_the_host():
 
 
 def test_lines_are_named_by_channel_name_or_label(probe):
-    src = probe("--label", "13=bus.sda")
-    res = acquire.capture_at(src, acquire.Request([("D", "bus.SDA"), ("E", "gpio11")], 20_000_000, 100))
-    assert [c.acquisition["pin"] for c in res.channels] == [13, 11]          # the label's channel; names any case
-    assert res.meta["probe_channels"] == {"D": 13, "E": 11}
+    src = probe("--label", "13=bus.sda", "--label", "12=bus@PB9")
+    res = acquire.capture_at(src, acquire.Request([("D", "bus.SDA"), ("E", "gpio11"), ("F", "BUS@pb9")], 20_000_000, 100))
+    assert [c.acquisition["pin"] for c in res.channels] == [13, 11, 12]      # by role, by name, by the target pin (S@P)
+    assert res.meta["probe_channels"] == {"D": 13, "E": 11, "F": 12}
     with pytest.raises(ValueError, match="no channel of that name"):
         acquire.capture_at(probe(), acquire.Request([("A", "10")], 20_000_000, 100))     # a number is not a name
     with pytest.raises(ValueError, match="no channel carries that label"):
         acquire.capture_at(probe(), acquire.Request([("A", "x035.nrst")], 20_000_000, 100))
+
+
+def test_stream_segments_join_bit_by_bit(tmp_path):
+    """A stream's segments need not end on a whole byte of each line (2 lines in 2-bit samples, 65332 samples a
+    segment on the P4): they join into one part, bit by bit - parts are cut only where data was lost."""
+    import random
+    import types
+    from oep_client.capture import SegmentInfo
+    rnd = random.Random(1)
+    n_seg, per = 3, 12                                  # 12 samples: 3 bytes of the stream, 1.5 bytes a line
+    a = [rnd.randrange(2) for _ in range(n_seg * per)]
+    b = [rnd.randrange(2) for _ in range(n_seg * per)]
+    data = bytearray()
+    for i in range(0, len(a), 4):                       # sample i: bits 2i (A) and 2i + 1 (B) of the stream
+        v = 0
+        for j in range(4):
+            v |= (a[i + j] | b[i + j] << 1) << (2 * j)
+        data.append(v)
+    segs = {k * 3: SegmentInfo(k * 3, per, 1_000_000 + k * per * 200, 50) for k in range(n_seg)}
+    got = types.SimpleNamespace(data=data, segments=segs, gaps=[], start=0)
+    cfg = types.SimpleNamespace(rate=5_000_000, width=2, positions=None, event_d={})
+    req = acquire.Request([("A", "x"), ("B", "y")], 5_000_000, 0, mode="stream", seconds=1)
+    parts, lost = acquire._stream_parts(None, cfg, got, ["A", "B"], [10, 11], req)
+    assert not lost and len(parts) == 1
+    got_a, got_b = (list(levels(c)) for c in parts[0].channels)
+    assert got_a == a and got_b == b
+
+
+def test_bits_written_across_bytes(tmp_path):
+    import io
+    rnd = __import__("random").Random(2)
+    want, f, carry = [], io.BytesIO(), None
+    for n in (5, 12, 3, 16, 7):
+        bits = [rnd.randrange(2) for _ in range(n)]
+        want += bits
+        col = bytes(sum(bits[i + j] << j for j in range(min(8, n - i))) for i in range(0, n, 8))
+        carry = acquire._write_bits(f, carry, col, n)
+    acquire._flush_bits(f, carry)
+    out = np.unpackbits(np.frombuffer(f.getvalue(), np.uint8), bitorder="little")[: len(want)]
+    assert list(out) == want and len(f.getvalue()) == (len(want) + 7) // 8