Restore CI compatibility gates

.github/workflows/ci.yml

@@ -262,7 +262,9 @@ jobs:
           # intentionally not a production or default-CI dependency.
           python bench/opencv_comparison/test_report.py
           # Fail the build if the .pyi type stubs drift from the runtime API.
-          python -m mypy.stubtest spatialrust --ignore-missing-stub
+          python -m mypy.stubtest spatialrust --ignore-missing-stub \
+            --allowlist crates/spatialrust-py/stubtest_allowlist.txt \
+            --ignore-unused-allowlist
 
   vision-platform-conformance:
     name: Vision conformance (${{ matrix.os }})

crates/spatialrust-ai/src/mock.rs

@@ -67,15 +67,10 @@ impl ModelSession for MockSession {
         self.info.validate_inputs(&inputs)?;
         // Output is always a newly allocated host `TensorBuffer`.
         if options.output_copy == CopyPolicy::Forbid {
-            return Err(AiError::CopyRequired {
-                direction: "output host",
-                name: "depth".into(),
-            });
+            return Err(AiError::CopyRequired { direction: "output host", name: "depth".into() });
         }
         match self.profile {
-            MockProfile::SyntheticDepth => {
-                run_synthetic_depth(inputs, options.input_copy)
-            }
+            MockProfile::SyntheticDepth => run_synthetic_depth(inputs, options.input_copy),
         }
     }
 }
@@ -110,10 +105,7 @@ impl MockProfile {
     }
 }
 
-fn run_synthetic_depth(
-    inputs: NamedTensors,
-    input_copy: CopyPolicy,
-) -> AiResult<NamedTensors> {
+fn run_synthetic_depth(inputs: NamedTensors, input_copy: CopyPolicy) -> AiResult<NamedTensors> {
     let input = inputs.get("images").ok_or_else(|| AiError::MissingInput("images".into()))?;
     let descriptor = input.descriptor();
     let shape = descriptor.shape();
@@ -131,10 +123,7 @@ fn run_synthetic_depth(
     }
     if !descriptor.is_c_contiguous() || descriptor.byte_offset() != 0 {
         if input_copy == CopyPolicy::Forbid {
-            return Err(AiError::CopyRequired {
-                direction: "input host",
-                name: "images".into(),
-            });
+            return Err(AiError::CopyRequired { direction: "input host", name: "images".into() });
         }
         return Err(AiError::Unsupported {
             backend: "mock".into(),
@@ -192,8 +181,8 @@ fn f32_values(tensor: &TensorBuffer) -> AiResult<Vec<f32>> {
 mod tests {
     use super::{MockInferenceBackend, MockProfile};
     use crate::{
-        AiError, CopyPolicy, InferenceBackend, ModelSession as _, ModelSource, NamedTensors,
-        RunOptions, SessionOptions,
+        AiError, CopyPolicy, InferenceBackend, ModelSource, NamedTensors, RunOptions,
+        SessionOptions,
     };
     use spatialrust_tensor::{DataType, Device, TensorBuffer, TensorDescriptor};
 
@@ -222,10 +211,7 @@ mod tests {
         let outputs = session
             .run_with_options(
                 inputs,
-                RunOptions {
-                    input_copy: CopyPolicy::Forbid,
-                    output_copy: CopyPolicy::Allow,
-                },
+                RunOptions { input_copy: CopyPolicy::Forbid, output_copy: CopyPolicy::Allow },
             )
             .unwrap();
         let depth = outputs.get("depth").unwrap();

crates/spatialrust-arrow/src/cdata.rs

@@ -149,9 +149,7 @@ pub unsafe fn import_point_cloud_c_data(
         )));
     }
     if schema.n_children < 0 || array.n_children < 0 || schema.n_children != array.n_children {
-        return Err(ArrowBridgeError::SchemaMismatch(
-            "schema/array child counts disagree".into(),
-        ));
+        return Err(ArrowBridgeError::SchemaMismatch("schema/array child counts disagree".into()));
     }
     let n = schema.n_children as usize;
     let mut point_schema = PointSchema::new();
@@ -178,8 +176,7 @@ fn export_schema(point_schema: &PointSchema) -> ArrowBridgeResult<ExportedArrowS
         .iter()
         .map(export_field_schema)
         .collect::<ArrowBridgeResult<Vec<_>>>()?;
-    let mut child_ptrs =
-        children.into_iter().map(Box::into_raw).collect::<Vec<*mut ArrowSchema>>();
+    let mut child_ptrs = children.into_iter().map(Box::into_raw).collect::<Vec<*mut ArrowSchema>>();
     let child_table = child_ptrs.as_mut_ptr();
     let n_children = child_ptrs.len() as i64;
     // Leak the vec table into private data; release rebuilds and frees it.
@@ -213,18 +210,12 @@ fn export_field_schema(field: &PointField) -> ArrowBridgeResult<Box<ArrowSchema>
             "Arrow C Data export currently supports scalar fields only".into(),
         ));
     }
-    let format = CString::new(dtype_format(field.dtype)?).map_err(|_| {
-        ArrowBridgeError::InvalidConfiguration("field format contained NUL".into())
-    })?;
-    let name = CString::new(field.name.as_str()).map_err(|_| {
-        ArrowBridgeError::InvalidConfiguration("field name contained NUL".into())
-    })?;
-    let private = Box::new(SchemaPrivate {
-        format,
-        name,
-        children_table: ptr::null_mut(),
-        n_children: 0,
-    });
+    let format = CString::new(dtype_format(field.dtype)?)
+        .map_err(|_| ArrowBridgeError::InvalidConfiguration("field format contained NUL".into()))?;
+    let name = CString::new(field.name.as_str())
+        .map_err(|_| ArrowBridgeError::InvalidConfiguration("field name contained NUL".into()))?;
+    let private =
+        Box::new(SchemaPrivate { format, name, children_table: ptr::null_mut(), n_children: 0 });
     Ok(Box::new(ArrowSchema {
         format: private.format.as_ptr(),
         name: private.name.as_ptr(),
@@ -429,9 +420,9 @@ fn format_dtype(format: &str) -> ArrowBridgeResult<DType> {
         "S" => Ok(DType::U16),
         "I" => Ok(DType::U32),
         "i" => Ok(DType::I32),
-        other => Err(ArrowBridgeError::SchemaMismatch(format!(
-            "unsupported Arrow format `{other}`"
-        ))),
+        other => {
+            Err(ArrowBridgeError::SchemaMismatch(format!("unsupported Arrow format `{other}`")))
+        }
     }
 }
 
@@ -511,11 +502,8 @@ unsafe extern "C" fn release_array(array: *mut ArrowArray) {
     if !array.private_data.is_null() {
         let private = Box::from_raw(array.private_data as *mut ArrayPrivate);
         if !private.children_table.is_null() && private.n_children > 0 {
-            let children = Vec::from_raw_parts(
-                private.children_table,
-                private.n_children,
-                private.n_children,
-            );
+            let children =
+                Vec::from_raw_parts(private.children_table, private.n_children, private.n_children);
             for child in children {
                 if !child.is_null() {
                     if let Some(release) = (*child).release {
@@ -526,11 +514,8 @@ unsafe extern "C" fn release_array(array: *mut ArrowArray) {
             }
         }
         if !private.buffers_table.is_null() && private.n_buffers > 0 {
-            let _ = Vec::from_raw_parts(
-                private.buffers_table as *mut *const c_void,
-                private.n_buffers,
-                private.n_buffers,
-            );
+            let _ =
+                Vec::from_raw_parts(private.buffers_table, private.n_buffers, private.n_buffers);
         }
         drop(private);
     }
@@ -561,7 +546,11 @@ mod tests {
         .unwrap();
         let (mut schema, mut array) = export_point_cloud_c_data(&cloud).unwrap();
         let imported = unsafe {
-            import_point_cloud_c_data(schema.as_mut_ptr(), array.as_mut_ptr(), SpatialMetadata::default())
+            import_point_cloud_c_data(
+                schema.as_mut_ptr(),
+                array.as_mut_ptr(),
+                SpatialMetadata::default(),
+            )
         }
         .unwrap();
         assert_eq!(imported.len(), 2);

crates/spatialrust-arrow/src/device.rs

@@ -5,7 +5,9 @@ use std::ptr;
 use spatialrust_core::{PointCloud, SpatialMetadata};
 
 use crate::{
-    cdata::{export_point_cloud_c_data, import_point_cloud_c_data, ArrowArray, ExportedArrowSchema},
+    cdata::{
+        export_point_cloud_c_data, import_point_cloud_c_data, ArrowArray, ExportedArrowSchema,
+    },
     ArrowBridgeError, ArrowBridgeResult,
 };
 
@@ -112,7 +114,9 @@ pub unsafe fn import_point_cloud_device_array(
 
 #[cfg(test)]
 mod tests {
-    use super::{export_point_cloud_device_array, import_point_cloud_device_array, ArrowDeviceType};
+    use super::{
+        export_point_cloud_device_array, import_point_cloud_device_array, ArrowDeviceType,
+    };
     use spatialrust_core::{
         PointBuffer, PointBufferSet, PointCloud, SpatialMetadata, StandardSchemas,
     };

crates/spatialrust-arrow/src/lib.rs

@@ -7,10 +7,10 @@
 
 #[cfg(feature = "arrow-c-data")]
 mod cdata;
-#[cfg(feature = "arrow-c-data")]
-mod error;
 #[cfg(feature = "arrow-c-device")]
 mod device;
+#[cfg(feature = "arrow-c-data")]
+mod error;
 #[cfg(feature = "arrow-c-stream")]
 mod stream;
 
@@ -19,12 +19,12 @@ pub use cdata::{
     export_point_cloud_c_data, import_point_cloud_c_data, ArrowArray, ArrowSchema,
     ExportedArrowArray, ExportedArrowSchema,
 };
-#[cfg(feature = "arrow-c-data")]
-pub use error::{ArrowBridgeError, ArrowBridgeResult};
 #[cfg(feature = "arrow-c-device")]
 pub use device::{
     export_point_cloud_device_array, import_point_cloud_device_array, ArrowDeviceArray,
     ArrowDeviceType, ExportedArrowDeviceArray,
 };
+#[cfg(feature = "arrow-c-data")]
+pub use error::{ArrowBridgeError, ArrowBridgeResult};
 #[cfg(feature = "arrow-c-stream")]
 pub use stream::{export_record_source_c_stream, ArrowArrayStream, ExportedArrowArrayStream};

crates/spatialrust-arrow/src/stream.rs

@@ -7,17 +7,23 @@ use std::{
 
 use spatialrust_records::SpatialRecordSource;
 
-use crate::{cdata::{export_point_cloud_c_data, ArrowArray, ArrowSchema}, ArrowBridgeResult};
+use crate::{
+    cdata::{export_point_cloud_c_data, ArrowArray, ArrowSchema},
+    ArrowBridgeResult,
+};
 
 /// Arrow C Stream Interface object.
 #[repr(C)]
 pub struct ArrowArrayStream {
     /// Fills `out` with the stream schema.
-    pub get_schema: Option<unsafe extern "C" fn(stream: *mut ArrowArrayStream, out: *mut ArrowSchema) -> i32>,
+    pub get_schema:
+        Option<unsafe extern "C" fn(stream: *mut ArrowArrayStream, out: *mut ArrowSchema) -> i32>,
     /// Fills `out` with the next array (`release=null` when exhausted).
-    pub get_next: Option<unsafe extern "C" fn(stream: *mut ArrowArrayStream, out: *mut ArrowArray) -> i32>,
+    pub get_next:
+        Option<unsafe extern "C" fn(stream: *mut ArrowArrayStream, out: *mut ArrowArray) -> i32>,
     /// Optional last-error message.
-    pub get_last_error: Option<unsafe extern "C" fn(stream: *mut ArrowArrayStream) -> *const c_char>,
+    pub get_last_error:
+        Option<unsafe extern "C" fn(stream: *mut ArrowArrayStream) -> *const c_char>,
     /// Release callback.
     pub release: Option<unsafe extern "C" fn(stream: *mut ArrowArrayStream)>,
     /// Implementation private data.
@@ -141,11 +147,9 @@ unsafe extern "C" fn stream_get_last_error(stream: *mut ArrowArrayStream) -> *co
         return ptr::null();
     }
     match private_mut(stream) {
-        Ok(private) => private
-            .last_error
-            .as_ref()
-            .map(|value| value.as_ptr())
-            .unwrap_or(ptr::null()),
+        Ok(private) => {
+            private.last_error.as_ref().map(|value| value.as_ptr()).unwrap_or(ptr::null())
+        }
         Err(_) => ptr::null(),
     }
 }
@@ -176,7 +180,9 @@ unsafe fn private_mut(stream: *mut ArrowArrayStream) -> Result<&'static mut Stre
     Ok(&mut *(stream.private_data as *mut StreamPrivate))
 }
 
-fn empty_cloud(schema: &spatialrust_core::PointSchema) -> ArrowBridgeResult<spatialrust_core::PointCloud> {
+fn empty_cloud(
+    schema: &spatialrust_core::PointSchema,
+) -> ArrowBridgeResult<spatialrust_core::PointCloud> {
     use spatialrust_core::{PointBuffer, PointBufferSet, PointCloud, SpatialMetadata};
     let mut buffers = PointBufferSet::new();
     for field in schema.fields() {
@@ -214,9 +220,7 @@ mod tests {
     use spatialrust_core::{
         PointBuffer, PointBufferSet, PointCloud, SpatialMetadata, StandardSchemas,
     };
-    use spatialrust_records::{
-        MemoryChunkSource, SchemaDescriptor, SchemaVersion,
-    };
+    use spatialrust_records::{MemoryChunkSource, SchemaDescriptor, SchemaVersion};
 
     #[test]
     fn stream_yields_chunked_clouds() {