opendp 0.14.2-dev.20260401.2

A library of differential privacy algorithms for the statistical analysis of sensitive private data.
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use std::sync::Arc;

#[cfg(feature = "ffi")]
use polars::series::Series;
use polars::{
    error::{PolarsResult, polars_bail, polars_err},
    prelude::{AnonymousColumnsUdf, Column, ColumnsUdf, Expr},
};
use polars_plan::prelude::FunctionOptions;
use serde::{Deserialize, Serialize};

use crate::{
    core::{Measurement, MetricSpace},
    domains::{ExprDomain, ExprPlan, WildExprDomain},
    error::Fallible,
    measurements::{
        PrivateExpr,
        expr_noise::{NoiseExprMeasure, NoiseShim},
    },
    metrics::L01InfDistance,
    polars::{OpenDPPlugin, apply_plugin, match_shim},
    transformations::{StableExpr, traits::UnboundedMetric},
};

macro_rules! new_make_expr_counting_query {
    ($plugin:ident, $name:literal, $stable_method:ident, $dp_method:ident, $constructor:ident) => {
        #[derive(Clone, Serialize, Deserialize)]
        pub(crate) struct $plugin;
        impl ColumnsUdf for $plugin {
            // makes it possible to downcast the AnonymousFunction trait object back to Self
            fn as_any(&self) -> &dyn std::any::Any {
                self
            }

            fn call_udf(&self, _: &mut [Column]) -> PolarsResult<Column> {
                polars_bail!(InvalidOperation: "OpenDP expressions must be passed through make_private_lazyframe to be executed.")
            }
        }

        impl AnonymousColumnsUdf for $plugin {
            fn as_column_udf(self: Arc<Self>) -> Arc<dyn ColumnsUdf> {
                self
            }

            fn deep_clone(self: Arc<Self>) -> Arc<dyn AnonymousColumnsUdf> {
                Arc::new(Arc::unwrap_or_clone(self))
            }

            fn get_field(&self, _: &polars::prelude::Schema, fields: &[polars::prelude::Field]) -> PolarsResult<polars::prelude::Field> {
                <&[polars::prelude::Field; 1]>::try_from(fields).map_err(|_| polars_err!(InvalidOperation: "{} expects one column", Self::NAME)).map(|[x]| x.clone())
            }
        }

        impl OpenDPPlugin for $plugin {
            const NAME: &'static str = $name;
            #[cfg(feature = "ffi")]
            const SHIM: bool = true;
            fn function_options() -> FunctionOptions {
                FunctionOptions::aggregation()
            }
        }

        pub fn $constructor<MI: 'static + UnboundedMetric, MO: NoiseExprMeasure>(
            input_domain: WildExprDomain,
            input_metric: L01InfDistance<MI>,
            output_measure: MO,
            expr: Expr,
            global_scale: Option<f64>,
        ) -> Fallible<Measurement<WildExprDomain, L01InfDistance<MI>, MO, ExprPlan>>
        where
            Expr: StableExpr<L01InfDistance<MI>, L01InfDistance<MI>> + PrivateExpr<L01InfDistance<MI>, MO>,
            (ExprDomain, MO::Metric): MetricSpace,
        {
            let Some([input, scale]) = match_shim::<$plugin, _>(&expr)? else {
                return fallible!(MakeMeasurement, "Expected {} function", $plugin::NAME);
            };

            apply_plugin(vec![input.$stable_method(), scale], expr, NoiseShim).make_private(
                input_domain.clone(),
                input_metric,
                output_measure,
                global_scale,
            )
        }

        #[cfg(feature = "ffi")]
        #[pyo3_polars::derive::polars_expr(output_type=Null)]
        fn $dp_method(_: &[Series]) -> PolarsResult<Series> {
            polars_bail!(InvalidOperation: "OpenDP expressions must be passed through make_private_lazyframe to be executed.")
        }

    }
}

new_make_expr_counting_query!(DPLenShim, "dp_len", len, dp_len, make_expr_dp_len);
new_make_expr_counting_query!(DPCountShim, "dp_count", count, dp_count, make_expr_dp_count);
new_make_expr_counting_query!(
    DPNullCountShim,
    "dp_null_count",
    null_count,
    dp_null_count,
    make_expr_dp_null_count
);
new_make_expr_counting_query!(
    DPNUniqueShim,
    "dp_n_unique",
    n_unique,
    dp_n_unique,
    make_expr_dp_n_unique
);