apairo-preprocess 0.2.0__py3-none-any.whl

apairo_preprocess/traversability/from_trajectory.py

@@ -0,0 +1,181 @@
+"""Trajectory-based traversability ground truth.
+
+For each scan, a point is labelled traversable (1) if it lies within the
+robot's 2-D footprint projected along any **future** pose — i.e. positions
+the robot has not yet visited.
+
+Poses are read from the dataset via ``poses_key`` (declared in
+``input_keys``).  The full trajectory is available in ``__call__`` because
+:class:`SequencePreprocessor` receives an iterator over all frames at once.
+
+Poses must be ``(4, 4)`` float64 homogeneous matrices.  Apply
+``ds = ds.transform(poses_key, PoseTo4x4())`` from ``apairo_transform`` beforehand
+if your poses are stored in another format (quaternion, Euler, compact 3×4).
+
+Typical usage::
+
+    Goose3DDataset.run_preprocess(
+        TraversabilityFromTrajectory(poses_key="kissicp_poses", robot_radius=0.75),
+        split_dir,
+    )
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar, Iterator
+
+import numpy as np
+from scipy.spatial import KDTree
+
+from apairo.core.preprocessor import SequencePreprocessor
+from apairo.core.sample import Sample
+from apairo_transform import RangeFilter
+
+class TraversabilityFromTrajectory(SequencePreprocessor):
+    """Label each point traversable if it lies in the robot's forward footprint.
+
+    Poses and point clouds are loaded from the dataset via ``input_keys``.
+    Sequence boundary detection and look-ahead are computed in ``__call__``
+    where the full trajectory is available.
+
+    Args:
+        lidar_key:             Input channel for point cloud data.
+        poses_key:             Input channel for per-frame poses — must be ``(4, 4)``
+                               float64.  Apply ``PoseTo4x4()`` from ``apairo_transform``
+                               if needed.
+        robot_radius:          Half-width of the robot footprint in XY (metres).
+        height_min:            Minimum point height relative to the nearest robot
+                               position to be traversable (metres, ≤ 0).
+        height_max:            Maximum point height relative to the nearest robot
+                               position (metres, ≥ 0).
+        forward_window:        Maximum number of future poses to look ahead.
+                               ``None`` (default) uses the entire remaining trajectory.
+        forward_distance:      Maximum *path length* (metres) of future trajectory
+                               to consider.  Caps the look-ahead where the path
+                               loops back near already-seen terrain: without it, a
+                               point can be labelled traversable because a much
+                               later part of the trajectory passes nearby.
+                               ``None`` (default) does not cap by distance.
+        sequence_gap:          Distance threshold (metres) to detect sequence
+                               boundaries and avoid look-ahead across discontinuous
+                               sessions.
+        near_exclusion_radius: Sensor-frame distance below which a point is never
+                               labelled traversable, suppressing dynamic objects
+                               (e.g. humans) close to the robot.  The shape of the
+                               exclusion zone is controlled by ``near_exclusion_norm``.
+                               ``0.0`` disables the exclusion (default).
+        near_exclusion_norm:   Norm order for the exclusion distance, forwarded to
+                               :class:`~apairo_transform.RangeFilter`.  Use
+                               ``np.inf`` (L∞) for a cube, ``2`` for a sphere.
+                               Defaults to ``np.inf``.
+        output_key:            Override the default output channel name ``"trav_traj"``.
+    """
+
+    output_key: ClassVar[str] = "trav_traj"
+    input_keys: ClassVar[list[str]] = ["lidar", "poses"]
+    timestamps_from: ClassVar[str] = "lidar"
+    sources: ClassVar[list[str]] = ["lidar", "poses"]
+
+    def __init__(
+        self,
+        lidar_key: str = "lidar",
+        poses_key: str = "poses",
+        robot_radius: float = 0.75,
+        height_min: float = -0.3,
+        height_max: float = 0.5,
+        forward_window: int | None = None,
+        forward_distance: float | None = None,
+        sequence_gap: float = 5.0,
+        near_exclusion_radius: float = 0.0,
+        near_exclusion_norm: float = np.inf,
+        output_key: str | None = None,
+    ) -> None:
+        self._lidar_key = lidar_key
+        self._poses_key = poses_key
+        self._robot_radius = robot_radius
+        self._height_min = height_min
+        self._height_max = height_max
+        self._forward_window = forward_window
+        self._forward_distance = forward_distance
+        self._sequence_gap = sequence_gap
+        self._near_filter = (
+            RangeFilter(min=near_exclusion_radius, max=None, norm=near_exclusion_norm)
+            if near_exclusion_radius > 0
+            else None
+        )
+
+        self.input_keys = [lidar_key, poses_key]
+        self.sources = [lidar_key, poses_key]
+        if output_key is not None:
+            self.output_key = output_key
+
+    def __call__(self, frames: Iterator[Sample]) -> np.ndarray:
+        all_samples = list(frames)
+        n = len(all_samples)
+
+        poses = np.asarray(
+            np.stack([s.data[self._poses_key] for s in all_samples]), dtype=np.float64
+        )
+        if poses.shape[1:] != (4, 4):
+            raise ValueError(
+                f"poses must be (N, 4, 4) — apply PoseTo4x4() from apairo_transform first. "
+                f"Got {poses.shape}"
+            )
+
+        # Sequence boundary detection — done here where poses are available.
+        positions = poses[:, :3, 3]
+        dists = np.linalg.norm(np.diff(positions, axis=0), axis=1)
+        boundaries = np.where(dists > self._sequence_gap)[0]
+        ends = np.concatenate([boundaries, [n - 1]])
+        seq_end = ends[np.searchsorted(ends, np.arange(n))]
+
+        # Cumulative path length, for the forward_distance cap.
+        path = np.concatenate([[0.0], np.cumsum(dists)])
+
+        results = []
+        for idx, sample in enumerate(all_samples):
+            pc = np.asarray(sample.data[self._lidar_key])
+            xyz_sensor = pc[:, :3].astype(np.float64)
+            n_pts = len(xyz_sensor)
+
+            T = poses[idx]
+            xyz_h = np.column_stack([xyz_sensor, np.ones(n_pts)])
+            xyz_world = (T @ xyz_h.T).T[:, :3]
+
+            end = int(seq_end[idx]) + 1
+            if self._forward_window is not None:
+                end = min(end, idx + 1 + self._forward_window)
+            if self._forward_distance is not None:
+                end = min(
+                    end,
+                    int(np.searchsorted(path, path[idx] + self._forward_distance, side="right")),
+                )
+            future_pos = poses[idx + 1 : end, :3, 3]
+
+            if len(future_pos) == 0:
+                results.append(np.zeros(n_pts, dtype=np.uint8))
+                continue
+
+            tree = KDTree(future_pos[:, :2])
+            # workers=-1 deadlocks when called from a ThreadPoolExecutor (e.g. viewer)
+            dist_xy, nn_idx = tree.query(xyz_world[:, :2], k=1)
+            dz = xyz_world[:, 2] - future_pos[nn_idx, 2]
+
+            trav = (
+                (dist_xy < self._robot_radius)
+                & (dz >= self._height_min)
+                & (dz <= self._height_max)
+            )
+            if self._near_filter is not None:
+                trav &= self._near_filter.compute_mask(xyz_sensor)
+
+            results.append(trav.astype(np.uint8))
+
+        # Uniform scans stack to (N, P) as before; ragged scans (real lidar,
+        # variable return count) become an object array of per-frame rows,
+        # which the per-frame runner and direct callers iterate identically.
+        if len({len(r) for r in results}) <= 1:
+            return np.stack(results)
+        out = np.empty(n, dtype=object)
+        out[:] = results
+        return out

apairo_preprocess-0.2.0.dist-info/METADATA

@@ -0,0 +1,255 @@
+Metadata-Version: 2.4
+Name: apairo-preprocess
+Version: 0.2.0
+Summary: Preprocessing for apairo datasets: odometry, ground segmentation, projection, traversability labels
+Author-email: Augustin Bresset <augustin.bresset@gmail.com>
+License: MIT
+Project-URL: Homepage, https://apairo-robotics.github.io/
+Project-URL: Repository, https://github.com/apairo-robotics/apairo_preprocess
+Project-URL: Issues, https://github.com/apairo-robotics/apairo_preprocess/issues
+Keywords: apairo,lidar,point-cloud,traversability,ground-segmentation,robotics
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy
+Requires-Dist: pyyaml
+Requires-Dist: tqdm
+Requires-Dist: cloth-simulation-filter
+Requires-Dist: apairo>=0.9
+Requires-Dist: apairo-transform>=0.3
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# apairo-preprocess
+
+Preprocessing pipelines for [apairo](https://github.com/apairo-robotics/apairo) datasets — LiDAR odometry, ground segmentation, camera projection, and traversability ground truth generation.
+
+---
+
+## Installation
+
+```bash
+pip install apairo-preprocess
+```
+
+It brings `apairo` (≥ 0.9) and `apairo-transform` (≥ 0.3).
+
+### Optional dependencies
+
+| Preprocessor | Dependency | Install |
+|---|---|---|
+| `KissICPOdometry` | KISS-ICP | `pip install kiss-icp` |
+| `GICPOdometry` | Open3D | `pip install open3d` |
+| `GroundSegmentationCSF` / `GroundHeightFromLabels` (CSF backend) | CSF | `pip install cloth-simulation-filter` |
+
+Requires Python ≥ 3.11.
+
+---
+
+## Preprocessors
+
+### Odometry
+
+| Class | Output channel | Backend | Output |
+|---|---|---|---|
+| `KissICPOdometry` | `kissicp_poses` | [KISS-ICP](https://github.com/PRBonn/kiss-icp) | `(4, 4)` float64 pose per scan |
+| `GICPOdometry` | `gicp_poses` | Open3D GICP | `(4, 4)` float64 pose per scan |
+
+### Ground segmentation
+
+Binary ground/non-ground labels (0 = ground, 1 = non-ground). All three algorithms share the same label convention and can be compared directly.
+
+| Class | Output channel | Method | Extra dep |
+|---|---|---|---|
+| `GroundSegmentationCSF` | `ground_csf` | Cloth Simulation Filter — accurate on uneven terrain | `CSF` |
+| `GroundSegmentationRANSAC` | `ground_ransac` | RANSAC plane fitting — fast, assumes flat ground | — |
+| `GroundSegmentationFromLabels` | `ground_labels` | Maps existing semantic class IDs to ground/non-ground | — |
+
+### Priors
+
+Scalar per-point features used as traversability priors. Depend on previously computed channels.
+
+| Class | Output channel | Input channels | Output |
+|---|---|---|---|
+| `GroundHeightFromLabels` | `ground_height` | any ground segmentation + `voxelised` | float32 height above nearest ground point (m) |
+| `TrajectoryDistance` | `trajectory_distance` | `voxelised` + `poses` | float32 distance to nearest trajectory waypoint (m) |
+
+### Traversability
+
+Binary traversability labels (1 = traversable, 0 = not).
+
+| Class | Output channel | Method |
+|---|---|---|
+| `TraversabilityFromLabels` | `trav_label` | Maps semantic class IDs to binary traversable/non-traversable |
+| `TraversabilityFromTrajectory` | `trav_traj` | Labels points inside the robot's forward footprint along the trajectory |
+
+### Camera projection
+
+Atomic bridges between the point cloud and image spaces.  All outputs are
+**row-aligned** with the lidar scan, so any per-point channel composes with
+the projection by row index.
+
+| Class | Output channel | Input channels | Output |
+|---|---|---|---|
+| `LidarCameraProjection` | `lidar_uv` | lidar only (extrinsics/intrinsics are static) | `(N, 3)` float32 `[u, v, depth]`, NaN outside the frustum |
+| `PointFeaturesFromImage` | `point_features` | `lidar_uv` + image | `(N, C)` image values per point (e.g. RGB) — image → cloud |
+| `ImageMaskFromPointLabels` | `trav_mask` | `trav_traj` + `lidar_uv` | `(H, W)` uint8 label mask, 255 = no data — cloud → image |
+
+Pixel conflicts resolve to the nearest point (depth ordering); an optional
+occlusion filter (`occlusion_bin_px`) drops points hidden behind nearer
+returns so ground behind an obstacle does not bleed onto its pixels.
+Both halves of the projection come from the dataset calibration: the
+extrinsic via `ds.calibration.get_tf(lidar_frame, camera_frame)`, the
+intrinsics via `ds.calibration.get_intrinsics(camera_frame)`.
+
+**Asynchronous datasets:** `LidarCameraProjection` streams a single channel
+and runs anywhere.  The two multi-channel preprocessors run via
+`run_preprocess` on synchronous (profiled) datasets only; on an async dataset
+(TartanDrive, raw rigs) run them over a `synchronize()` view and persist with
+`ChannelWriter` — see
+[`examples/traversability_image_mask.py`](examples/traversability_image_mask.py).
+
+---
+
+## Quickstart
+
+### Ground segmentation
+
+```python
+from apairo.dataset.rellis import Rellis3DDataset
+from apairo_preprocess import GroundSegmentationCSF, GroundSegmentationFromLabels, GroundSegmentationRANSAC
+
+dataset_dir = "/data/Rellis-3D/00000"
+
+Rellis3DDataset.run_preprocess(GroundSegmentationRANSAC(), dataset_dir)
+Rellis3DDataset.run_preprocess(GroundSegmentationCSF(), dataset_dir)   # requires: pip install CSF
+
+# From existing semantic labels (default ground IDs are for RELLIS-3D)
+Rellis3DDataset.run_preprocess(GroundSegmentationFromLabels(), dataset_dir)
+
+# writes ground_ransac/, ground_csf/, ground_labels/  (uint8: 0=ground, 1=non-ground)
+```
+
+### Height above ground (prior)
+
+Ground segmentation must be computed first.
+
+```python
+from apairo_preprocess import GroundSegmentationCSF, GroundHeightFromLabels
+
+Rellis3DDataset.run_preprocess(GroundSegmentationCSF(), dataset_dir)
+Rellis3DDataset.run_preprocess(
+    GroundHeightFromLabels(ground_key="ground_csf"),
+    dataset_dir,
+)
+# writes ground_height/  (float32, metres above nearest ground point)
+```
+
+`GroundHeightFromLabels` accepts any ground key — swap `"ground_csf"` for `"ground_ransac"` or `"ground_labels"` to change the backend without re-running CSF.
+
+### Traversability from semantic labels
+
+```python
+from apairo_preprocess import TraversabilityFromLabels
+
+# Default traversable IDs for RELLIS-3D: {dirt, grass, asphalt, concrete, puddle, mud}
+Rellis3DDataset.run_preprocess(TraversabilityFromLabels(), dataset_dir)
+# writes trav_label/  (uint8: 1=traversable, 0=not)
+```
+
+Custom IDs for SemanticKITTI:
+
+```python
+from apairo.dataset.semantic_kitti import SemanticKittiDataset
+from apairo_preprocess import TraversabilityFromLabels
+
+SemanticKittiDataset.run_preprocess(
+    TraversabilityFromLabels(traversable_ids=frozenset({40, 44, 48, 49, 60, 72})),
+    "/data/sequences/00",
+)
+```
+
+### Traversability ground truth from trajectory
+
+Requires poses to be computed first (e.g. with `KissICPOdometry`).
+
+```python
+from apairo.dataset.goose import Goose3DDataset
+from apairo_preprocess import KissICPOdometry, TraversabilityFromTrajectory
+
+Goose3DDataset.run_preprocess(KissICPOdometry(voxel_size=1.0), "/data/goose/seq_001")
+Goose3DDataset.run_preprocess(
+    TraversabilityFromTrajectory(poses_key="kissicp_poses", robot_radius=0.75),
+    "/data/goose/seq_001",
+)
+# writes trav_traj/  (uint8: 1=traversable, 0=not)
+```
+
+### Traversability mask in image space
+
+Projects the trajectory ground truth into the camera: `trav_traj` labels the
+points, `lidar_uv` places them in the image, `ImageMaskFromPointLabels`
+paints the mask.
+
+```python
+from apairo_preprocess import ImageMaskFromPointLabels, LidarCameraProjection
+
+cal = Rellis3DDataset(dataset_dir, keys=["lidar"]).calibration
+cam = cal.get_intrinsics("camera")               # K, distortion, image size
+T = cal.get_tf("lidar", "camera")                # lidar -> camera optical frame
+
+Rellis3DDataset.run_preprocess(
+    LidarCameraProjection(intrinsics=cam, extrinsics=T),
+    dataset_dir,
+)
+Rellis3DDataset.run_preprocess(
+    ImageMaskFromPointLabels(image_size=(cam.height, cam.width), radius=2, occlusion_bin_px=8),
+    dataset_dir,
+)
+# writes lidar_uv/  (float32 [u, v, depth] per point)
+#    and trav_mask/ (uint8 per pixel: 1=traversable, 0=not, 255=no data)
+```
+
+To sanity-check calibration and projection first, colour the cloud with
+camera RGB and inspect it in a 3-D viewer (projector, apairo_rr):
+
+```python
+from apairo_preprocess import PointFeaturesFromImage
+
+Rellis3DDataset.run_preprocess(
+    PointFeaturesFromImage(image_key="image", output_key="lidar_rgb"),
+    dataset_dir,
+)
+```
+
+---
+
+## Examples
+
+Ready-to-run scripts in [`examples/`](examples/):
+
+```bash
+python examples/kissicp_odometry.py /data/Rellis-3D/00000 --dataset rellis
+python examples/traversability_from_labels.py /data/Rellis-3D/00000
+python examples/traversability_from_trajectory.py /data/goose/seq_001
+python examples/traversability_image_mask.py /data/tartan/seq --lidar-frame velodyne --camera-frame multisense_left --rgb
+
+# no dataset needed — synthetic scene, renders every pipeline stage (needs matplotlib)
+python examples/projection_pipeline_demo.py --out-dir /tmp/projection_demo
+```
+
+---
+
+## License
+
+MIT

apairo_preprocess-0.2.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+apairo_preprocess/__init__.py,sha256=wEAn4dD45rqJAFfaWqEqk8UCjiR8bNpZ7ca5Fqv4DRQ,1133
+apairo_preprocess/ground/__init__.py,sha256=3UvuSZhAdVvUqZZjFFNLH90LBs-ZSmhLmEXl1x2bjq4,322
+apairo_preprocess/ground/csf.py,sha256=6DmUABDq6Of4Wi1JHdCAE8OH3iaYA9CNKdqVbkq5zfo,3157
+apairo_preprocess/ground/from_labels.py,sha256=Bcj8bpB6_mRf_9MnYKx5-7Zl8lFhAyaAWvreRl8BFfs,1911
+apairo_preprocess/ground/ransac.py,sha256=IlhK4oeo7JJSm_xe1SRcs1cSOcg-0tGdZ1XAh4VjUKo,3115
+apairo_preprocess/odometry/__init__.py,sha256=erzuos15IRNHoBm0q3Hf-IqvP3lpnSLKNc5doKX2lks,167
+apairo_preprocess/odometry/gicp.py,sha256=RM3NQjSTJMGpe9p8bPPVbubdTMk6HHtnIwVcHRnvTgk,3337
+apairo_preprocess/odometry/kissicp.py,sha256=pqnbmmZ4Q7J2cYUOEP_RYZux851A_4roMMuZcjX_Lao,2884
+apairo_preprocess/pointcloud/__init__.py,sha256=0p975u6q-KfblA6CJwI1U7sfsSDZVD35Gie1M7PQwP8,264
+apairo_preprocess/pointcloud/robot_filter.py,sha256=ckh8eTE_0FtJNn-QEQHq_jPF1B8WAFJPUaZp-tXRGDU,4388
+apairo_preprocess/pointcloud/voxelise.py,sha256=IVuzNjNbNMhZbJmlHeBZaF9yHcQTEx9IXMhchk_SnQo,10861
+apairo_preprocess/priors/__init__.py,sha256=3_s47SMwLczKFM7LhO43wtW77Db-ZGBSXwPWANkcatI,221
+apairo_preprocess/priors/ground_height.py,sha256=SKbVN0Yz5gYx5f9imOSTxXSmi2QU9tzTx61__XWKvd4,2264
+apairo_preprocess/priors/trajectory_distance.py,sha256=4FmNxJ4KX-rl8iacuYPofWsYAQQOehMUv9iYscXWqxM,3576
+apairo_preprocess/projection/__init__.py,sha256=RWy_75qtgOtvNQqGAdp4rMrstAvVTLe5tSaNw8UYUHY,465
+apairo_preprocess/projection/bev.py,sha256=PUyc9HyU9UkVvHBjgwm5wRA7wpiT47fuP8oc75UdcCc,6711
+apairo_preprocess/projection/image_mask.py,sha256=vH8TxwVbt5mPCTM07S6E0wQeX0YooF-qGoOaqREN3s0,7712
+apairo_preprocess/projection/lidar_to_camera.py,sha256=oC-ZWEc5lJGFtTSSTN1sAmKflGU9_dMJrz5zKA0XXlM,7350
+apairo_preprocess/projection/point_features.py,sha256=sjpJT-JMtHaZRkq-F0xNGucFZbNlq3of-4PlWm8oONo,4014
+apairo_preprocess/traversability/__init__.py,sha256=PJXnR-IFpylesJBP3uJJhVae51yRPsF70R_tvvAIifk,255
+apairo_preprocess/traversability/from_labels.py,sha256=Ko-Oa-xJgbYux61BbPcNeXJ-YiwgKJY9mP7o7_rkfew,1979
+apairo_preprocess/traversability/from_trajectory.py,sha256=JhXbRCltlWGQ6GP08ErNP09305ILowzAZXoiCRtxbb8,7967
+apairo_preprocess-0.2.0.dist-info/licenses/LICENSE,sha256=17AGWvla1McJcPrt-Tyos8l2V1W4rgNJiRujo1lKzTY,1073
+apairo_preprocess-0.2.0.dist-info/METADATA,sha256=IQU6Q_SdQeWjlCOamkGucx-jSuqLTNUPd3-TAZNFBZY,9434
+apairo_preprocess-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+apairo_preprocess-0.2.0.dist-info/top_level.txt,sha256=WT1v0QlQpiFhHPUuIHrZwbVGU2zxkvwUwSl19clk8WA,18
+apairo_preprocess-0.2.0.dist-info/RECORD,,

apairo_preprocess-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

apairo_preprocess-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Augustin BRESSET
+
+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.

apairo_preprocess-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+apairo_preprocess