# Auto-generated. Do not edit.
from opendp._convert import *
from opendp._lib import *
from opendp.mod import *
from opendp.typing import *
[docs]
def make_cast(
TI: RuntimeTypeDescriptor,
TO: RuntimeTypeDescriptor
) -> Transformation:
"""Make a Transformation that casts a vector of data from type `TI` to type `TO`.
Failure to parse results in None, else Some<TO>.
:param TI: input data type to cast from
:type TI: RuntimeTypeDescriptor
:param TO: data type to cast into
:type TO: RuntimeTypeDescriptor
:return: A cast step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
TI = RuntimeType.parse(type_name=TI)
TO = RuntimeType.parse(type_name=TO)
# Convert arguments to c types.
TI = py_to_c(TI, c_type=ctypes.c_char_p)
TO = py_to_c(TO, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_cast
function.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(TI, TO), Transformation))
[docs]
def make_cast_default(
TI: RuntimeTypeDescriptor,
TO: RuntimeTypeDescriptor
) -> Transformation:
"""Make a Transformation that casts a vector of data from type `TI` to type `TO`. If cast fails, fill with default.
:param TI: input data type to cast from
:type TI: RuntimeTypeDescriptor
:param TO: data type to cast into
:type TO: RuntimeTypeDescriptor
:return: A cast_default step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
TI = RuntimeType.parse(type_name=TI)
TO = RuntimeType.parse(type_name=TO)
# Convert arguments to c types.
TI = py_to_c(TI, c_type=ctypes.c_char_p)
TO = py_to_c(TO, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_cast_default
function.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(TI, TO), Transformation))
[docs]
def make_is_equal(
value,
TI: RuntimeTypeDescriptor = None
) -> Transformation:
"""Make a Transformation that checks if each element is equal to `value`.
:param value: value to check against
:param TI: input data type
:type TI: RuntimeTypeDescriptor
:return: A is_equal step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
TI = RuntimeType.parse_or_infer(type_name=TI, public_example=value)
# Convert arguments to c types.
value = py_to_c(value, c_type=ctypes.c_void_p, type_name=TI)
TI = py_to_c(TI, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_is_equal
function.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(value, TI), Transformation))
[docs]
def make_is_null(
DIA: RuntimeTypeDescriptor
) -> Transformation:
"""Make a Transformation that checks if each element in a vector is null.
:param DIA: atomic input domain
:type DIA: RuntimeTypeDescriptor
:return: A is_null step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
DIA = RuntimeType.parse(type_name=DIA)
# Convert arguments to c types.
DIA = py_to_c(DIA, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_is_null
function.argtypes = [ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(DIA), Transformation))
[docs]
def make_cast_inherent(
TI: RuntimeTypeDescriptor,
TO: RuntimeTypeDescriptor
) -> Transformation:
"""Make a Transformation that casts a vector of data from type `TI` to a type that can represent nullity `TO`.
If cast fails, fill with `TO`'s null value.
:param TI: input data type to cast from
:type TI: RuntimeTypeDescriptor
:param TO: data type to cast into
:type TO: RuntimeTypeDescriptor
:return: A cast_inherent step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
TI = RuntimeType.parse(type_name=TI)
TO = RuntimeType.parse(type_name=TO)
# Convert arguments to c types.
TI = py_to_c(TI, c_type=ctypes.c_char_p)
TO = py_to_c(TO, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_cast_inherent
function.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(TI, TO), Transformation))
[docs]
def make_cast_metric(
MI: DatasetMetric,
MO: DatasetMetric,
T: RuntimeTypeDescriptor
) -> Transformation:
"""Make a Transformation that converts the dataset metric from type `MI` to type `MO`.
:param MI: input dataset metric
:type MI: DatasetMetric
:param MO: output dataset metric
:type MO: DatasetMetric
:param T: atomic type of data
:type T: RuntimeTypeDescriptor
:return: A cast_metric step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
MI = RuntimeType.parse(type_name=MI)
MO = RuntimeType.parse(type_name=MO)
T = RuntimeType.parse(type_name=T)
# Convert arguments to c types.
MI = py_to_c(MI, c_type=ctypes.c_char_p)
MO = py_to_c(MO, c_type=ctypes.c_char_p)
T = py_to_c(T, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_cast_metric
function.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(MI, MO, T), Transformation))
[docs]
def make_clamp(
lower,
upper,
DI: RuntimeTypeDescriptor = "VectorDomain<AllDomain<T>>",
M: RuntimeTypeDescriptor = "SymmetricDistance"
) -> Transformation:
"""Make a Transformation that clamps numeric data in Vec<`T`> between `lower` and `upper`. Set DI to AllDomain<T> for clamping aggregated values.
:param lower: If datum is less than lower, let datum be lower.
:param upper: If datum is greater than upper, let datum be upper.
:param DI: input domain. One of VectorDomain<AllDomain<_>> or AllDomain<_>.
:type DI: RuntimeTypeDescriptor
:param M: metric. Set to SymmetricDistance when clamping datasets, or AbsoluteDistance<_> when clamping aggregated scalars
:type M: RuntimeTypeDescriptor
:return: A clamp step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
DI = RuntimeType.parse(type_name=DI, generics=["T"])
M = RuntimeType.parse(type_name=M)
T = get_domain_atom_or_infer(DI, lower)
DI = DI.substitute(T=T)
# Convert arguments to c types.
lower = py_to_c(lower, c_type=ctypes.c_void_p, type_name=T)
upper = py_to_c(upper, c_type=ctypes.c_void_p, type_name=T)
DI = py_to_c(DI, c_type=ctypes.c_char_p)
M = py_to_c(M, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_clamp
function.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(lower, upper, DI, M), Transformation))
[docs]
def make_unclamp(
lower,
upper,
M: RuntimeTypeDescriptor,
T: RuntimeTypeDescriptor = "VectorDomain<IntervalDomain<T>>"
) -> Transformation:
"""Make a Transformation that unclamps a VectorDomain<IntervalDomain<T>> to a VectorDomain<AllDomain<T>>. Set DI to IntervalDomain<T> to work on scalars.
:param lower: Lower bound of the input data.
:param upper: Upper bound of the input data.
:param T: domain of data being unclamped
:type T: RuntimeTypeDescriptor
:param M: metric to use on the input and output spaces
:type M: RuntimeTypeDescriptor
:return: A unclamp step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
T = RuntimeType.parse_or_infer(type_name=T, public_example=lower)
M = RuntimeType.parse(type_name=M)
# Convert arguments to c types.
lower = py_to_c(lower, c_type=ctypes.c_void_p, type_name=T)
upper = py_to_c(upper, c_type=ctypes.c_void_p, type_name=T)
T = py_to_c(T, c_type=ctypes.c_char_p)
M = py_to_c(M, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_unclamp
function.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(lower, upper, T, M), Transformation))
[docs]
def make_count(
TIA: RuntimeTypeDescriptor,
TO: RuntimeTypeDescriptor = "i32"
) -> Transformation:
"""Make a Transformation that computes a count of the number of records in data.
:param TIA: Atomic Input Type. Input data is expected to be of the form Vec<TIA>.
:type TIA: RuntimeTypeDescriptor
:param TO: type of output integer
:type TO: RuntimeTypeDescriptor
:return: A count step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
TIA = RuntimeType.parse(type_name=TIA)
TO = RuntimeType.parse(type_name=TO)
# Convert arguments to c types.
TIA = py_to_c(TIA, c_type=ctypes.c_char_p)
TO = py_to_c(TO, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_count
function.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(TIA, TO), Transformation))
[docs]
def make_count_distinct(
TIA: RuntimeTypeDescriptor,
TO: RuntimeTypeDescriptor = "i32"
) -> Transformation:
"""Make a Transformation that computes a count of the number of unique, distinct records in data.
:param TIA: Atomic Input Type. Input data is expected to be of the form Vec<TIA>.
:type TIA: RuntimeTypeDescriptor
:param TO: Output Type. integer
:type TO: RuntimeTypeDescriptor
:return: A count_distinct step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
TIA = RuntimeType.parse(type_name=TIA)
TO = RuntimeType.parse(type_name=TO)
# Convert arguments to c types.
TIA = py_to_c(TIA, c_type=ctypes.c_char_p)
TO = py_to_c(TO, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_count_distinct
function.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(TIA, TO), Transformation))
[docs]
def make_count_by(
n: int,
MO: SensitivityMetric,
TI: RuntimeTypeDescriptor,
TO: RuntimeTypeDescriptor = "i32"
) -> Transformation:
"""Make a Transformation that computes the count of each unique value in data.
This assumes that the category set is unknown.
Use make_base_stability to release this query.
:param n: Number of records in input data.
:type n: int
:param MO: Output Metric.
:type MO: SensitivityMetric
:param TI: Input Type. Categorical/hashable input data type. Input data must be Vec<TI>.
:type TI: RuntimeTypeDescriptor
:param TO: Output Type. express counts in terms of this integral type
:type TO: RuntimeTypeDescriptor
:return: The carrier type is HashMap<TI, TO>- the counts for each unique data input.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
MO = RuntimeType.parse(type_name=MO)
TI = RuntimeType.parse(type_name=TI)
TO = RuntimeType.parse(type_name=TO)
# Convert arguments to c types.
n = py_to_c(n, c_type=ctypes.c_uint)
MO = py_to_c(MO, c_type=ctypes.c_char_p)
TI = py_to_c(TI, c_type=ctypes.c_char_p)
TO = py_to_c(TO, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_count_by
function.argtypes = [ctypes.c_uint, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(n, MO, TI, TO), Transformation))
[docs]
def make_count_by_categories(
categories: Any,
MO: SensitivityMetric,
TI: RuntimeTypeDescriptor = None,
TO: RuntimeTypeDescriptor = "i32"
) -> Transformation:
"""Make a Transformation that computes the number of times each category appears in the data.
This assumes that the category set is known.
:param categories: The set of categories to compute counts for.
:type categories: Any
:param MO: output sensitivity metric
:type MO: SensitivityMetric
:param TI: categorical/hashable input data type. Input data must be Vec<TI>.
:type TI: RuntimeTypeDescriptor
:param TO: express counts in terms of this integral type
:type TO: RuntimeTypeDescriptor
:return: A count_by_categories step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
MO = RuntimeType.parse(type_name=MO)
TI = RuntimeType.parse_or_infer(type_name=TI, public_example=next(iter(categories), None))
TO = RuntimeType.parse(type_name=TO)
# Convert arguments to c types.
categories = py_to_c(categories, c_type=AnyObjectPtr, type_name=RuntimeType(origin='Vec', args=[TI]))
MO = py_to_c(MO, c_type=ctypes.c_char_p)
TI = py_to_c(TI, c_type=ctypes.c_char_p)
TO = py_to_c(TO, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_count_by_categories
function.argtypes = [AnyObjectPtr, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(categories, MO, TI, TO), Transformation))
[docs]
def make_split_lines(
) -> Transformation:
"""Make a Transformation that takes a string and splits it into a Vec<String> of its lines.
:return: A split_lines step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# No type arguments to standardize.
# No arguments to convert to c types.
# Call library function.
function = lib.opendp_trans__make_split_lines
function.argtypes = []
function.restype = FfiResult
return c_to_py(unwrap(function(), Transformation))
[docs]
def make_split_records(
separator: str
) -> Transformation:
"""Make a Transformation that splits each record in a Vec<String> into a Vec<Vec<String>>.
:param separator: The token(s) that separate entries in each record.
:type separator: str
:return: A split_records step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# No type arguments to standardize.
# Convert arguments to c types.
separator = py_to_c(separator, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_split_records
function.argtypes = [ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(separator), Transformation))
[docs]
def make_create_dataframe(
col_names: Any,
K: RuntimeTypeDescriptor = None
) -> Transformation:
"""Make a Transformation that constructs a dataframe from a Vec<Vec<String>>.
:param col_names: Column names for each record entry.
:type col_names: Any
:param K: categorical/hashable data type of column names
:type K: RuntimeTypeDescriptor
:return: A create_dataframe step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
K = RuntimeType.parse_or_infer(type_name=K, public_example=next(iter(col_names), None))
# Convert arguments to c types.
col_names = py_to_c(col_names, c_type=AnyObjectPtr, type_name=RuntimeType(origin='Vec', args=[K]))
K = py_to_c(K, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_create_dataframe
function.argtypes = [AnyObjectPtr, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(col_names, K), Transformation))
[docs]
def make_split_dataframe(
separator: str,
col_names: Any,
K: RuntimeTypeDescriptor = None
) -> Transformation:
"""Make a Transformation that splits each record in a Vec<String> into a Vec<Vec<String>>,
and loads the resulting table into a dataframe keyed by `col_names`.
:param separator: The token(s) that separate entries in each record.
:type separator: str
:param col_names: Column names for each record entry.
:type col_names: Any
:param K: categorical/hashable data type of column names
:type K: RuntimeTypeDescriptor
:return: A split_dataframe step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
K = RuntimeType.parse_or_infer(type_name=K, public_example=next(iter(col_names), None))
# Convert arguments to c types.
separator = py_to_c(separator, c_type=ctypes.c_char_p)
col_names = py_to_c(col_names, c_type=AnyObjectPtr, type_name=RuntimeType(origin='Vec', args=[K]))
K = py_to_c(K, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_split_dataframe
function.argtypes = [ctypes.c_char_p, AnyObjectPtr, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(separator, col_names, K), Transformation))
[docs]
def make_parse_column(
key,
T: RuntimeTypeDescriptor,
impute: bool = True,
K: RuntimeTypeDescriptor = None
) -> Transformation:
"""Make a Transformation that parses the `key` column of a dataframe as `T`.
:param key: name of column to select from dataframe and parse
:param impute: Enable to impute values that fail to parse. If false, raise an error if parsing fails.
:type impute: bool
:param K: categorical/hashable data type of the key/column name
:type K: RuntimeTypeDescriptor
:param T: data type to parse into
:type T: RuntimeTypeDescriptor
:return: A parse_column step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
K = RuntimeType.parse_or_infer(type_name=K, public_example=key)
T = RuntimeType.parse(type_name=T)
# Convert arguments to c types.
key = py_to_c(key, c_type=ctypes.c_void_p, type_name=K)
impute = py_to_c(impute, c_type=ctypes.c_bool)
K = py_to_c(K, c_type=ctypes.c_char_p)
T = py_to_c(T, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_parse_column
function.argtypes = [ctypes.c_void_p, ctypes.c_bool, ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(key, impute, K, T), Transformation))
[docs]
def make_select_column(
key,
T: RuntimeTypeDescriptor,
K: RuntimeTypeDescriptor = None
) -> Transformation:
"""Make a Transformation that retrieves the column `key` from a dataframe as Vec<`T`>.
:param key: categorical/hashable data type of the key/column name
:param K: data type of the key
:type K: RuntimeTypeDescriptor
:param T: data type to downcast to
:type T: RuntimeTypeDescriptor
:return: A select_column step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
K = RuntimeType.parse_or_infer(type_name=K, public_example=key)
T = RuntimeType.parse(type_name=T)
# Convert arguments to c types.
key = py_to_c(key, c_type=ctypes.c_void_p, type_name=K)
K = py_to_c(K, c_type=ctypes.c_char_p)
T = py_to_c(T, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_select_column
function.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(key, K, T), Transformation))
[docs]
def make_identity(
M: DatasetMetric,
T: RuntimeTypeDescriptor
) -> Transformation:
"""Make a Transformation that simply passes the data through.
:param M: dataset metric
:type M: DatasetMetric
:param T: Type of data passed to the identity function.
:type T: RuntimeTypeDescriptor
:return: A identity step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
M = RuntimeType.parse(type_name=M)
T = RuntimeType.parse(type_name=T)
# Convert arguments to c types.
M = py_to_c(M, c_type=ctypes.c_char_p)
T = py_to_c(T, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_identity
function.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(M, T), Transformation))
[docs]
def make_impute_constant(
constant,
DA: RuntimeTypeDescriptor = "OptionNullDomain<AllDomain<T>>"
) -> Transformation:
"""Make a Transformation that replaces null/None data with `constant`.
By default, the input type is Vec<Option<`T`>>, as emitted by make_cast.
Set DA to InherentNullDomain<AllDomain<T>> for imputing on types that have an inherent representation of nullity, like floats.
:param constant: Value to replace nulls with.
:param DA: domain of data being imputed. This is OptionNullDomain<AllDomain<T>> or InherentNullDomain<AllDomain<T>>
:type DA: RuntimeTypeDescriptor
:return: A impute_constant step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
DA = RuntimeType.parse(type_name=DA, generics=["T"])
T = get_domain_atom_or_infer(DA, constant)
DA = DA.substitute(T=T)
# Convert arguments to c types.
constant = py_to_c(constant, c_type=ctypes.c_void_p, type_name=T)
DA = py_to_c(DA, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_impute_constant
function.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(constant, DA), Transformation))
[docs]
def make_bounded_mean(
lower,
upper,
n: int,
T: RuntimeTypeDescriptor = None
) -> Transformation:
"""Make a Transformation that computes the mean of bounded data.
Use make_clamp to bound data.
:param lower: Lower bound of input data.
:param upper: Upper bound of input data.
:param n: Number of records in input data.
:type n: int
:param T: atomic data type
:type T: RuntimeTypeDescriptor
:return: A bounded_mean step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
T = RuntimeType.parse_or_infer(type_name=T, public_example=lower)
# Convert arguments to c types.
lower = py_to_c(lower, c_type=ctypes.c_void_p, type_name=T)
upper = py_to_c(upper, c_type=ctypes.c_void_p, type_name=T)
n = py_to_c(n, c_type=ctypes.c_uint)
T = py_to_c(T, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_bounded_mean
function.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(lower, upper, n, T), Transformation))
[docs]
def make_bounded_sum(
lower,
upper,
T: RuntimeTypeDescriptor = None
) -> Transformation:
"""Make a Transformation that computes the sum of bounded data.
Use make_clamp to bound data.
:param lower: Lower bound of input data.
:param upper: Upper bound of input data.
:param T: atomic type of data
:type T: RuntimeTypeDescriptor
:return: A bounded_sum step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
T = RuntimeType.parse_or_infer(type_name=T, public_example=lower)
# Convert arguments to c types.
lower = py_to_c(lower, c_type=ctypes.c_void_p, type_name=T)
upper = py_to_c(upper, c_type=ctypes.c_void_p, type_name=T)
T = py_to_c(T, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_bounded_sum
function.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(lower, upper, T), Transformation))
[docs]
def make_bounded_sum_n(
lower,
upper,
n: int,
T: RuntimeTypeDescriptor = None
) -> Transformation:
"""Make a Transformation that computes the sum of bounded data with known length.
This uses a restricted-sensitivity proof that takes advantage of known N for better utility.
Use make_clamp to bound data.
:param lower: Lower bound of input data.
:param upper: Upper bound of input data.
:param n: Number of records in input data.
:type n: int
:param T: atomic type of data
:type T: RuntimeTypeDescriptor
:return: A bounded_sum_n step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
T = RuntimeType.parse_or_infer(type_name=T, public_example=lower)
# Convert arguments to c types.
lower = py_to_c(lower, c_type=ctypes.c_void_p, type_name=T)
upper = py_to_c(upper, c_type=ctypes.c_void_p, type_name=T)
n = py_to_c(n, c_type=ctypes.c_uint)
T = py_to_c(T, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_bounded_sum_n
function.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(lower, upper, n, T), Transformation))
[docs]
def make_bounded_variance(
lower,
upper,
n: int,
ddof: int = 1,
T: RuntimeTypeDescriptor = None
) -> Transformation:
"""Make a Transformation that computes the variance of bounded data.
Use make_clamp to bound data.
:param lower: Lower bound of input data.
:param upper: Upper bound of input data.
:param n: Number of records in input data.
:type n: int
:param ddof: Delta degrees of freedom. Set to 0 if not a sample, 1 for sample estimate.
:type ddof: int
:param T: atomic data type
:type T: RuntimeTypeDescriptor
:return: A bounded_variance step.
:rtype: Transformation
:raises AssertionError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type-argument fails to parse
:raises OpenDPException: packaged error from the core OpenDP library
"""
# Standardize type arguments.
T = RuntimeType.parse_or_infer(type_name=T, public_example=lower)
# Convert arguments to c types.
lower = py_to_c(lower, c_type=ctypes.c_void_p, type_name=T)
upper = py_to_c(upper, c_type=ctypes.c_void_p, type_name=T)
n = py_to_c(n, c_type=ctypes.c_uint)
ddof = py_to_c(ddof, c_type=ctypes.c_uint)
T = py_to_c(T, c_type=ctypes.c_char_p)
# Call library function.
function = lib.opendp_trans__make_bounded_variance
function.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.c_uint, ctypes.c_char_p]
function.restype = FfiResult
return c_to_py(unwrap(function(lower, upper, n, ddof, T), Transformation))
