# Auto-generated. Do not edit.
from opendp._convert import *
from opendp._lib import *
from opendp.mod import *
from opendp.typing import *
__all__ = [
"_error_free",
"_function_free",
"_measurement_free",
"_transformation_free",
"function_eval",
"measurement_check",
"measurement_function",
"measurement_input_carrier_type",
"measurement_input_distance_type",
"measurement_input_domain",
"measurement_input_metric",
"measurement_invoke",
"measurement_map",
"measurement_output_distance_type",
"measurement_output_measure",
"queryable_eval",
"queryable_query_type",
"transformation_check",
"transformation_function",
"transformation_input_carrier_type",
"transformation_input_distance_type",
"transformation_input_domain",
"transformation_input_metric",
"transformation_invoke",
"transformation_map",
"transformation_output_distance_type",
"transformation_output_domain",
"transformation_output_metric"
]
@versioned
def _error_free(
this: FfiError
) -> bool:
"""Internal function. Free the memory associated with `error`.
[_error_free in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn._error_free.html)
:param this:
:type this: FfiError
:return: A boolean, where true indicates successful free
:rtype: bool
:raises TypeError: if an argument's type differs from the expected type
:raises UnknownTypeError: if a type argument fails to parse
"""
# No type arguments to standardize.
# Convert arguments to c types.
c_this = this
# Call library function.
lib_function = lib.opendp_core___error_free
lib_function.argtypes = [ctypes.POINTER(FfiError)]
lib_function.restype = ctypes.c_bool
output = c_to_py(lib_function(c_this))
return output
@versioned
def _function_free(
this: Function
):
"""Internal function. Free the memory associated with `this`.
[_function_free in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn._function_free.html)
:param this:
:type this: Function
:raises TypeError: 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.
c_this = this
# Call library function.
lib_function = lib.opendp_core___function_free
lib_function.argtypes = [Function]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this), ctypes.c_void_p))
return output
@versioned
def _measurement_free(
this: Measurement
):
"""Internal function. Free the memory associated with `this`.
[_measurement_free in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn._measurement_free.html)
:param this:
:type this: Measurement
:raises TypeError: 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.
c_this = this
# Call library function.
lib_function = lib.opendp_core___measurement_free
lib_function.argtypes = [Measurement]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this), ctypes.c_void_p))
return output
@versioned
def _transformation_free(
this: Transformation
):
"""Internal function. Free the memory associated with `this`.
[_transformation_free in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn._transformation_free.html)
:param this:
:type this: Transformation
:raises TypeError: 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.
c_this = this
# Call library function.
lib_function = lib.opendp_core___transformation_free
lib_function.argtypes = [Transformation]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this), ctypes.c_void_p))
return output
[docs]
@versioned
def function_eval(
this: Function,
arg: Any,
TI: str = None
) -> Any:
"""Eval the `function` with `arg`.
[function_eval in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.function_eval.html)
:param this: Function to invoke.
:type this: Function
:param arg: Input data to supply to the measurement. A member of the measurement's input domain.
:type arg: Any
:param TI: Input Type.
:type TI: str
:rtype: Any
:raises TypeError: 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.
c_this = py_to_c(this, c_type=Function, type_name=None)
c_arg = py_to_c(arg, c_type=AnyObjectPtr, type_name=parse_or_infer(TI, arg))
c_TI = py_to_c(TI, c_type=ctypes.c_char_p, type_name=None)
# Call library function.
lib_function = lib.opendp_core__function_eval
lib_function.argtypes = [Function, AnyObjectPtr, ctypes.c_char_p]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this, c_arg, c_TI), AnyObjectPtr))
return output
[docs]
@versioned
def measurement_check(
measurement: Measurement,
distance_in: Any,
distance_out: Any
):
"""Check the privacy relation of the `measurement` at the given `d_in`, `d_out`
[measurement_check in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.measurement_check.html)
:param measurement: Measurement to check the privacy relation of.
:type measurement: Measurement
:param distance_in:
:type distance_in: Any
:param distance_out:
:type distance_out: Any
:return: True indicates that the relation passed at the given distance.
:raises TypeError: 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.
c_measurement = py_to_c(measurement, c_type=Measurement, type_name=None)
c_distance_in = py_to_c(distance_in, c_type=AnyObjectPtr, type_name=measurement_input_distance_type(measurement))
c_distance_out = py_to_c(distance_out, c_type=AnyObjectPtr, type_name=measurement_output_distance_type(measurement))
# Call library function.
lib_function = lib.opendp_core__measurement_check
lib_function.argtypes = [Measurement, AnyObjectPtr, AnyObjectPtr]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_measurement, c_distance_in, c_distance_out), BoolPtr))
return output
[docs]
@versioned
def measurement_function(
this: Measurement
) -> Function:
"""Get the function from a measurement.
[measurement_function in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.measurement_function.html)
:param this: The measurement to retrieve the value from.
:type this: Measurement
:rtype: Function
:raises TypeError: 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.
c_this = py_to_c(this, c_type=Measurement, type_name=None)
# Call library function.
lib_function = lib.opendp_core__measurement_function
lib_function.argtypes = [Measurement]
lib_function.restype = FfiResult
output = unwrap(lib_function(c_this), Function)
return output
[docs]
@versioned
def measurement_input_domain(
this: Measurement
):
"""Get the input domain from a `measurement`.
[measurement_input_domain in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.measurement_input_domain.html)
:param this: The measurement to retrieve the value from.
:type this: Measurement
:raises TypeError: 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.
c_this = py_to_c(this, c_type=Measurement, type_name=None)
# Call library function.
lib_function = lib.opendp_core__measurement_input_domain
lib_function.argtypes = [Measurement]
lib_function.restype = FfiResult
output = unwrap(lib_function(c_this), Domain)
return output
[docs]
@versioned
def measurement_invoke(
this: Measurement,
arg: Any
) -> Any:
"""Invoke the `measurement` with `arg`. Returns a differentially private release.
[measurement_invoke in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.measurement_invoke.html)
:param this: Measurement to invoke.
:type this: Measurement
:param arg: Input data to supply to the measurement. A member of the measurement's input domain.
:type arg: Any
:rtype: Any
:raises TypeError: 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.
c_this = py_to_c(this, c_type=Measurement, type_name=None)
c_arg = py_to_c(arg, c_type=AnyObjectPtr, type_name=measurement_input_carrier_type(this))
# Call library function.
lib_function = lib.opendp_core__measurement_invoke
lib_function.argtypes = [Measurement, AnyObjectPtr]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this, c_arg), AnyObjectPtr))
return output
[docs]
@versioned
def measurement_map(
measurement: Measurement,
distance_in: Any
) -> Any:
"""Use the `measurement` to map a given `d_in` to `d_out`.
[measurement_map in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.measurement_map.html)
:param measurement: Measurement to check the map distances with.
:type measurement: Measurement
:param distance_in: Distance in terms of the input metric.
:type distance_in: Any
:rtype: Any
:raises TypeError: 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.
c_measurement = py_to_c(measurement, c_type=Measurement, type_name=None)
c_distance_in = py_to_c(distance_in, c_type=AnyObjectPtr, type_name=measurement_input_distance_type(measurement))
# Call library function.
lib_function = lib.opendp_core__measurement_map
lib_function.argtypes = [Measurement, AnyObjectPtr]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_measurement, c_distance_in), AnyObjectPtr))
return output
[docs]
@versioned
def measurement_output_distance_type(
this: Measurement
) -> str:
"""Get the output distance type of `measurement`.
[measurement_output_distance_type in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.measurement_output_distance_type.html)
:param this: The measurement to retrieve the type from.
:type this: Measurement
:rtype: str
:raises TypeError: 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.
c_this = py_to_c(this, c_type=Measurement, type_name=None)
# Call library function.
lib_function = lib.opendp_core__measurement_output_distance_type
lib_function.argtypes = [Measurement]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this), ctypes.c_char_p))
return output
[docs]
@versioned
def measurement_output_measure(
this: Measurement
):
"""Get the output domain from a `measurement`.
[measurement_output_measure in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.measurement_output_measure.html)
:param this: The measurement to retrieve the value from.
:type this: Measurement
:raises TypeError: 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.
c_this = py_to_c(this, c_type=Measurement, type_name=None)
# Call library function.
lib_function = lib.opendp_core__measurement_output_measure
lib_function.argtypes = [Measurement]
lib_function.restype = FfiResult
output = unwrap(lib_function(c_this), Measure)
return output
[docs]
@versioned
def queryable_eval(
queryable: Any,
query: Any
) -> Any:
"""Invoke the `queryable` with `query`. Returns a differentially private release.
[queryable_eval in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.queryable_eval.html)
:param queryable: Queryable to eval.
:type queryable: Any
:param query: Input data to supply to the measurement. A member of the measurement's input domain.
:type query: Any
:rtype: Any
:raises TypeError: 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.
c_queryable = py_to_c(queryable, c_type=AnyObjectPtr, type_name=None)
c_query = py_to_c(query, c_type=AnyObjectPtr, type_name=queryable_query_type(queryable))
# Call library function.
lib_function = lib.opendp_core__queryable_eval
lib_function.argtypes = [AnyObjectPtr, AnyObjectPtr]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_queryable, c_query), AnyObjectPtr))
return output
[docs]
@versioned
def queryable_query_type(
this: Any
) -> str:
"""Get the query type of `queryable`.
[queryable_query_type in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.queryable_query_type.html)
:param this: The queryable to retrieve the query type from.
:type this: Any
:rtype: str
:raises TypeError: 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.
c_this = py_to_c(this, c_type=AnyObjectPtr, type_name=None)
# Call library function.
lib_function = lib.opendp_core__queryable_query_type
lib_function.argtypes = [AnyObjectPtr]
lib_function.restype = FfiResult
output = c_to_py(unwrap(lib_function(c_this), ctypes.c_char_p))
return output
[docs]
@versioned
def transformation_input_domain(
this: Transformation
):
"""Get the input domain from a `transformation`.
[transformation_input_domain in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.transformation_input_domain.html)
:param this: The transformation to retrieve the value from.
:type this: Transformation
:raises TypeError: 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.
c_this = py_to_c(this, c_type=Transformation, type_name=None)
# Call library function.
lib_function = lib.opendp_core__transformation_input_domain
lib_function.argtypes = [Transformation]
lib_function.restype = FfiResult
output = unwrap(lib_function(c_this), Domain)
return output
[docs]
@versioned
def transformation_output_domain(
this: Transformation
):
"""Get the output domain from a `transformation`.
[transformation_output_domain in Rust documentation.](https://docs.rs/opendp/latest/opendp/core/fn.transformation_output_domain.html)
:param this: The transformation to retrieve the value from.
:type this: Transformation
:raises TypeError: 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.
c_this = py_to_c(this, c_type=Transformation, type_name=None)
# Call library function.
lib_function = lib.opendp_core__transformation_output_domain
lib_function.argtypes = [Transformation]
lib_function.restype = FfiResult
output = unwrap(lib_function(c_this), Domain)
return output
