diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index 8000727b..b5f936a3 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -121,7 +121,9 @@ On-disk identifiers (metadata record names, channel naming) are neutral and form The `hebbian-mcap` dependency owns generic grouping and MCAP serialization. HFlow owns group selection, derived targets, episode schemas, transformations and provenance. -The shared package also owns H.264 inspection and optional camera-to-MP4 export; +The shared package also owns `CompressedVideo` encoding, reading and payload +replacement for protobuf and ROS 2 CDR channels, H.264 inspection and optional +camera-to-MP4 export; `hflow.mcap_video` adapts HFlow media limits to that exporter. Codec dependencies remain behind the `video` extra. We maintain both repositories; coordinated changes to `mcap-tools` are welcome. diff --git a/docs/FORMAT.md b/docs/FORMAT.md index 3f365984..c9adf7f1 100644 --- a/docs/FORMAT.md +++ b/docs/FORMAT.md @@ -19,7 +19,7 @@ The single overriding rule: **a canonical episode is spec-conforming MCAP.** Eve - MCAP magic, `Header`, data section, `DataEnd`, summary section, `Footer`, closing magic, per the [MCAP spec](https://mcap.dev/spec). - `Header.profile` is the empty string `""` (the file mixes protobuf video channels with pass-through channels of arbitrary encoding, so no single profile applies). -- `Header.library` is informational only (currently `hebbian-mcap/0.1.0`). Its exact value is not part of the format contract, and no reader may key behavior off it (see [Identifier rules](#identifier-rules)). +- `Header.library` is informational only (currently `hebbian-mcap/0.1.1`). Its exact value is not part of the format contract, and no reader may key behavior off it (see [Identifier rules](#identifier-rules)). - Chunks are compressed with **zstd** by default (`"none"` is permitted). Each `Chunk` record carries `uncompressed_crc`; the `Footer` carries a summary CRC. - The summary section repeats all `Schema` and `Channel` records and contains `Statistics`, all `ChunkIndex` records, `AttachmentIndex`/`MetadataIndex` records, and `SummaryOffset` records. A canonical episode always has a complete summary; unindexed files are not canonical. - Each topic names exactly one channel. MCAP allows several channels to share a topic; a canonical episode does not, because topic-keyed reads would be ambiguous. diff --git a/pyproject.toml b/pyproject.toml index 74922975..848f6efd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -22,12 +22,11 @@ keywords = [ requires-python = ">=3.11" dependencies = [ "duckdb>=2.0.0", - "foxglove-schemas-protobuf>=0.4.0", "httpx>=0.28.1,<1", "httpx2>=2.12.0", "huggingface-hub>=1.31.0,<2", "mcap>=1.4.0", - "hebbian-mcap==0.1.0", + "hebbian-mcap==0.1.1", "mcap-protobuf-support>=0.5.4", "mcap-ros2-support>=0.5.7", "numpy>=2.3.5", @@ -57,7 +56,7 @@ mediapipe = ["mediapipe>=1.0.1"] # dependency is real, and confined to the one check that needs it. Headless # because a data pipeline runs where there is no display. motion = ["opencv-python-headless>=5.0.0.93"] -video = ["av>=18.1.0", "hebbian-mcap[video]==0.1.0"] +video = ["av>=18.1.0", "hebbian-mcap[video]==0.1.1"] native-build = ["Cython>=3.3.0", "setuptools>=84.0.0"] openai = ["openai>=3.3.1"] @@ -72,6 +71,7 @@ hflow = "hflow.cli:main" [dependency-groups] dev = [ "av>=18.1.0", # the video extra, exercised by timestamp-preserving camera export tests + "foxglove-schemas-protobuf>=0.4.0", # tests build foxglove messages to feed readers "Cython>=3.3.0", # the native-build extra, present so its real build path is tested "hflow-server", # the workspace API package, present in dev so the suite tests it "obstore>=0.11.1", # the bucket extra, present in dev so the suite tests it diff --git a/src/hflow/behavior.py b/src/hflow/behavior.py index 0807d042..dc0dc874 100644 --- a/src/hflow/behavior.py +++ b/src/hflow/behavior.py @@ -108,4 +108,10 @@ # hebbian-mcap. Message semantics and group isolation are preserved, but the # library identifier, schema/channel placement, and compressed bytes can change. # Regenerate derived outputs rather than mixing both writers under one identity. -TRANSFORM_BEHAVIOR_VERSION: str = "12" +# +# "13": video messages are encoded and rewritten by hebbian-mcap 0.1.1. The +# CompressedVideo schema record now carries protobuf ``json_name`` entries, the +# library identifier names the new release, and a pass-through protobuf message +# that gains an access unit delimiter keeps its original field order. Decoded +# message content is unchanged. +TRANSFORM_BEHAVIOR_VERSION: str = "13" diff --git a/src/hflow/doctor.py b/src/hflow/doctor.py index dbebc328..13bf3a4c 100644 --- a/src/hflow/doctor.py +++ b/src/hflow/doctor.py @@ -17,12 +17,13 @@ """ import math -from collections.abc import Callable, Iterator +from collections.abc import Iterator from dataclasses import dataclass, field from enum import StrEnum from pathlib import Path from typing import Any +from hebbian_mcap import CompressedVideoCodec from mcap.reader import make_reader from mcap.records import Channel, Schema @@ -190,7 +191,7 @@ def _check_video_payload( class VideoEncodingUnsupported(ValueError): - """No decoder factory in the supported set handles this message encoding. + """The channel's message encoding or schema is outside the supported set. A subclass of ``ValueError`` because every existing caller treats resolution failure as a ``ValueError``; the distinct type lets the video @@ -200,19 +201,17 @@ class VideoEncodingUnsupported(ValueError): """ -def _resolve_video_decoder(topic: str, channel: Channel, schema: Schema) -> Callable[[bytes], Any]: +def _resolve_video_codec(topic: str, channel: Channel, schema: Schema) -> CompressedVideoCodec: """Resolve either supported encoded-video payload representation.""" - from mcap_protobuf.decoder import DecoderFactory as ProtobufDecoderFactory - from mcap_ros2.decoder import DecoderFactory as Ros2DecoderFactory - - for factory in (Ros2DecoderFactory(), ProtobufDecoderFactory()): - decoder = factory.decoder_for(channel.message_encoding, schema) - if decoder is not None: - return decoder - raise VideoEncodingUnsupported( - f"video topic {topic!r} has message encoding {channel.message_encoding!r} " - "that no available decoder handles" - ) + try: + return CompressedVideoCodec( + channel.message_encoding, schema.encoding, schema.name, schema.data + ) + except ValueError as error: + raise VideoEncodingUnsupported( + f"video topic {topic!r} has message encoding {channel.message_encoding!r} " + f"that no available decoder handles ({error})" + ) from error def _unreadable_message(stream: Any, error: Exception) -> str: @@ -503,7 +502,7 @@ def iter_all_messages() -> Iterator[tuple[int, int, bytes]]: video_log_times: dict[int, list[int]] = {} video_keyframes: dict[int, list[bool | None]] = {} try: - video_decoders: dict[int, Callable[[bytes], Any]] = {} + video_codecs: dict[int, CompressedVideoCodec] = {} for channel_id, log_time, payload in iter_all_messages(): previous = last_log_time_by_channel.get(channel_id) @@ -523,12 +522,12 @@ def iter_all_messages() -> Iterator[tuple[int, int, bytes]]: continue message_index = video_message_counts.get(channel_id, 0) video_message_counts[channel_id] = message_index + 1 - decoder = video_decoders.get(channel_id) - if decoder is None: + codec = video_codecs.get(channel_id) + if codec is None: channel = summary.channels[channel_id] schema = summary.schemas[channel.schema_id] try: - decoder = _resolve_video_decoder(channel.topic, channel, schema) + codec = _resolve_video_codec(channel.topic, channel, schema) except VideoEncodingUnsupported as error: video_check_skipped_topics.add(topics_by_channel_id[channel_id]) collector.add( @@ -538,14 +537,14 @@ def iter_all_messages() -> Iterator[tuple[int, int, bytes]]: "cannot run on this topic (the file bytes are not implicated)", ) continue - video_decoders[channel_id] = decoder - decoded = decoder(payload) + video_codecs[channel_id] = codec + decoded = codec.decode(payload) is_keyframe = _check_video_payload( collector, topics_by_channel_id[channel_id], message_index, decoded.format, - bytes(decoded.data), + decoded.data, is_first_message=message_index == 0, ) video_log_times.setdefault(channel_id, []).append(log_time) diff --git a/src/hflow/importers/lerobot.py b/src/hflow/importers/lerobot.py index cb0b1e1b..0825a421 100644 --- a/src/hflow/importers/lerobot.py +++ b/src/hflow/importers/lerobot.py @@ -1276,10 +1276,8 @@ def _feature_rows(feature_name: str) -> list | None: landing_relative_key = _landing_relative_key(episode_index) output_file_name = Path(landing_relative_key).name - from foxglove_schemas_protobuf.CompressedVideo_pb2 import CompressedVideo - from mcap_protobuf.schema import build_file_descriptor_set + from hebbian_mcap import COMPRESSED_VIDEO_SCHEMA, encode_compressed_video - video_schema_data = build_file_descriptor_set(CompressedVideo).SerializeToString() state_schema_name = "lerobot_msgs/msg/State" action_schema_name = "lerobot_msgs/msg/Action" state_schema_text = f"float32[{numeric_schemas['observation.state'].dim}] position" @@ -1296,7 +1294,7 @@ def _feature_rows(feature_name: str) -> list | None: mcap_writer.start(profile="", library="hflow LeRobot source adapter") video_schema_id = mcap_writer.register_schema( - "foxglove.CompressedVideo", "protobuf", video_schema_data + "foxglove.CompressedVideo", "protobuf", COMPRESSED_VIDEO_SCHEMA ) state_schema_id = mcap_writer.register_schema( state_schema_name, "ros2msg", state_schema_data @@ -1328,16 +1326,12 @@ def _feature_rows(feature_name: str) -> list | None: ) for camera_key in camera_keys: access_units, _presentation_timestamps = video_data_by_camera[camera_key] - video_message = CompressedVideo() - video_message.timestamp.seconds = log_time_ns // NANOSECONDS_PER_SECOND - video_message.timestamp.nanos = log_time_ns % NANOSECONDS_PER_SECOND - video_message.frame_id = camera_key - video_message.data = access_units[frame_index] - video_message.format = "h264" mcap_writer.add_message( channel_id=video_channel_ids[camera_key], log_time=log_time_ns, - data=video_message.SerializeToString(), + data=encode_compressed_video( + log_time_ns, camera_key, access_units[frame_index], "h264" + ), publish_time=log_time_ns, sequence=frame_index, ) diff --git a/src/hflow/importers/video.py b/src/hflow/importers/video.py index 1cc19120..593c10e1 100644 --- a/src/hflow/importers/video.py +++ b/src/hflow/importers/video.py @@ -8,9 +8,8 @@ from fractions import Fraction from pathlib import Path -from foxglove_schemas_protobuf.CompressedVideo_pb2 import CompressedVideo +from hebbian_mcap import COMPRESSED_VIDEO_SCHEMA, encode_compressed_video from mcap.writer import Writer -from mcap_protobuf.schema import build_file_descriptor_set from hflow._field_guards import ( require_finite_float, @@ -374,7 +373,7 @@ def _import_inspected_video( schema_id = writer.register_schema( name=CANONICAL_VIDEO_SCHEMA_NAME, encoding="protobuf", - data=build_file_descriptor_set(CompressedVideo).SerializeToString(), + data=COMPRESSED_VIDEO_SCHEMA, ) channel_id = writer.register_channel( topic=f"/{config.camera_name}/compressed", @@ -408,19 +407,14 @@ def _import_inspected_video( ) for frame_index, access_unit in enumerate(access_units): timestamp_ns = _sample_timestamp_ns(config, frame_index) - message = CompressedVideo() - message.timestamp.seconds, message.timestamp.nanos = divmod( - timestamp_ns, NANOSECONDS_PER_SECOND - ) - message.frame_id = config.camera_name - message.format = "h264" - message.data = access_unit.data writer.add_message( channel_id=channel_id, log_time=timestamp_ns, publish_time=timestamp_ns, sequence=frame_index, - data=message.SerializeToString(), + data=encode_compressed_video( + timestamp_ns, config.camera_name, access_unit.data, "h264" + ), ) writer.finish() # A hard link is an atomic create-if-absent on the same filesystem; diff --git a/src/hflow/transform.py b/src/hflow/transform.py index f2a78897..85e37053 100644 --- a/src/hflow/transform.py +++ b/src/hflow/transform.py @@ -56,7 +56,6 @@ import hashlib import json from collections.abc import Callable, Mapping, Sequence -from copy import copy from dataclasses import dataclass, field from itertools import pairwise from pathlib import Path @@ -64,10 +63,14 @@ from typing import Any, Literal from hebbian_mcap import ( + COMPRESSED_VIDEO_SCHEMA, NO_SCHEMA_ID, ChannelId, + CompressedVideo, + CompressedVideoCodec, GroupedMcapWriter, SchemaId, + encode_compressed_video, ) from hflow import video as video_module @@ -389,49 +392,17 @@ def _resolve_decoder(topic: str, info: TopicInfo) -> Callable[[bytes], Any]: ) -@dataclass(frozen=True) -class _Ros2VideoMessageWithData: - """Override only the payload while forwarding every other field to its owner.""" - - _original: object - data: bytes - - def __getattr__(self, name: str) -> Any: - return getattr(self._original, name) - - -def _resolve_encoder(topic: str, info: TopicInfo) -> Callable[[Any, bytes], bytes]: - """An encoder matching a decoded pass-through video message.""" - if info.message_encoding == "protobuf": - - def encode_protobuf(message: Any, data: bytes) -> bytes: - repaired_message = copy(message) - repaired_message.data = data - serialize = getattr(repaired_message, "SerializeToString", None) - if not callable(serialize): - raise ValueError( - f"camera topic {topic!r} decoded a protobuf message that cannot " - "be serialized after inserting an AUD" - ) - return bytes(serialize()) - - return encode_protobuf - if info.message_encoding == "cdr" and info.schema_encoding == "ros2msg": - from mcap_ros2.writer import serialize_dynamic - - encoders = serialize_dynamic(info.schema_name, info.schema_data.decode()) - encoder = encoders.get(info.schema_name) - if encoder is not None: - - def encode_cdr(message: Any, data: bytes) -> bytes: - # mcap_ros2's slotted SimpleNamespace fields are lost by copy.copy. - return encoder(_Ros2VideoMessageWithData(_original=message, data=data)) - - return encode_cdr - raise ValueError( - f"camera topic {topic!r} has message encoding {info.message_encoding!r} " - "that cannot be serialized after inserting an AUD" - ) +def _resolve_passthrough_video_codec(topic: str, info: TopicInfo) -> CompressedVideoCodec: + """The codec for one pass-through video channel, or a loud error naming the topic.""" + try: + return CompressedVideoCodec( + info.message_encoding, info.schema_encoding, info.schema_name, info.schema_data + ) + except ValueError as error: + raise ValueError( + f"camera topic {topic!r} has message encoding {info.message_encoding!r} " + f"that no available decoder handles ({error})" + ) from error @dataclass(frozen=True) @@ -442,14 +413,16 @@ class _PassthroughVideoMessage: data: bytes -def _parse_passthrough_video_message(topic: str, decoded_message: Any) -> _PassthroughVideoMessage: +def _parse_passthrough_video_message( + topic: str, decoded_message: CompressedVideo +) -> _PassthroughVideoMessage: if decoded_message.format != "h264": raise SourceNotConforming( f"pass-through video topic {topic!r} carries format " f"{decoded_message.format!r}; the canonical convention requires 'h264' " "(re-encode upstream -- v1 does not transcode CompressedVideo)" ) - return _PassthroughVideoMessage(format="h264", data=bytes(decoded_message.data)) + return _PassthroughVideoMessage(format="h264", data=decoded_message.data) def _insert_missing_passthrough_video_aud( @@ -686,8 +659,7 @@ def group_for(info: TopicInfo) -> str: for channel_id, info in infos.items() if info.schema_name in PASSTHROUGH_VIDEO_SCHEMA_NAMES } - passthrough_video_decoders: dict[int, Callable[[bytes], Any]] = {} - passthrough_video_encoders: dict[int, Callable[[Any, bytes], bytes]] = {} + passthrough_video_codecs: dict[int, CompressedVideoCodec] = {} passthrough_video_channels_with_messages: set[int] = set() # Log time of every keyframe on each pass-through channel, so the # cadence stamped into provenance is measured off the bytes being @@ -700,19 +672,18 @@ def group_for(info: TopicInfo) -> str: camera_payloads[batch.channel_id].extend(batch.data) else: if batch.channel_id in passthrough_video_channel_ids: - if batch.channel_id not in passthrough_video_decoders: - passthrough_video_decoders[batch.channel_id] = _resolve_decoder( - batch.topic, infos[batch.channel_id] + if batch.channel_id not in passthrough_video_codecs: + passthrough_video_codecs[batch.channel_id] = ( + _resolve_passthrough_video_codec(batch.topic, infos[batch.channel_id]) ) - decode = passthrough_video_decoders[batch.channel_id] + codec = passthrough_video_codecs[batch.channel_id] canonical_payloads: list[bytes] = [] for message_index, payload in enumerate(batch.data): is_first_message = ( batch.channel_id not in passthrough_video_channels_with_messages ) - decoded_message = decode(payload) video_message = _parse_passthrough_video_message( - batch.topic, decoded_message + batch.topic, codec.decode(payload) ) repaired_video_message = _insert_missing_passthrough_video_aud( batch.topic, video_message @@ -727,13 +698,7 @@ def group_for(info: TopicInfo) -> str: int(batch.log_times[message_index]) ) if repaired_video_message.data != video_message.data: - if batch.channel_id not in passthrough_video_encoders: - passthrough_video_encoders[batch.channel_id] = _resolve_encoder( - batch.topic, infos[batch.channel_id] - ) - payload = passthrough_video_encoders[batch.channel_id]( - decoded_message, repaired_video_message.data - ) + payload = codec.replace_data(payload, repaired_video_message.data) canonical_payloads.append(payload) passthrough_video_channels_with_messages.add(batch.channel_id) else: @@ -748,8 +713,6 @@ def group_for(info: TopicInfo) -> str: for index, payload in enumerate(canonical_payloads) ) - from foxglove_schemas_protobuf.CompressedVideo_pb2 import CompressedVideo - for channel_id in transcode_channel_ids: payloads = camera_payloads[channel_id] topic = infos[channel_id].topic @@ -775,17 +738,17 @@ def group_for(info: TopicInfo) -> str: input_codec=input_codec, ) for index, access_unit in enumerate(access_units): - message = CompressedVideo() - message.timestamp.FromNanoseconds(log_times[index]) - message.frame_id = frame_ids[index] or topic.strip("/") - message.data = access_unit.data - message.format = "h264" outgoing.append( _OutgoingMessage( log_time=log_times[index], publish_time=camera_publish_times[channel_id][index], source_channel_id=channel_id, - data=message.SerializeToString(), + data=encode_compressed_video( + log_times[index], + frame_ids[index] or topic.strip("/"), + access_unit.data, + "h264", + ), ) ) @@ -853,8 +816,6 @@ def output_topic(message: _OutgoingMessage) -> str: derived_topic, DEFAULT_STATE_GROUP ) - from mcap_protobuf.schema import build_file_descriptor_set - source_metadata = reader.metadata() episode_record_present = METADATA_RECORD_EPISODE in source_metadata episode_record = dict(source_metadata.get(METADATA_RECORD_EPISODE, {})) @@ -898,7 +859,7 @@ def output_topic(message: _OutgoingMessage) -> str: video_schema_id = writer.register_schema( name=CANONICAL_VIDEO_SCHEMA_NAME, encoding="protobuf", - data=build_file_descriptor_set(CompressedVideo).SerializeToString(), + data=COMPRESSED_VIDEO_SCHEMA, ) output_channel_ids[source_channel_id] = writer.register_channel( info.topic, diff --git a/tests/test_processing_regressions.py b/tests/test_processing_regressions.py index 098f28a7..ba838ca9 100644 --- a/tests/test_processing_regressions.py +++ b/tests/test_processing_regressions.py @@ -7,9 +7,8 @@ import subprocess import sys import textwrap -from collections.abc import Callable from pathlib import Path -from typing import Any, cast +from typing import cast import pytest from foxglove_schemas_protobuf.CompressedVideo_pb2 import CompressedVideo @@ -27,7 +26,6 @@ ) import hflow -from hflow import transform from hflow.catalog import content_episode_id from hflow.checks import required_topics from hflow.doctor import diagnose @@ -37,7 +35,6 @@ METADATA_RECORD_PROVENANCE, PROVENANCE_KEY_TOPIC_GROUP_PREFIX, ) -from hflow.reader import TopicInfo from hflow.testing import SyntheticEpisodeSpec, synthesize_episode from hflow.transform import SourceNotConforming, write_canonical_episode from hflow.video import estimate_fps_from_log_times @@ -519,10 +516,10 @@ def test_transform_inserts_missing_aud_into_ros2_video(tmp_path: Path) -> None: @pytest.mark.parametrize( "data", [KEYFRAME_ACCESS_UNIT, KEYFRAME_WITHOUT_AUD], ids=["conforming", "repaired"] ) -def test_transform_preserves_decoder_owned_video_messages( - tmp_path: Path, monkeypatch: pytest.MonkeyPatch, encoding: str, data: bytes +def test_transform_preserves_every_field_of_passthrough_video_messages( + tmp_path: Path, encoding: str, data: bytes ) -> None: - source = tmp_path / "decoder-owned-video.mcap" + source = tmp_path / "passthrough-video.mcap" if encoding == "protobuf": write_compressed_video_mcap(source, [("/cam", 1, data)]) else: @@ -536,34 +533,22 @@ def test_transform_preserves_decoder_owned_video_messages( original="source-recorder", ) - resolve_decoder = transform._resolve_decoder - decoder_owned_messages: list[Any] = [] - - def retaining_decoder(topic: str, info: TopicInfo) -> Callable[[bytes], Any]: - decode = resolve_decoder(topic, info) - - def decode_and_retain(payload: bytes) -> Any: - message = decode(payload) - decoder_owned_messages.append(message) - return message - - return decode_and_retain - - monkeypatch.setattr(transform, "_resolve_decoder", retaining_decoder) output = tmp_path / "out.mcap" write_canonical_episode(source, output) - (original,) = decoder_owned_messages - assert bytes(original.data) == data - assert original.format == "h264" - assert original.frame_id == "cam" - if encoding == "cdr": - with output.open("rb") as stream: - schema, channel, message = next(make_reader(stream).iter_messages()) - assert schema is not None - decode = Ros2DecoderFactory().decoder_for(channel.message_encoding, schema) - assert decode is not None - assert decode(message.data).original == "source-recorder" + with output.open("rb") as stream: + schema, channel, message = next(make_reader(stream).iter_messages()) + assert schema is not None + if encoding == "protobuf": + written = CompressedVideo.FromString(message.data) + else: + decode = Ros2DecoderFactory().decoder_for(channel.message_encoding, schema) + assert decode is not None + written = decode(message.data) + assert written.original == "source-recorder" + assert bytes(written.data).endswith(KEYFRAME_WITHOUT_AUD) + assert written.format == "h264" + assert written.frame_id == "cam" report = diagnose(output) assert report.conforming, report.summary() diff --git a/uv.lock b/uv.lock index 868555cb..f1e85f0f 100644 --- a/uv.lock +++ b/uv.lock @@ -1222,15 +1222,15 @@ wheels = [ [[package]] name = "hebbian-mcap" -version = "0.1.0" +version = "0.1.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/59/7e/e25ba9b4d74999bbf33dc0c989c4324c3b53d6b5393095cc21587fa68ade/hebbian_mcap-0.1.0.tar.gz", hash = "sha256:35845094f7d74ba428305c6eed7008cdc491c0f269494760edf0b6b18d561d16", size = 33623, upload-time = "2026-11-13T14:50:28.306Z" } +sdist = { url = "https://files.pythonhosted.org/packages/36/00/93440d933a7b0f6238cfbfc15ecaa63687bb93a735de1f5c68961a779b19/hebbian_mcap-0.1.1.tar.gz", hash = "sha256:89c41bfaedea4dc78f5c21015538b5ae19ee6ed764443b2fd3b5bcc636976b17", size = 45064, upload-time = "2026-11-15T10:28:14.103Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f3/55/21c241ef1fecf9788676b525aeaafb905bcd665d690fc06059e0478be40c/hebbian_mcap-0.1.0-cp311-abi3-macosx_10_12_x86_64.whl", hash = "sha256:65b7cf112de4cf7c0446d912927ad4cfa95c8bfa13e20d69d3da852de7f2e678", size = 613164, upload-time = "2026-11-13T14:50:22.492Z" }, - { url = "https://files.pythonhosted.org/packages/42/c7/3b49a463fe7a55dd5b9ba7ca7f7b23be6b20ae0e225e7f322e73fbd599c0/hebbian_mcap-0.1.0-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:b823fa90d3a33b00e724af9d49a54870362fb3c52e6fcdc9658ae2be46f5f445", size = 560158, upload-time = "2026-11-13T14:50:24.145Z" }, - { url = "https://files.pythonhosted.org/packages/6e/24/3bdfae9592d0f4ad96bf8f127c831eda429f214a242890a73654717c1062/hebbian_mcap-0.1.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1a9bc08328cdc063d22fa972e0930ecd8cb8c02d7c8da6c43c442d1d154af0a5", size = 691691, upload-time = "2026-11-13T14:50:25.079Z" }, - { url = "https://files.pythonhosted.org/packages/ad/04/31861e259dc72c0326db37166cdfd65e46d08da26c5906cec89f45c6a903/hebbian_mcap-0.1.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:238ca2985779bd63bc6344e70dc8a18dcb97906d1bae22ab9f8c6fb2e3982dcd", size = 685952, upload-time = "2026-11-13T14:50:26.099Z" }, - { url = "https://files.pythonhosted.org/packages/c8/ba/a573437df2b82a9d001252c2ea8a1e0ab2655a8014c097e9283c0b6ebea7/hebbian_mcap-0.1.0-cp311-abi3-win_amd64.whl", hash = "sha256:65f26d177478a95fe9abf50ec056d8d6d4df3e04c0279469ff50601a417191dd", size = 479322, upload-time = "2026-11-13T14:50:27.271Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a3/6d9e987cc4c6f6b5c61ac1beed8df46db31c03b1b935591244dbd80ee22b/hebbian_mcap-0.1.1-cp311-abi3-macosx_10_12_x86_64.whl", hash = "sha256:9ab2dd5c1ff0b665968ffa08dbc122a49778a5d303e2bc40c12a1953432e737f", size = 634284, upload-time = "2026-11-15T10:28:04.531Z" }, + { url = "https://files.pythonhosted.org/packages/48/c8/212378fe1cd2fb9030a50032e0f3a43131965b20cd84d615187776d7b812/hebbian_mcap-0.1.1-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:cc319552d6514b5210a14ce3099cb07b6804e7bf5e20d99fef88664439bca213", size = 578239, upload-time = "2026-11-15T10:28:07.776Z" }, + { url = "https://files.pythonhosted.org/packages/21/63/1bb0a63aac128c9eb627cd255ad2a9dac9100efb3ed8450aec5d35344634/hebbian_mcap-0.1.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8c4289507648799032a84804a4b13c47ea5c5ff606cb78aa4ef3a2664a5df342", size = 709197, upload-time = "2026-11-15T10:28:09.51Z" }, + { url = "https://files.pythonhosted.org/packages/18/cc/0ea8816b7c8c97f661d5af6016cb4f9878dc31014fe6129ab1cc70c97332/hebbian_mcap-0.1.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b596562a8be241de0ab4e404f9859e43640ade2ff270558fad7ebef78540d1f0", size = 708167, upload-time = "2026-11-15T10:28:11.573Z" }, + { url = "https://files.pythonhosted.org/packages/64/17/ec82211116102e6a1fd35daa07ca01f16c004dee3976d0a1d6d947fe22f1/hebbian_mcap-0.1.1-cp311-abi3-win_amd64.whl", hash = "sha256:a7704c336cd77ebcc51c3b30ef4dc7b97e9b0c767a60b56d951f39c980833fe7", size = 507248, upload-time = "2026-11-15T10:28:12.98Z" }, ] [package.optional-dependencies] @@ -1274,7 +1274,6 @@ version = "0.2.21" source = { editable = "." } dependencies = [ { name = "duckdb" }, - { name = "foxglove-schemas-protobuf" }, { name = "hebbian-mcap" }, { name = "httpx" }, { name = "httpx2" }, @@ -1322,6 +1321,7 @@ dev = [ { name = "av", version = "18.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, { name = "av", version = "19.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, { name = "cython" }, + { name = "foxglove-schemas-protobuf" }, { name = "hflow-server" }, { name = "obstore" }, { name = "opencv-python-headless" }, @@ -1339,9 +1339,8 @@ requires-dist = [ { name = "av", marker = "extra == 'video'", specifier = ">=18.1.0" }, { name = "cython", marker = "extra == 'native-build'", specifier = ">=3.3.0" }, { name = "duckdb", specifier = ">=2.0.0" }, - { name = "foxglove-schemas-protobuf", specifier = ">=0.4.0" }, - { name = "hebbian-mcap", specifier = "==0.1.0" }, - { name = "hebbian-mcap", extras = ["video"], marker = "extra == 'video'", specifier = "==0.1.0" }, + { name = "hebbian-mcap", specifier = "==0.1.1" }, + { name = "hebbian-mcap", extras = ["video"], marker = "extra == 'video'", specifier = "==0.1.1" }, { name = "httpx", specifier = ">=0.28.1,<1" }, { name = "httpx2", specifier = ">=2.12.0" }, { name = "huggingface-hub", specifier = ">=1.31.0,<2" }, @@ -1367,6 +1366,7 @@ provides-extras = ["arrow", "bucket", "mediapipe", "motion", "video", "native-bu dev = [ { name = "av", specifier = ">=18.1.0" }, { name = "cython", specifier = ">=3.3.0" }, + { name = "foxglove-schemas-protobuf", specifier = ">=0.4.0" }, { name = "hflow-server", editable = "packages/hflow-server" }, { name = "obstore", specifier = ">=0.11.1" }, { name = "opencv-python-headless", specifier = ">=5.0.0.93" },