antecedent-data 0.3.0

Causal data views and Arrow-backed adapters for the Antecedent causal inference engine; start with the `antecedent` crate
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

//! Cross-language Arrow load gate : measured copy behavior.
//!
//! Fixture: `conformance/gates/arrow_copy_fixture.json` (shared with Python).
//!
//! SPDX-License-Identifier: MIT OR Apache-2.0

#![cfg(feature = "arrow")]

use std::fs;
use std::path::PathBuf;
use std::sync::Arc;

use antecedent_data::{TableView, tabular_from_record_batch};
use arrow_array::{ArrayRef, Float64Array, RecordBatch};
use arrow_schema::{DataType, Field, Schema};
use serde_json::Value;

fn fixture_path() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("../../conformance/gates/arrow_copy_fixture.json")
}

fn fixture_batch() -> RecordBatch {
    let raw = fs::read_to_string(fixture_path()).expect("arrow_copy_fixture.json");
    let v: Value = serde_json::from_str(&raw).expect("parse fixture");
    let names = v["column_names"].as_array().expect("column_names");
    let cols = v["columns"].as_object().expect("columns");
    let fields: Vec<Field> =
        names.iter().map(|n| Field::new(n.as_str().unwrap(), DataType::Float64, false)).collect();
    let arrays: Vec<ArrayRef> = names
        .iter()
        .map(|n| {
            let name = n.as_str().unwrap();
            let values: Vec<f64> =
                cols[name].as_array().unwrap().iter().map(|x| x.as_f64().unwrap()).collect();
            Arc::new(Float64Array::from(values)) as ArrayRef
        })
        .collect();
    RecordBatch::try_new(Arc::new(Schema::new(fields)), arrays).unwrap()
}

#[test]
fn rust_arrow_load_reports_measured_copy() {
    let batch = fixture_batch();
    let expected_rows = 8usize;
    let loaded = tabular_from_record_batch(&batch).unwrap();
    assert_eq!(loaded.data.row_count(), expected_rows);
    assert_eq!(loaded.data.schema().len(), 3);
    assert!(loaded.bytes_copied > 0);
    assert!(!loaded.diagnostics.is_empty());
    assert!(
        loaded.diagnostics.entries.iter().any(|d| d.code.contains("materialize")),
        "expected materialization diagnostics"
    );
}