foxglove-sdk 0.14.1__cp312-cp312-musllinux_1_2_i686.whl → 0.16.6__cp312-cp312-musllinux_1_2_i686.whl

foxglove/notebook/foxglove_widget.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import pathlib
+from typing import TYPE_CHECKING, Literal
+
+import anywidget
+import traitlets
+
+if TYPE_CHECKING:
+    from ..layouts import Layout
+    from .notebook_buffer import NotebookBuffer
+
+
+class FoxgloveWidget(anywidget.AnyWidget):
+    """
+    A widget that displays a Foxglove viewer in a notebook.
+    """
+
+    _esm = pathlib.Path(__file__).parent / "static" / "widget.js"
+    width = traitlets.Union(
+        [traitlets.Int(), traitlets.Enum(values=["full"])], default_value="full"
+    ).tag(sync=True)
+    height = traitlets.Int(default_value=500).tag(sync=True)
+    src = traitlets.Unicode(default_value=None, allow_none=True).tag(sync=True)
+    _layout = traitlets.Unicode(default_value=None, allow_none=True).tag(sync=True)
+
+    def __init__(
+        self,
+        *,
+        buffer: NotebookBuffer,
+        width: int | Literal["full"] | None = None,
+        height: int | None = None,
+        src: str | None = None,
+        layout: Layout | None = None,
+    ):
+        """
+        :param buffer: The NotebookBuffer object that contains the data to display in the widget.
+        :param width: The width of the widget. Defaults to "full".
+        :param height: The height of the widget in pixels. Defaults to 500.
+        :param src: The source URL of the Foxglove viewer. Defaults to
+            "https://embed.foxglove.dev/".
+        """
+        super().__init__()
+        if width is not None:
+            self.width = width
+        else:
+            self.width = "full"
+        if height is not None:
+            self.height = height
+        if src is not None:
+            self.src = src
+
+        if layout is not None:
+            self._layout = layout.to_json()
+
+        # Callback to get the data to display in the widget
+        self._buffer = buffer
+        # Keep track of when the widget is ready to receive data
+        self._ready = False
+        # Pending data to be sent when the widget is ready
+        self._pending_data: list[bytes] = []
+        self.on_msg(self._handle_custom_msg)
+        self.refresh()
+
+    def refresh(self) -> None:
+        """
+        Refresh the widget by getting the data from the callback function and sending it
+        to the widget.
+        """
+        data = self._buffer._get_data()
+        if not self._ready:
+            self._pending_data = data
+        else:
+            self.send({"type": "update-data"}, data)
+
+    def _handle_custom_msg(self, msg: dict, buffers: list[bytes]) -> None:
+        if msg["type"] == "ready":
+            self._ready = True
+
+            if len(self._pending_data) > 0:
+                self.send({"type": "update-data"}, self._pending_data)
+                self._pending_data = []

foxglove/notebook/notebook_buffer.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import os
+import uuid
+from tempfile import TemporaryDirectory
+from typing import Literal
+
+from mcap.reader import make_reader
+
+from .._foxglove_py import Context, open_mcap
+from ..layouts import Layout
+from .foxglove_widget import FoxgloveWidget
+
+
+class NotebookBuffer:
+    """
+    A data buffer to collect and manage messages and visualization in Jupyter notebooks.
+
+    The NotebookBuffer object will buffer all data logged to the provided context. When you
+    are ready to visualize the data, you can call the :meth:`show` method to display an embedded
+    Foxglove visualization widget. The widget provides a fully-featured Foxglove interface
+    directly within your Jupyter notebook, allowing you to explore multi-modal robotics data
+    including 3D scenes, plots, images, and more.
+    """
+
+    def __init__(self, *, context: Context | None = None):
+        """
+        Initialize a new NotebookBuffer for collecting logged messages.
+
+        :param context: The Context used to log the messages. If no Context is provided, the global
+            context will be used. Logged messages will be buffered.
+        """
+        # We need to keep the temporary directory alive until the writer is closed
+        self._temp_directory = TemporaryDirectory()
+        self._context = context
+        self._files: list[str] = []
+        self._create_writer()
+
+    def show(
+        self,
+        *,
+        width: int | Literal["full"] | None = None,
+        height: int | None = None,
+        src: str | None = None,
+        layout: Layout | None = None,
+    ) -> FoxgloveWidget:
+        """
+        Show the Foxglove viewer. Call this method as the last step of a notebook cell
+        to display the viewer.
+        """
+        widget = FoxgloveWidget(
+            buffer=self,
+            width=width,
+            height=height,
+            src=src,
+            layout=layout,
+        )
+        return widget
+
+    def clear(self) -> None:
+        """
+        Clear the buffered data.
+        """
+        self._writer.close()
+        # Delete the temporary directory and all its contents
+        self._temp_directory.cleanup()
+        # Reset files list
+        self._files = []
+        # Create a new temporary directory
+        self._temp_directory = TemporaryDirectory()
+        self._create_writer()
+
+    def _get_data(self) -> list[bytes]:
+        """
+        Retrieve all collected data.
+        """
+        # close the current writer
+        self._writer.close()
+
+        if len(self._files) > 1:
+            if is_mcap_empty(self._files[-1]):
+                # If the last file is empty, remove the last file since it won't add any new data
+                # to the buffer
+                os.remove(self._files[-1])
+                self._files.pop()
+            elif is_mcap_empty(self._files[0]):
+                # If the first file is empty, remove the first file since it won't add any new data
+                # to the buffer
+                os.remove(self._files[0])
+                self._files.pop(0)
+
+        # read the content of the files
+        contents: list[bytes] = []
+        for file_name in self._files:
+            with open(file_name, "rb") as f_read:
+                contents.append(f_read.read())
+
+        self._create_writer()
+
+        return contents
+
+    def _create_writer(self) -> None:
+        random_id = uuid.uuid4().hex[:8]
+        file_name = f"{self._temp_directory.name}/log-{random_id}.mcap"
+        self._files.append(file_name)
+        self._writer = open_mcap(path=file_name, context=self._context)
+
+
+def is_mcap_empty(file_name: str) -> bool:
+    with open(file_name, "rb") as f_read:
+        iter = make_reader(f_read).iter_messages()
+        is_empty = next(iter, None) is None
+
+    return is_empty

foxglove/notebook/static/widget.js

@@ -0,0 +1 @@
+var g=EventTarget,f="https://embed.foxglove.dev/",w="foxglove.default-layout";function y(){let t,e;return{promise:new Promise((a,i)=>{t=a,e=i}),resolve:t,reject:e}}var d=class extends g{#e;#a;#d;#r=!1;#n;#t={dataSource:void 0,selectLayout:void 0,extension:[]};#s;#i=!1;constructor(e){super();let{parent:s,src:a,orgSlug:i,initialDataSource:o,initialLayout:r,initialLayoutParams:n,initialExtensions:l,colorScheme:h="auto",embeddedViewer:u}=e;this.#d=i,this.#n=y();let c=a??f;try{this.#a=new URL(c)}catch{throw new Error(`[FoxgloveViewer] Invalid server URL: ${c}`)}u!=null&&this.#a.searchParams.set("embeddedViewer",u),window.addEventListener("message",this.#h),o&&this.setDataSource(o),r!=null&&n==null&&this.setLayoutData(r),n!=null&&this.selectLayout(n),l&&this.installExtensions(l),this.#e=document.createElement("iframe"),this.#e.src=this.#a.href,this.#e.title="Foxglove",this.#e.allow="cross-origin-isolated",this.#e.style.width="100%",this.#e.style.height="100%",this.#e.style.border="none",this.setColorScheme(h),s.appendChild(this.#e)}setDataSource(e){this.#l({type:"set-data-source",payload:e})}selectLayout(e){this.#l({type:"select-layout",payload:e})}async getLayout(){return this.#s||(this.#s=y(),await this.#n.promise,this.#o({type:"get-layout"})),await this.#s.promise}setLayoutData(e){this.selectLayout({storageKey:w,opaqueLayout:e,force:!0})}installExtensions(e){this.#l({type:"install-extension",payload:e})}isReady(){return this.#r}destroy(){this.#i=!0,this.#e.remove(),window.removeEventListener("message",this.#h)}isDestroyed(){return this.#i}setColorScheme(e){this.#e.style.colorScheme=e==="auto"?"normal":e}#l(e){switch(e.type){case"install-extension":this.#t.extension.push(e);break;case"set-data-source":this.#t.dataSource=e;break;case"select-layout":this.#t.selectLayout=e;break}this.#r&&this.#o(e)}#o(e){if(this.#i){console.warn("[FoxgloveViewer] Unable to post command. Frame has been destroyed.");return}v(this.#e.contentWindow,"Invariant: iframe should be loaded."),this.#e.contentWindow.postMessage(e,this.#a.origin)}#h=e=>{let s=new URL(e.origin);if(!(e.source!==this.#e.contentWindow||s.origin!==this.#a.origin)){if(this.#i){console.warn("[FoxgloveViewer] Unable to handle message. Frame has been destroyed.");return}switch(e.data.type){case"foxglove-origin-request":this.#o({type:"origin-ack"});break;case"foxglove-handshake-request":this.#r=!0,this.#n.resolve(),this.#o({type:"handshake-ack",payload:{orgSlug:this.#d,initialDataSource:this.#t.dataSource?.payload,initialLayoutParams:this.#t.selectLayout?.payload,initialExtensions:this.#t.extension.flatMap(a=>a.payload)}});break;case"foxglove-handshake-complete":this.dispatchEvent(new Event("ready"));break;case"foxglove-error":this.dispatchEvent(new CustomEvent("error",{detail:e.data.payload}));break;case"foxglove-layout-data":this.#s?(this.#s.resolve(e.data.payload),this.#s=void 0):console.warn("[FoxgloveViewer] Received layout but getLayout was not called.");break;default:console.warn("[FoxgloveViewer] Unhandled message type:",e.data);break}}}};function v(t,e="no additional info provided"){if(!t)throw new Error("Assertion Error: "+e)}var m="foxglove-notebook-default-layout";function p(t){return{storageKey:m,force:!0,layout:t?JSON.parse(t):void 0}}function x({model:t,el:e}){let s=document.createElement("div"),a=t.get("_layout"),i=new d({parent:s,embeddedViewer:"Python",src:t.get("src"),orgSlug:void 0,initialLayoutParams:p(a)});i.addEventListener("ready",()=>{t.send({type:"ready"})}),t.on("msg:custom",(o,r)=>{if(o.type==="update-data"){let n=r.map((l,h)=>new File([l.buffer],`data-${h}.mcap`));i.setDataSource({type:"file",file:n})}}),s.style.width=t.get("width")==="full"?"100%":`${t.get("width")}px`,s.style.height=`${t.get("height")}px`,t.on("change:width",()=>{s.style.width=t.get("width")==="full"?"100%":`${t.get("width")}px`}),t.on("change:height",()=>{s.style.height=`${t.get("height")}px`}),t.on("change:_layout",()=>{let o=t.get("_layout"),r=p(o);i.selectLayout(r)}),e.appendChild(s)}var R={render:x};export{R as default};

foxglove/schemas/__init__.py

@@ -40,6 +40,7 @@ from foxglove._foxglove_py.schemas import (
     PackedElementFieldNumericType,
     Point2,
     Point3,
+    Point3InFrame,
     PointCloud,
     PointsAnnotation,
     PointsAnnotationType,
@@ -88,6 +89,7 @@ FoxgloveSchema = Union[
     PackedElementField,
     Point2,
     Point3,
+    Point3InFrame,
     PointCloud,
     PointsAnnotation,
     Pose,
@@ -139,6 +141,7 @@ __all__ = [
     "PackedElementFieldNumericType",
     "Point2",
     "Point3",
+    "Point3InFrame",
     "PointCloud",
     "PointsAnnotation",
     "PointsAnnotationType",

foxglove/tests/test_context.py

@@ -0,0 +1,10 @@
+from foxglove import Context
+
+
+def test_default_context_is_singleton() -> None:
+    assert Context.default() is Context.default()
+
+
+def test_context_is_distinct() -> None:
+    assert Context() is not Context.default()
+    assert Context() is not Context()

foxglove/tests/test_logging.py

@@ -1,4 +1,7 @@
 import logging
+import os
+import subprocess
+import sys
 
 import pytest
 from foxglove import set_log_level
@@ -14,3 +17,46 @@ def test_set_log_level_accepts_string_or_int() -> None:
 def test_set_log_level_clamps_illegal_values() -> None:
     set_log_level(-1)
     set_log_level(2**64)
+
+
+def test_logging_config_with_env() -> None:
+    # Run a script in a child process so logger can be re-initialized from env.
+    test_script = """
+import logging
+import foxglove
+
+logging.basicConfig(level=logging.DEBUG)
+
+server = foxglove.start_server(port=0)
+server.stop()
+
+print("test_init_with_env_complete")
+"""
+
+    # Default: unset
+    env = os.environ.copy()
+    env["FOXGLOVE_LOG_LEVEL"] = ""
+
+    result = subprocess.run(
+        [sys.executable, "-c", test_script],
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=5,
+    )
+    assert "test_init_with_env_complete" in result.stdout
+    assert "Started server" in result.stderr
+
+    # Quiet the WS server logging
+    env = os.environ.copy()
+    env["FOXGLOVE_LOG_LEVEL"] = "debug,foxglove::websocket::server=warn"
+
+    result = subprocess.run(
+        [sys.executable, "-c", test_script],
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=5,
+    )
+    assert "test_init_with_env_complete" in result.stdout
+    assert "Started server" not in result.stderr

foxglove/tests/test_mcap.py

@@ -1,8 +1,9 @@
+from io import SEEK_CUR, SEEK_SET, BytesIO
 from pathlib import Path
-from typing import Callable, Generator, Optional
+from typing import Callable, Generator, Optional, Union
 
 import pytest
-from foxglove import Channel, Context, open_mcap
+from foxglove import Channel, ChannelDescriptor, Context, open_mcap
 from foxglove.mcap import MCAPWriteOptions
 
 chan = Channel("test", schema={"type": "object"})
@@ -114,3 +115,363 @@ def test_write_to_different_contexts(make_tmp_mcap: Callable[[], Path]) -> None:
     contents2 = tmp_2.read_bytes()
 
     assert len(contents1) < len(contents2)
+
+
+def _verify_metadata_in_file(file_path: Path, expected_metadata: dict) -> None:
+    """Helper function to verify metadata in MCAP file matches expected."""
+    import mcap.reader
+
+    with open(file_path, "rb") as f:
+        reader = mcap.reader.make_reader(f)
+
+        found_metadata = {}
+        metadata_count = 0
+
+        for record in reader.iter_metadata():
+            metadata_count += 1
+            found_metadata[record.name] = dict(record.metadata)
+
+        # Verify count
+        assert metadata_count == len(
+            expected_metadata
+        ), f"Expected {len(expected_metadata)} metadata records, found {metadata_count}"
+
+        # Verify metadata names and content
+        assert set(found_metadata.keys()) == set(
+            expected_metadata.keys()
+        ), "Metadata names don't match"
+
+        for name, expected_kv in expected_metadata.items():
+            assert (
+                found_metadata[name] == expected_kv
+            ), f"Metadata '{name}' has wrong key-value pairs"
+
+
+def _verify_attachments_in_file(
+    file_path: Path, expected_attachments: list[dict]
+) -> None:
+    """Helper function to verify attachments in MCAP file match expected."""
+    import mcap.reader
+
+    with open(file_path, "rb") as f:
+        reader = mcap.reader.make_reader(f)
+
+        found_attachments = []
+        for attachment in reader.iter_attachments():
+            found_attachments.append(
+                {
+                    "log_time": attachment.log_time,
+                    "create_time": attachment.create_time,
+                    "name": attachment.name,
+                    "media_type": attachment.media_type,
+                    "data": attachment.data,
+                }
+            )
+
+        # Verify count
+        assert len(found_attachments) == len(
+            expected_attachments
+        ), f"Expected {len(expected_attachments)} attachments, found {len(found_attachments)}"
+
+        # Verify each attachment matches expected
+        for expected in expected_attachments:
+            matching = [a for a in found_attachments if a["name"] == expected["name"]]
+            assert len(matching) == 1, f"Attachment '{expected['name']}' not found"
+            actual = matching[0]
+            assert (
+                actual["log_time"] == expected["log_time"]
+            ), f"Attachment '{expected['name']}' has wrong log_time"
+            assert (
+                actual["create_time"] == expected["create_time"]
+            ), f"Attachment '{expected['name']}' has wrong create_time"
+            assert (
+                actual["media_type"] == expected["media_type"]
+            ), f"Attachment '{expected['name']}' has wrong media_type"
+            assert (
+                actual["data"] == expected["data"]
+            ), f"Attachment '{expected['name']}' has wrong data"
+
+
+def test_write_metadata(tmp_mcap: Path) -> None:
+    """Test writing metadata to MCAP file."""
+    # Define expected metadata
+    expected_metadata = {
+        "test1": {"key1": "value1", "key2": "value2"},
+        "test2": {"a": "1", "b": "2"},
+        "test3": {"x": "y", "z": "w"},
+    }
+
+    with open_mcap(tmp_mcap) as writer:
+        # This should not raise an error
+        writer.write_metadata("empty", {})
+
+        # Write basic metadata
+        writer.write_metadata("test1", expected_metadata["test1"])
+
+        # Write multiple metadata records
+        writer.write_metadata("test2", expected_metadata["test2"])
+        writer.write_metadata("test3", expected_metadata["test3"])
+
+        # Write empty metadata (should be skipped)
+        writer.write_metadata("empty_test", {})
+
+        # Log some messages
+        for ii in range(5):
+            chan.log({"foo": ii})
+
+    # Verify metadata was written correctly
+    _verify_metadata_in_file(tmp_mcap, expected_metadata)
+
+
+def test_channel_filter(make_tmp_mcap: Callable[[], Path]) -> None:
+    tmp_1 = make_tmp_mcap()
+    tmp_2 = make_tmp_mcap()
+
+    ch1 = Channel("/1", schema={"type": "object"})
+    ch2 = Channel("/2", schema={"type": "object"})
+
+    def filter(ch: ChannelDescriptor) -> bool:
+        return ch.topic.startswith("/1")
+
+    mcap1 = open_mcap(tmp_1, channel_filter=filter)
+    mcap2 = open_mcap(tmp_2, channel_filter=None)
+
+    ch1.log({})
+    ch2.log({})
+
+    mcap1.close()
+    mcap2.close()
+
+    assert tmp_1.stat().st_size < tmp_2.stat().st_size
+
+
+def test_attach_basic(tmp_mcap: Path) -> None:
+    """Test writing a single attachment to MCAP file."""
+    expected_attachments = [
+        {
+            "log_time": 1000000000,
+            "create_time": 2000000000,
+            "name": "config.json",
+            "media_type": "application/json",
+            "data": b'{"setting": true}',
+        }
+    ]
+
+    with open_mcap(tmp_mcap) as writer:
+        writer.attach(
+            log_time=1000000000,
+            create_time=2000000000,
+            name="config.json",
+            media_type="application/json",
+            data=b'{"setting": true}',
+        )
+
+    _verify_attachments_in_file(tmp_mcap, expected_attachments)
+
+
+def test_attach_multiple(tmp_mcap: Path) -> None:
+    """Test writing multiple attachments to MCAP file."""
+    expected_attachments = [
+        {
+            "log_time": 100,
+            "create_time": 200,
+            "name": "config.json",
+            "media_type": "application/json",
+            "data": b'{"setting": true}',
+        },
+        {
+            "log_time": 300,
+            "create_time": 400,
+            "name": "calibration.yaml",
+            "media_type": "text/yaml",
+            "data": b"camera:\n  fx: 500\n  fy: 500",
+        },
+        {
+            "log_time": 500,
+            "create_time": 600,
+            "name": "image.png",
+            "media_type": "image/png",
+            "data": bytes([0x89, 0x50, 0x4E, 0x47]),  # PNG magic bytes
+        },
+    ]
+
+    with open_mcap(tmp_mcap) as writer:
+        writer.attach(
+            log_time=100,
+            create_time=200,
+            name="config.json",
+            media_type="application/json",
+            data=b'{"setting": true}',
+        )
+        writer.attach(
+            log_time=300,
+            create_time=400,
+            name="calibration.yaml",
+            media_type="text/yaml",
+            data=b"camera:\n  fx: 500\n  fy: 500",
+        )
+        writer.attach(
+            log_time=500,
+            create_time=600,
+            name="image.png",
+            media_type="image/png",
+            data=bytes([0x89, 0x50, 0x4E, 0x47]),  # PNG magic bytes
+        )
+
+    _verify_attachments_in_file(tmp_mcap, expected_attachments)
+
+
+def test_attach_with_messages(tmp_mcap: Path) -> None:
+    """Test writing attachments alongside messages."""
+    with open_mcap(tmp_mcap) as writer:
+        # Write some messages
+        for ii in range(5):
+            chan.log({"foo": ii})
+
+        # Write an attachment
+        writer.attach(
+            log_time=1000,
+            create_time=2000,
+            name="notes.txt",
+            media_type="text/plain",
+            data=b"Recording notes",
+        )
+
+        # Write more messages
+        for ii in range(5, 10):
+            chan.log({"foo": ii})
+
+    # Verify attachment was written
+    expected_attachments = [
+        {
+            "log_time": 1000,
+            "create_time": 2000,
+            "name": "notes.txt",
+            "media_type": "text/plain",
+            "data": b"Recording notes",
+        }
+    ]
+    _verify_attachments_in_file(tmp_mcap, expected_attachments)
+
+
+def test_attach_after_close(tmp_mcap: Path) -> None:
+    """Test that attaching after close raises an error."""
+    writer = open_mcap(tmp_mcap)
+    writer.close()
+
+    with pytest.raises(Exception):  # FoxgloveError for SinkClosed
+        writer.attach(
+            log_time=100,
+            create_time=200,
+            name="test.txt",
+            media_type="text/plain",
+            data=b"test",
+        )
+
+
+# =============================================================================
+# Tests for file-like object support
+# =============================================================================
+
+
+class TestFileLikeObject:
+    """Tests for writing MCAP to file-like objects."""
+
+    def test_write_to_bytesio(self) -> None:
+        """Test writing MCAP to a BytesIO buffer produces valid MCAP."""
+        buffer = BytesIO()
+        test_chan = Channel("test_bytesio", schema={"type": "object"})
+
+        with open_mcap(buffer):
+            for i in range(10):
+                test_chan.log({"value": i})
+
+        # Verify buffer has data with MCAP magic bytes
+        data = buffer.getvalue()
+        assert len(data) > 0
+        assert data[:8] == b"\x89MCAP0\r\n"
+
+    def test_bytesio_readable_by_mcap_reader(self) -> None:
+        """Test that MCAP written to BytesIO can be read back."""
+        import mcap.reader
+
+        buffer = BytesIO()
+        test_chan = Channel("test_readable", schema={"type": "object"})
+
+        with open_mcap(buffer):
+            for i in range(5):
+                test_chan.log({"index": i})
+
+        # Read back and verify
+        buffer.seek(0)
+        reader = mcap.reader.make_reader(buffer)
+        summary = reader.get_summary()
+
+        assert summary is not None
+        assert summary.statistics is not None
+        assert summary.statistics.message_count == 5
+
+
+# =============================================================================
+# Tests for disable_seeking option
+# =============================================================================
+
+
+class NonSeekableWriter:
+    """A file-like object that supports write/flush but raises on actual seeks.
+
+    This mimics a non-seekable stream like a pipe or network socket. It allows
+    position queries (seek(0, SEEK_CUR) or tell()) and no-op seeks to the current
+    position, but raises OSError on any seek that would change the position.
+    """
+
+    def __init__(self) -> None:
+        self._buffer = BytesIO()
+        self._position = 0
+
+    def write(self, data: Union[bytes, bytearray]) -> int:
+        written = self._buffer.write(data)
+        self._position += written
+        return written
+
+    def flush(self) -> None:
+        self._buffer.flush()
+
+    def seek(self, offset: int, whence: int = SEEK_SET) -> int:
+        if whence == SEEK_CUR and offset == 0:
+            # Allow querying current position (tell())
+            return self._position
+        elif whence == SEEK_SET and offset == self._position:
+            # Allow no-op seek to current position
+            return self._position
+        else:
+            # Actual seeks that change position are not supported
+            raise OSError("Seeking is not supported")
+
+    def getvalue(self) -> bytes:
+        return self._buffer.getvalue()
+
+
+class TestDisableSeeking:
+    """Tests for the disable_seeking option in MCAPWriteOptions."""
+
+    def test_disable_seeking_prevents_seek_calls(self) -> None:
+        """Test that disable_seeking=True allows writing without seek calls."""
+        writer = NonSeekableWriter()
+        options = MCAPWriteOptions(disable_seeking=True)
+        test_chan = Channel("test_no_seek", schema={"type": "object"})
+
+        with open_mcap(writer, writer_options=options):
+            test_chan.log({"value": 1})
+
+        # Verify MCAP magic bytes are present
+        assert writer.getvalue()[:8] == b"\x89MCAP0\r\n"
+
+    def test_seeking_fails_without_disable_seeking(self) -> None:
+        """Test that seeking is attempted by default and fails on non-seekable writer."""
+        writer = NonSeekableWriter()
+        test_chan = Channel("test_seek_default", schema={"type": "object"})
+
+        with pytest.raises(RuntimeError):
+            with open_mcap(writer):
+                test_chan.log({"value": 1})