highwayscene-proto 1.0.0__tar.gz

highwayscene_proto-1.0.0/LICENSE

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

highwayscene_proto-1.0.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include proto *.proto

highwayscene_proto-1.0.0/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: highwayscene-proto
+Version: 1.0.0
+Summary: Reference Python reader and Protobuf schema for HighwayScene records
+Author: Alexander Baumann
+License-Expression: MIT
+Project-URL: Homepage, https://highwayscene.github.io/
+Project-URL: Dataset, https://huggingface.co/datasets/iis-esslingen/HighwayScene
+Project-URL: Repository, https://github.com/HighwayScene/highwayscene-proto
+Project-URL: Issues, https://github.com/HighwayScene/highwayscene-proto/issues
+Keywords: lidar,point-cloud,protobuf,highwayscene,dataset
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: betterproto==1.2.5
+Requires-Dist: numpy<3,>=1.24
+Provides-Extra: visualization
+Requires-Dist: open3d<1,>=0.18; extra == "visualization"
+Provides-Extra: codegen
+Requires-Dist: black==26.5.1; extra == "codegen"
+Requires-Dist: betterproto[compiler]==1.2.5; extra == "codegen"
+Requires-Dist: grpcio-tools==1.83.0; extra == "codegen"
+Requires-Dist: protobuf==7.35.1; extra == "codegen"
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.2; extra == "dev"
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Requires-Dist: ruff<1,>=0.11; extra == "dev"
+Requires-Dist: twine<7,>=5; extra == "dev"
+Dynamic: license-file
+
+# highwayscene-proto
+
+`highwayscene-proto` is the reference Python reader and Protobuf schema for
+[HighwayScene](https://huggingface.co/datasets/iis-esslingen/HighwayScene), a
+multi-sensor static roadside LiDAR dataset. It provides generated message
+classes, memory-efficient record iteration, random frame access, and typed
+NumPy views of point-cloud channels.
+
+HighwayScene accompanies the paper **“Beam-Wise Statistical Background
+Subtraction for Static Roadside LiDAR: A Cross-Sensor Benchmark Study.”** See
+the [project page](https://highwayscene.github.io/) for the paper, code,
+dataset, and benchmark resources.
+
+## Installation
+
+Install the reader from PyPI:
+
+```bash
+python -m pip install highwayscene-proto
+```
+
+For development from a checkout:
+
+```bash
+python -m pip install -e '.[dev]'
+```
+
+Python 3.10 or newer is required.
+
+## Quick start
+
+Stream frames from a record without loading the complete file:
+
+```python
+from highwayscene import LaserName, decode_pointcloud, iter_frames
+
+for frame in iter_frames("HighwayScene/test/record.pb"):
+    print(frame.frame_id, frame.frame_timestamp_ns)
+    for scan in frame.lidars:
+        sensor = LaserName(scan.laser_name).name
+        points = decode_pointcloud(scan.pointcloud)
+        print(sensor, points.xyz.shape, points.channel_id)
+```
+
+Use `RecordFile` when you need indexed access:
+
+```python
+from highwayscene import RecordFile, decode_pointcloud
+
+record = RecordFile("HighwayScene/test/record.pb")
+frame = record[12]
+xyz = decode_pointcloud(frame.lidars[0].pointcloud).xyz
+```
+
+The existing generated-module imports remain available:
+
+```python
+from highwayscene.frame import Frame
+from highwayscene.sensors import LaserName, LidarScan
+```
+
+Imports through the former `a42` package name remain available as compatibility aliases.
+New code should use the `highwayscene` namespace.
+
+Inspect a file or a complete split from the command line:
+
+```bash
+highwayscene-inspect HighwayScene/test --limit 3
+highwayscene-inspect HighwayScene/test/record.pb --json
+```
+
+## Dataset download and layout
+
+Download HighwayScene with Git LFS or `huggingface_hub`:
+
+```bash
+python -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='iis-esslingen/HighwayScene', repo_type='dataset', local_dir='HighwayScene')"
+```
+
+The point-cloud records are organized by benchmark split:
+
+```text
+HighwayScene/
+├── train/*.pb
+├── val/*.pb
+├── test/*.pb
+└── label/...
+```
+
+The labels under `label/` belong to the background-subtraction benchmark and
+are consumed by the
+[`roadside-lidar-background-subtraction`](https://github.com/HighwayScene/roadside-lidar-background-subtraction)
+repository. They are separate from the optional `object_list` field in the
+Protobuf schema.
+
+## Record format
+
+Each `.pb` file is a sequence of messages. Every message consists of a
+four-byte unsigned little-endian payload length followed by one serialized
+`highwayscene.frame.Frame` message:
+
+```text
+[uint32 payload bytes][serialized Frame][uint32 payload bytes][serialized Frame]...
+```
+
+The schema is available under [`proto/highwayscene`](proto/highwayscene). Cartesian coordinates
+are interleaved little-endian `float32` values. Populated auxiliary channels
+contain one value per Cartesian point:
+
+| Field | NumPy dtype | Availability |
+| --- | --- | --- |
+| `cartesian` | `<f4`, shaped `(N, 3)` | all sensors |
+| `intensity` | `<u2` | sensor-dependent |
+| `ambient` | `<u2` | sensor-dependent |
+| `velocity` | `<f4` | Aeva Aeries II |
+| `reflectivity` | `<u2` | sensor-dependent |
+| `timestamp_offset` | `<u8` | sensor-dependent |
+| `channel_id` | `<u2` | sensors with fixed beam IDs |
+| `horizontal_id` | `<u2` | Blickfeld Qb2 scan positions |
+
+`decode_pointcloud()` validates byte alignment and channel lengths. Its default
+arrays are zero-copy, read-only views. Pass `copy=True` when writable arrays
+are required.
+
+## Sensor identifiers
+
+The HighwayScene classification sensors use these enum values:
+
+| Sensor | `LaserName` |
+| --- | --- |
+| Blickfeld Qb2 | `CLASS_QB2` |
+| Ouster OS0 | `CLASS_OS0` |
+| Aeva Aeries II | `CLASS_AERIES_II` |
+
+The remaining enum values are retained for wire compatibility with the
+HighwayScene record format.
+
+## Schema generation
+
+Generated `betterproto` bindings are committed so users do not need a Protobuf
+compiler. To regenerate them after an intentional schema change:
+
+```bash
+python -m pip install -e '.[codegen]'
+./scripts/generate_bindings.sh
+```
+
+Never renumber or reuse an existing Protobuf field. CI verifies that committed
+bindings match the schemas.
+
+## Licensing
+
+This reader and its Protobuf schemas are released under the [MIT License](LICENSE).
+The HighwayScene dataset is distributed separately under
+[CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/); using
+this package does not change the dataset license.

highwayscene_proto-1.0.0/README.md

@@ -0,0 +1,156 @@
+# highwayscene-proto
+
+`highwayscene-proto` is the reference Python reader and Protobuf schema for
+[HighwayScene](https://huggingface.co/datasets/iis-esslingen/HighwayScene), a
+multi-sensor static roadside LiDAR dataset. It provides generated message
+classes, memory-efficient record iteration, random frame access, and typed
+NumPy views of point-cloud channels.
+
+HighwayScene accompanies the paper **“Beam-Wise Statistical Background
+Subtraction for Static Roadside LiDAR: A Cross-Sensor Benchmark Study.”** See
+the [project page](https://highwayscene.github.io/) for the paper, code,
+dataset, and benchmark resources.
+
+## Installation
+
+Install the reader from PyPI:
+
+```bash
+python -m pip install highwayscene-proto
+```
+
+For development from a checkout:
+
+```bash
+python -m pip install -e '.[dev]'
+```
+
+Python 3.10 or newer is required.
+
+## Quick start
+
+Stream frames from a record without loading the complete file:
+
+```python
+from highwayscene import LaserName, decode_pointcloud, iter_frames
+
+for frame in iter_frames("HighwayScene/test/record.pb"):
+    print(frame.frame_id, frame.frame_timestamp_ns)
+    for scan in frame.lidars:
+        sensor = LaserName(scan.laser_name).name
+        points = decode_pointcloud(scan.pointcloud)
+        print(sensor, points.xyz.shape, points.channel_id)
+```
+
+Use `RecordFile` when you need indexed access:
+
+```python
+from highwayscene import RecordFile, decode_pointcloud
+
+record = RecordFile("HighwayScene/test/record.pb")
+frame = record[12]
+xyz = decode_pointcloud(frame.lidars[0].pointcloud).xyz
+```
+
+The existing generated-module imports remain available:
+
+```python
+from highwayscene.frame import Frame
+from highwayscene.sensors import LaserName, LidarScan
+```
+
+Imports through the former `a42` package name remain available as compatibility aliases.
+New code should use the `highwayscene` namespace.
+
+Inspect a file or a complete split from the command line:
+
+```bash
+highwayscene-inspect HighwayScene/test --limit 3
+highwayscene-inspect HighwayScene/test/record.pb --json
+```
+
+## Dataset download and layout
+
+Download HighwayScene with Git LFS or `huggingface_hub`:
+
+```bash
+python -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='iis-esslingen/HighwayScene', repo_type='dataset', local_dir='HighwayScene')"
+```
+
+The point-cloud records are organized by benchmark split:
+
+```text
+HighwayScene/
+├── train/*.pb
+├── val/*.pb
+├── test/*.pb
+└── label/...
+```
+
+The labels under `label/` belong to the background-subtraction benchmark and
+are consumed by the
+[`roadside-lidar-background-subtraction`](https://github.com/HighwayScene/roadside-lidar-background-subtraction)
+repository. They are separate from the optional `object_list` field in the
+Protobuf schema.
+
+## Record format
+
+Each `.pb` file is a sequence of messages. Every message consists of a
+four-byte unsigned little-endian payload length followed by one serialized
+`highwayscene.frame.Frame` message:
+
+```text
+[uint32 payload bytes][serialized Frame][uint32 payload bytes][serialized Frame]...
+```
+
+The schema is available under [`proto/highwayscene`](proto/highwayscene). Cartesian coordinates
+are interleaved little-endian `float32` values. Populated auxiliary channels
+contain one value per Cartesian point:
+
+| Field | NumPy dtype | Availability |
+| --- | --- | --- |
+| `cartesian` | `<f4`, shaped `(N, 3)` | all sensors |
+| `intensity` | `<u2` | sensor-dependent |
+| `ambient` | `<u2` | sensor-dependent |
+| `velocity` | `<f4` | Aeva Aeries II |
+| `reflectivity` | `<u2` | sensor-dependent |
+| `timestamp_offset` | `<u8` | sensor-dependent |
+| `channel_id` | `<u2` | sensors with fixed beam IDs |
+| `horizontal_id` | `<u2` | Blickfeld Qb2 scan positions |
+
+`decode_pointcloud()` validates byte alignment and channel lengths. Its default
+arrays are zero-copy, read-only views. Pass `copy=True` when writable arrays
+are required.
+
+## Sensor identifiers
+
+The HighwayScene classification sensors use these enum values:
+
+| Sensor | `LaserName` |
+| --- | --- |
+| Blickfeld Qb2 | `CLASS_QB2` |
+| Ouster OS0 | `CLASS_OS0` |
+| Aeva Aeries II | `CLASS_AERIES_II` |
+
+The remaining enum values are retained for wire compatibility with the
+HighwayScene record format.
+
+## Schema generation
+
+Generated `betterproto` bindings are committed so users do not need a Protobuf
+compiler. To regenerate them after an intentional schema change:
+
+```bash
+python -m pip install -e '.[codegen]'
+./scripts/generate_bindings.sh
+```
+
+Never renumber or reuse an existing Protobuf field. CI verifies that committed
+bindings match the schemas.
+
+## Licensing
+
+This reader and its Protobuf schemas are released under the [MIT License](LICENSE).
+The HighwayScene dataset is distributed separately under
+[CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/); using
+this package does not change the dataset license.

highwayscene_proto-1.0.0/proto/highwayscene/common/calibration.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+package highwayscene.common;
+
+message SensorCalibration {
+  string sensor_name            = 1;
+  repeated float extrinsic      = 2;
+
+  float vertical_fov           = 3;
+  float horizontal_fov         = 4;
+
+  uint32 vertical_scanlines = 5;
+  uint32 horizontal_scanlines = 6;
+
+  float horizontal_angle_spacing = 7;
+
+  repeated float beam_altitude_angles = 8;
+  repeated float beam_azimuth_angles  = 9;
+
+  string frame_mode             = 10;
+  string scan_pattern           = 11;
+}

highwayscene_proto-1.0.0/proto/highwayscene/data/pointcloud.proto

@@ -0,0 +1,13 @@
+syntax = "proto3";
+package highwayscene.data;
+
+message PointCloud {
+  bytes    cartesian           = 1;
+  bytes    intensity           = 2;
+  bytes    ambient             = 3;
+  bytes    velocity            = 4;
+  bytes    reflectivity        = 5; // Reflectivity = Intensity * r²
+  bytes    timestamp_offset    = 6; // Offset to Scan Timestamp in ns
+  bytes    channel_id          = 7;
+  bytes    horizontal_id       = 8;
+}

highwayscene_proto-1.0.0/proto/highwayscene/frame.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+package highwayscene.frame;
+
+import "highwayscene/sensors/lidar.proto";
+
+// Groups synchronized sensor scans into one dataset frame.
+message Frame {
+  uint64                    frame_timestamp_ns = 1;
+  repeated highwayscene.sensors.LidarScan lidars        = 2;
+  uint32                    frame_id           = 3;
+}

highwayscene_proto-1.0.0/proto/highwayscene/label/object.proto

@@ -0,0 +1,41 @@
+syntax = "proto3";
+package highwayscene.label;
+
+import "highwayscene/data/pointcloud.proto";
+
+message Position {
+  float x = 1;
+  float y = 2;
+  float z = 3;
+}
+
+message Dimensions {
+  float x = 1;
+  float y = 2;
+  float z = 3;
+}
+
+message Orientation {
+  float x = 1;
+  float y = 2;
+  float z = 3;
+  float w = 4;
+}
+
+message Velocity {
+  float x = 1;
+  float y = 2;
+  float z = 3;
+}
+
+message ObjectBBox {
+  uint32               id           = 1;
+  uint64               timestamp_ns = 2;
+  Position             position     = 3;
+  Dimensions           dimension    = 4;
+  Orientation          orientation  = 5;
+  Velocity             velocity     = 6;
+  highwayscene.data.PointCloud  pointcloud   = 7;
+  string               obj_class    = 8;
+  float                obj_class_score = 9;
+}

highwayscene_proto-1.0.0/proto/highwayscene/sensors/camera.proto

@@ -0,0 +1,21 @@
+syntax = "proto3";
+package highwayscene.sensors;
+
+
+// Camera-specific metadata.
+message CameraCalibration {
+  string sensor_name = 1;
+  // Intrinsic matrix in row-major order, when available.
+  repeated double intrinsic = 2;
+}
+
+// A single camera image.
+message CameraFrame {
+  string sensor_name           = 1;
+  uint64 frame_timestamp_ns    = 2;  // Timestamp used for sensor synchronization.
+  uint32 width                 = 3;
+  uint32 height                = 4;
+  string encoding              = 5;  // "jpeg", "png", "raw_bgr", ...
+  bytes image_data             = 6;
+  CameraCalibration calibration = 7;
+}

highwayscene_proto-1.0.0/proto/highwayscene/sensors/lidar.proto

@@ -0,0 +1,35 @@
+syntax = "proto3";
+package highwayscene.sensors;
+
+import "highwayscene/common/calibration.proto";
+import "highwayscene/label/object.proto";
+import "highwayscene/data/pointcloud.proto";
+
+// Identifies the LiDAR sensor that produced a scan.
+enum LaserName {
+  UNKNOWN_NAME     = 0;
+  WIM_HOR          = 1;
+  ANPR_HOR         = 2;
+  AMPEL_HOR        = 3;
+  WIM_VER          = 4;
+  ANPR_VER         = 5;
+  AMPEL_VER        = 6;
+  CLASS_QB2        = 7;
+  CLASS_OS0        = 8;
+  CLASS_AERIES_II  = 9;
+}
+
+// Data captured by one LiDAR sensor for a single sweep.
+message LidarScan {
+  LaserName                      laser_name        = 1;
+  uint64                         scan_timestamp_ns = 2;
+
+  // Encoded point-cloud channels.
+  highwayscene.data.PointCloud                     pointcloud        = 3;
+
+  // Sensor calibration metadata.
+  highwayscene.common.SensorCalibration   calibration       = 4;
+
+  // Optional objects associated with this scan.
+  repeated highwayscene.label.ObjectBBox object_list = 5;
+}

highwayscene_proto-1.0.0/pyproject.toml

@@ -0,0 +1,88 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "highwayscene-proto"
+version = "1.0.0"
+description = "Reference Python reader and Protobuf schema for HighwayScene records"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  {name = "Alexander Baumann"},
+]
+keywords = ["lidar", "point-cloud", "protobuf", "highwayscene", "dataset"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+  "betterproto==1.2.5",
+  "numpy>=1.24,<3",
+]
+
+[project.optional-dependencies]
+visualization = [
+  "open3d>=0.18,<1",
+]
+codegen = [
+  "black==26.5.1",
+  "betterproto[compiler]==1.2.5",
+  "grpcio-tools==1.83.0",
+  "protobuf==7.35.1",
+]
+dev = [
+  "build>=1.2,<2",
+  "pytest>=8,<10",
+  "ruff>=0.11,<1",
+  "twine>=5,<7",
+]
+
+[project.scripts]
+highwayscene-inspect = "highwayscene.cli:entrypoint"
+a42-inspect = "highwayscene.cli:entrypoint"
+
+[project.urls]
+Homepage = "https://highwayscene.github.io/"
+Dataset = "https://huggingface.co/datasets/iis-esslingen/HighwayScene"
+Repository = "https://github.com/HighwayScene/highwayscene-proto"
+Issues = "https://github.com/HighwayScene/highwayscene-proto/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+highwayscene = ["py.typed"]
+a42 = ["py.typed"]
+
+[tool.pytest.ini_options]
+addopts = "-ra"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["B", "D", "E", "F", "I", "UP"]
+ignore = ["D203", "D213"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.per-file-ignores]
+"examples/*.py" = ["D"]
+"src/highwayscene/common.py" = ["ALL"]
+"src/highwayscene/data.py" = ["ALL"]
+"src/highwayscene/frame.py" = ["ALL"]
+"src/highwayscene/label.py" = ["ALL"]
+"src/highwayscene/sensors.py" = ["ALL"]
+"tests/*.py" = ["D"]

highwayscene_proto-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

highwayscene_proto-1.0.0/src/a42/__init__.py

@@ -0,0 +1,50 @@
+"""Compatibility API for the former ``a42`` package name."""
+
+from highwayscene import DEFAULT_MAX_MESSAGE_BYTES as DEFAULT_MAX_MESSAGE_BYTES
+from highwayscene import CameraCalibration as CameraCalibration
+from highwayscene import CameraFrame as CameraFrame
+from highwayscene import Dimensions as Dimensions
+from highwayscene import Frame as Frame
+from highwayscene import LaserName as LaserName
+from highwayscene import LidarScan as LidarScan
+from highwayscene import ObjectBBox as ObjectBBox
+from highwayscene import Orientation as Orientation
+from highwayscene import PointCloud as PointCloud
+from highwayscene import PointCloudArrays as PointCloudArrays
+from highwayscene import PointCloudFormatError as PointCloudFormatError
+from highwayscene import Position as Position
+from highwayscene import RecordFile as RecordFile
+from highwayscene import RecordFormatError as RecordFormatError
+from highwayscene import SensorCalibration as SensorCalibration
+from highwayscene import Velocity as Velocity
+from highwayscene import __version__ as __version__
+from highwayscene import decode_pointcloud as decode_pointcloud
+from highwayscene import iter_directory as iter_directory
+from highwayscene import iter_frame_stream as iter_frame_stream
+from highwayscene import iter_frames as iter_frames
+from highwayscene import iter_record_paths as iter_record_paths
+
+__all__ = [
+    "DEFAULT_MAX_MESSAGE_BYTES",
+    "CameraCalibration",
+    "CameraFrame",
+    "Dimensions",
+    "Frame",
+    "LaserName",
+    "LidarScan",
+    "ObjectBBox",
+    "Orientation",
+    "PointCloud",
+    "PointCloudArrays",
+    "PointCloudFormatError",
+    "Position",
+    "RecordFile",
+    "RecordFormatError",
+    "SensorCalibration",
+    "Velocity",
+    "decode_pointcloud",
+    "iter_directory",
+    "iter_frame_stream",
+    "iter_frames",
+    "iter_record_paths",
+]

highwayscene_proto-1.0.0/src/a42/__main__.py

@@ -0,0 +1,6 @@
+"""Run the HighwayScene inspector through the former package name."""
+
+from highwayscene.cli import entrypoint
+
+if __name__ == "__main__":
+    entrypoint()

highwayscene_proto-1.0.0/src/a42/cli.py

@@ -0,0 +1,6 @@
+"""Compatibility entry point for the HighwayScene inspector."""
+
+from highwayscene.cli import entrypoint as entrypoint
+from highwayscene.cli import main as main
+
+__all__ = ["entrypoint", "main"]

highwayscene_proto-1.0.0/src/a42/common.py

@@ -0,0 +1,5 @@
+"""Compatibility exports for calibration messages."""
+
+from highwayscene.common import SensorCalibration as SensorCalibration
+
+__all__ = ["SensorCalibration"]