statsig-python-core 0.18.0__tar.gz → 0.18.1__tar.gz

{statsig_python_core-0.18.0 → statsig_python_core-0.18.1}/Cargo.lock

@@ -2869,7 +2869,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.18.0"
+version = "0.18.1"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2961,7 +2961,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.18.0"
+version = "0.18.1"
 dependencies = [
  "async-trait",
  "napi",
@@ -2975,7 +2975,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.18.0"
+version = "0.18.1"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -2989,7 +2989,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.18.0"
+version = "0.18.1"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3038,7 +3038,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.18.0"
+version = "0.18.1"
 dependencies = [
  "async-trait",
  "parking_lot",
@@ -3051,7 +3051,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.18.0"
+version = "0.18.1"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.18.0 → statsig_python_core-0.18.1}/Cargo.toml

@@ -18,7 +18,7 @@ exclude = [
 [workspace.package]
 edition = "2021"
 license = "ISC"
-version = "0.18.0"
+version = "0.18.1"
 homepage = "https://statsig.com/"
 authors = ["Statsig", "Daniel Loomb <daniel@statsig.com>"]
 readme = "README.md"

{statsig_python_core-0.18.0 → statsig_python_core-0.18.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statsig_python_core
-Version: 0.18.0
+Version: 0.18.1
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{statsig_python_core-0.18.0 → statsig_python_core-0.18.1}/py_src/statsig_python_core/statsig.py

@@ -85,7 +85,7 @@ class Statsig(StatsigBasePy):
         name: str,
         options: Optional[FeatureGateEvaluationOptions] = None,
     ) -> FeatureGate:
-        raw = super()._INTERNAL_get_feature_gate_as_dict(user, name, options)
+        raw = super()._INTERNAL_get_feature_gate(user, name, options)
         return FeatureGate(name, raw)
 
     def get_dynamic_config(
@@ -94,7 +94,7 @@ class Statsig(StatsigBasePy):
         name: str,
         options: Optional[DynamicConfigEvaluationOptions] = None,
     ) -> DynamicConfig:
-        raw = super()._INTERNAL_get_dynamic_config_as_dict(user, name, options)
+        raw = super()._INTERNAL_get_dynamic_config(user, name, options)
         return DynamicConfig(name, raw)
 
     def get_experiment(

{statsig_python_core-0.18.0 → statsig_python_core-0.18.1}/py_src/statsig_python_core/statsig_python_core.pyi

@@ -178,13 +178,11 @@ class StatsigBasePy:
     def shutdown(self) -> typing.Any: ...
     def log_event(self, user: StatsigUser, event_name: builtins.str, value: typing.Optional[typing.Any] = None, metadata: typing.Optional[dict] = None) -> None: ...
     def check_gate(self, user: StatsigUser, name: builtins.str, options: typing.Optional[FeatureGateEvaluationOptions] = None) -> builtins.bool: ...
-    def _INTERNAL_get_feature_gate(self, user: StatsigUser, name: builtins.str, options: typing.Optional[FeatureGateEvaluationOptions] = None) -> builtins.str: ...
-    def _INTERNAL_get_feature_gate_as_dict(self, user: StatsigUser, name: builtins.str, options: typing.Optional[FeatureGateEvaluationOptions] = None) -> dict: ...
+    def _INTERNAL_get_feature_gate(self, user: StatsigUser, name: builtins.str, options: typing.Optional[FeatureGateEvaluationOptions] = None) -> dict: ...
     def manually_log_gate_exposure(self, user: StatsigUser, name: builtins.str) -> None: ...
-    def _INTERNAL_get_dynamic_config(self, user: StatsigUser, name: builtins.str, options: typing.Optional[DynamicConfigEvaluationOptions] = None) -> builtins.str: ...
-    def _INTERNAL_get_dynamic_config_as_dict(self, user: StatsigUser, name: builtins.str, options: typing.Optional[DynamicConfigEvaluationOptions] = None) -> dict: ...
+    def _INTERNAL_get_dynamic_config(self, user: StatsigUser, name: builtins.str, options: typing.Optional[DynamicConfigEvaluationOptions] = None) -> dict: ...
     def manually_log_dynamic_config_exposure(self, user: StatsigUser, name: builtins.str) -> None: ...
-    def _INTERNAL_get_experiment(self, user: StatsigUser, name: builtins.str, options: typing.Optional[ExperimentEvaluationOptions] = None) -> builtins.str: ...
+    def _INTERNAL_get_experiment(self, user: StatsigUser, name: builtins.str, options: typing.Optional[ExperimentEvaluationOptions] = None) -> dict: ...
     def manually_log_experiment_exposure(self, user: StatsigUser, name: builtins.str) -> None: ...
     def _INTERNAL_get_layer(self, user: StatsigUser, name: builtins.str, options: typing.Optional[LayerEvaluationOptions] = None) -> builtins.str: ...
     def _INTERNAL_log_layer_param_exposure(self, raw: builtins.str, param_name: builtins.str) -> None: ...

{statsig_python_core-0.18.0 → statsig_python_core-0.18.1}/py_src/statsig_python_core/statsig_types.py

@@ -160,9 +160,9 @@ class DynamicConfig(BaseConfigEvaluation):
 class Experiment(BaseConfigEvaluation):
     group_name: Optional[str]
 
-    def __init__(self, name: str, raw: str):
+    def __init__(self, name: str, raw: dict):
         try:
-            data = json.loads(raw) or {}
+            data = raw or {}
             super().__init__(name, data, "Experiment")
             self.group_name = data.get("groupName")
         except Exception as error:

{statsig_python_core-0.18.0 → statsig_python_core-0.18.1}/statsig-pyo3/src/lib.rs

@@ -3,6 +3,7 @@ mod interned_store_py;
 mod observability_client_base_py;
 mod output_logger_provider_base_py;
 mod pyo_utils;
+mod raw_evaluation_compat_py;
 mod safe_gil;
 mod statsig_base_py;
 mod statsig_metadata_py;

{statsig_python_core-0.18.0 → statsig_python_core-0.18.1}/statsig-pyo3/src/pyo_utils.rs

@@ -62,16 +62,6 @@ pub fn map_to_py_dict(py: Python, map: &HashMap<String, Value>) -> Py<PyAny> {
     };
 }
 
-pub fn map_to_py_dict_direct(py: Python, map: &HashMap<String, Value>) -> PyResult<Py<PyDict>> {
-    let py_dict = PyDict::new(py);
-
-    for (key, value) in map {
-        set_json_value_in_dict(py, &py_dict, key, value)?;
-    }
-
-    Ok(py_dict.unbind())
-}
-
 pub fn py_list_to_list(py_list: &Bound<PyList>) -> PyResult<Vec<String>> {
     let mut converted_list = Vec::new();
     for value in py_list {
@@ -111,85 +101,6 @@ pub fn list_of_values_to_py_list(py: Python, list: &Vec<Value>) -> PyResult<Py<P
     Ok(py_list.into())
 }
 
-fn json_array_to_py_list(py: Python, values: &Vec<Value>) -> PyResult<Py<PyAny>> {
-    let py_list = PyList::empty(py);
-
-    for value in values {
-        append_json_value(py, &py_list, value)?;
-    }
-
-    Ok(py_list.unbind().into())
-}
-
-fn json_object_to_py_dict(py: Python, map: &serde_json::Map<String, Value>) -> PyResult<Py<PyAny>> {
-    let py_dict = PyDict::new(py);
-
-    for (key, value) in map {
-        set_json_value_in_dict(py, &py_dict, key, value)?;
-    }
-
-    Ok(py_dict.unbind().into())
-}
-
-fn set_json_value_in_dict(
-    py: Python,
-    py_dict: &Bound<PyDict>,
-    key: &str,
-    value: &Value,
-) -> PyResult<()> {
-    match value {
-        Value::Null => py_dict.set_item(key, py.None())?,
-        Value::Bool(v) => py_dict.set_item(key, *v)?,
-        Value::Number(v) => set_number_in_dict(py_dict, key, v)?,
-        Value::String(v) => py_dict.set_item(key, v)?,
-        Value::Array(v) => py_dict.set_item(key, json_array_to_py_list(py, v)?)?,
-        Value::Object(v) => py_dict.set_item(key, json_object_to_py_dict(py, v)?)?,
-    }
-
-    Ok(())
-}
-
-fn append_json_value(py: Python, py_list: &Bound<PyList>, value: &Value) -> PyResult<()> {
-    match value {
-        Value::Null => py_list.append(py.None())?,
-        Value::Bool(v) => py_list.append(*v)?,
-        Value::Number(v) => append_number(py_list, v)?,
-        Value::String(v) => py_list.append(v)?,
-        Value::Array(v) => py_list.append(json_array_to_py_list(py, v)?)?,
-        Value::Object(v) => py_list.append(json_object_to_py_dict(py, v)?)?,
-    }
-
-    Ok(())
-}
-
-fn set_number_in_dict(py_dict: &Bound<PyDict>, key: &str, value: &Number) -> PyResult<()> {
-    if let Some(v) = value.as_i64() {
-        py_dict.set_item(key, v)?;
-    } else if let Some(v) = value.as_u64() {
-        py_dict.set_item(key, v)?;
-    } else if let Some(v) = value.as_f64() {
-        py_dict.set_item(key, v)?;
-    } else {
-        py_dict.set_item(key, value.to_string())?;
-    }
-
-    Ok(())
-}
-
-fn append_number(py_list: &Bound<PyList>, value: &Number) -> PyResult<()> {
-    if let Some(v) = value.as_i64() {
-        py_list.append(v)?;
-    } else if let Some(v) = value.as_u64() {
-        py_list.append(v)?;
-    } else if let Some(v) = value.as_f64() {
-        py_list.append(v)?;
-    } else {
-        py_list.append(value.to_string())?;
-    }
-
-    Ok(())
-}
-
 pub fn get_string_from_py_dict_throw_on_none(
     py_dict: &Bound<PyDict>,
     key: &str,

statsig_python_core-0.18.1/statsig-pyo3/src/raw_evaluation_compat_py.rs

@@ -0,0 +1,200 @@
+use pyo3::{
+    types::{PyAnyMethods, PyDict, PyList, PyListMethods},
+    Bound, Py, PyAny, PyResult, Python,
+};
+use serde_json::{Map as SerdeMap, Number as SerdeNumber, Value as SerdeValue};
+use statsig_rust::{
+    interned_string::InternedString,
+    statsig_types_raw::{DynamicConfigRaw, ExperimentRaw, FeatureGateRaw, SuffixedRuleId},
+    DynamicReturnable, EvaluationDetails, SecondaryExposure,
+};
+
+pub(crate) fn raw_gate_to_py_dict(py: Python, raw: &FeatureGateRaw) -> PyResult<Py<PyDict>> {
+    let dict = PyDict::new(py);
+
+    dict.set_item("name", raw.name)?;
+    dict.set_item("value", raw.value)?;
+
+    py_dict_insert_rule_id(&dict, &raw.rule_id)?;
+
+    dict.set_item("idType", opt_interned_str(&raw.id_type))?;
+    dict.set_item("details", evaluation_details_to_py_dict(py, raw.details)?)?;
+
+    Ok(dict.unbind())
+}
+
+pub(crate) fn raw_dynamic_config_to_py_dict(
+    py: Python,
+    raw: &DynamicConfigRaw,
+) -> PyResult<Py<PyDict>> {
+    let dict = PyDict::new(py);
+
+    dict.set_item("name", raw.name)?;
+
+    if let Some(value) = raw.value {
+        py_dict_insert_json_value(py, &dict, value)?;
+    }
+
+    py_dict_insert_rule_id(&dict, &raw.rule_id)?;
+
+    dict.set_item("idType", opt_interned_str(&raw.id_type))?;
+    dict.set_item("details", evaluation_details_to_py_dict(py, raw.details)?)?;
+
+    Ok(dict.unbind())
+}
+
+pub(crate) fn raw_experiment_to_py_dict(py: Python, raw: &ExperimentRaw) -> PyResult<Py<PyDict>> {
+    let dict = PyDict::new(py);
+
+    dict.set_item("name", raw.name)?;
+
+    if let Some(value) = raw.value {
+        py_dict_insert_json_value(py, &dict, value)?;
+    }
+
+    py_dict_insert_rule_id(&dict, &raw.rule_id)?;
+
+    dict.set_item("idType", opt_interned_str(&raw.id_type))?;
+    dict.set_item("details", evaluation_details_to_py_dict(py, raw.details)?)?;
+    dict.set_item("groupName", opt_interned_str(&raw.group_name))?;
+    dict.set_item("isExperimentActive", raw.is_experiment_active)?;
+
+    if let Some(secondary_exposures) = raw.secondary_exposures {
+        dict.set_item(
+            "secondaryExposures",
+            secondary_exposures_to_py_list(py, secondary_exposures)?,
+        )?;
+    }
+
+    Ok(dict.unbind())
+}
+
+fn evaluation_details_to_py_dict(py: Python, details: &EvaluationDetails) -> PyResult<Py<PyDict>> {
+    let raw = PyDict::new(py);
+    raw.set_item("reason", &details.reason)?;
+    raw.set_item("lcut", details.lcut)?;
+    raw.set_item("received_at", details.received_at)?;
+    raw.set_item("version", details.version)?;
+
+    Ok(raw.unbind())
+}
+
+fn secondary_exposures_to_py_list(
+    py: Python,
+    secondary_exposures: &Vec<SecondaryExposure>,
+) -> PyResult<Py<PyList>> {
+    let py_list = PyList::empty(py);
+    for secondary_exposure in secondary_exposures {
+        let dict = PyDict::new(py);
+        dict.set_item("gate", secondary_exposure.gate.as_str())?;
+        dict.set_item("gateValue", secondary_exposure.gate_value.as_str())?;
+        dict.set_item("ruleID", secondary_exposure.rule_id.as_str())?;
+        py_list.append(dict.unbind())?;
+    }
+    Ok(py_list.unbind())
+}
+
+fn opt_interned_str<'a>(value: &'a Option<&'a InternedString>) -> Option<&'a str> {
+    value.as_ref().map(|value| value.as_str())
+}
+
+fn py_dict_insert_rule_id(py_dict: &Bound<PyDict>, rule_id: &SuffixedRuleId) -> PyResult<()> {
+    if let Some(rule_id) = rule_id.try_as_unprefixed_str() {
+        py_dict.set_item("ruleID", rule_id)?;
+    } else {
+        py_dict.set_item("ruleID", rule_id.unperformant_to_string())?;
+    }
+    Ok(())
+}
+
+fn py_dict_insert_json_value(
+    py: Python,
+    py_dict: &Bound<PyDict>,
+    returnable: &DynamicReturnable,
+) -> PyResult<()> {
+    if let Some(value) = returnable.get_serde_map() {
+        py_dict.set_item("value", json_object_to_py_dict(py, value)?)?;
+    }
+
+    Ok(())
+}
+
+// ------------------------------------------------------------------------------- [ Serde to Pyo3 ]
+
+fn json_array_to_py_list(py: Python, values: Vec<SerdeValue>) -> PyResult<Py<PyAny>> {
+    let py_list = PyList::empty(py);
+
+    for value in values {
+        py_list_insert_value(py, &py_list, value)?;
+    }
+
+    Ok(py_list.unbind().into())
+}
+
+fn json_object_to_py_dict(py: Python, map: SerdeMap<String, SerdeValue>) -> PyResult<Py<PyDict>> {
+    let py_dict = PyDict::new(py);
+
+    for (key, value) in map {
+        py_dict_insert_value(py, &py_dict, key, value)?;
+    }
+
+    Ok(py_dict.unbind())
+}
+
+fn py_dict_insert_value(
+    py: Python,
+    py_dict: &Bound<PyDict>,
+    key: String,
+    value: SerdeValue,
+) -> PyResult<()> {
+    match value {
+        SerdeValue::Null => py_dict.set_item(key, py.None())?,
+        SerdeValue::Bool(v) => py_dict.set_item(key, v)?,
+        SerdeValue::Number(v) => py_dict_insert_number(py_dict, key, v)?,
+        SerdeValue::String(v) => py_dict.set_item(key, v)?,
+        SerdeValue::Array(v) => py_dict.set_item(key, json_array_to_py_list(py, v)?)?,
+        SerdeValue::Object(v) => py_dict.set_item(key, json_object_to_py_dict(py, v)?)?,
+    }
+
+    Ok(())
+}
+
+fn py_dict_insert_number(py_dict: &Bound<PyDict>, key: String, value: SerdeNumber) -> PyResult<()> {
+    if let Some(v) = value.as_i64() {
+        py_dict.set_item(key, v)?;
+    } else if let Some(v) = value.as_u64() {
+        py_dict.set_item(key, v)?;
+    } else if let Some(v) = value.as_f64() {
+        py_dict.set_item(key, v)?;
+    } else {
+        py_dict.set_item(key, value.to_string())?;
+    }
+
+    Ok(())
+}
+
+fn py_list_insert_value(py: Python, py_list: &Bound<PyList>, value: SerdeValue) -> PyResult<()> {
+    match value {
+        SerdeValue::Null => py_list.append(py.None())?,
+        SerdeValue::Bool(v) => py_list.append(v)?,
+        SerdeValue::Number(v) => py_list_insert_number(py_list, v)?,
+        SerdeValue::String(v) => py_list.append(v)?,
+        SerdeValue::Array(v) => py_list.append(json_array_to_py_list(py, v)?)?,
+        SerdeValue::Object(v) => py_list.append(json_object_to_py_dict(py, v)?)?,
+    }
+
+    Ok(())
+}
+
+fn py_list_insert_number(py_list: &Bound<PyList>, value: SerdeNumber) -> PyResult<()> {
+    if let Some(v) = value.as_i64() {
+        py_list.append(v)?;
+    } else if let Some(v) = value.as_u64() {
+        py_list.append(v)?;
+    } else if let Some(v) = value.as_f64() {
+        py_list.append(v)?;
+    } else {
+        py_list.append(value.to_string())?;
+    }
+    Ok(())
+}

{statsig_python_core-0.18.0 → statsig_python_core-0.18.1}/statsig-pyo3/src/statsig_base_py.rs

@@ -1,4 +1,7 @@
-use crate::pyo_utils::{map_to_py_dict_direct, py_dict_to_json_value_map};
+use crate::pyo_utils::py_dict_to_json_value_map;
+use crate::raw_evaluation_compat_py::{
+    raw_dynamic_config_to_py_dict, raw_experiment_to_py_dict, raw_gate_to_py_dict,
+};
 use crate::safe_gil::SafeGil;
 use crate::statsig_options_py::{safe_convert_to_statsig_options, StatsigOptionsPy};
 use crate::statsig_persistent_storage_override_adapter_py::convert_dict_to_user_persisted_values;
@@ -13,11 +16,13 @@ use crate::{
     statsig_user_py::StatsigUserPy,
 };
 use parking_lot::Mutex;
-use pyo3::{call::PyCallArgs, prelude::*, types::PyDict};
+use pyo3::{
+    call::PyCallArgs,
+    prelude::*,
+    types::{PyDict, PyModule},
+};
 use pyo3_stub_gen::derive::*;
 use serde_json::Value;
-use statsig_rust::evaluation::evaluation_details::EvaluationDetails;
-use statsig_rust::statsig_types::{DynamicConfig, FeatureGate};
 use statsig_rust::{
     log_e, ClientInitResponseOptions, DynamicConfigEvaluationOptions, ExperimentEvaluationOptions,
     FeatureGateEvaluationOptions, HashAlgorithm, LayerEvaluationOptions, ObservabilityClient,
@@ -241,35 +246,19 @@ impl StatsigBasePy {
     #[pyo3(name="_INTERNAL_get_feature_gate", signature = (user, name, options=None))]
     pub fn _internal_get_feature_gate(
         &self,
+        py: Python,
         user: &StatsigUserPy,
         name: &str,
         options: Option<FeatureGateEvaluationOptionsPy>,
-    ) -> String {
+    ) -> PyResult<Py<PyDict>> {
         self.inner.use_raw_feature_gate_with_options(
             &user.inner,
             name,
             options.map_or(FeatureGateEvaluationOptions::default(), |o| o.into()),
-            |raw| raw.unperformant_to_json_string(),
+            |raw| raw_gate_to_py_dict(py, raw),
         )
     }
 
-    #[pyo3(name="_INTERNAL_get_feature_gate_as_dict", signature = (user, name, options=None))]
-    pub fn _internal_get_feature_gate_as_dict(
-        &self,
-        user: &StatsigUserPy,
-        name: &str,
-        options: Option<FeatureGateEvaluationOptionsPy>,
-        py: Python,
-    ) -> PyResult<Py<PyDict>> {
-        let gate = self.inner.get_feature_gate_with_options(
-            &user.inner,
-            name,
-            options.map_or(FeatureGateEvaluationOptions::default(), |o| o.into()),
-        );
-
-        feature_gate_to_py_dict(py, &gate)
-    }
-
     #[pyo3(signature = (user, name))]
     pub fn manually_log_gate_exposure(&self, user: &StatsigUserPy, name: &str) -> PyResult<()> {
         self.inner.manually_log_gate_exposure(&user.inner, name);
@@ -279,35 +268,19 @@ impl StatsigBasePy {
     #[pyo3(name="_INTERNAL_get_dynamic_config", signature = (user, name, options=None))]
     pub fn _internal_get_dynamic_config(
         &self,
+        py: Python,
         user: &StatsigUserPy,
         name: &str,
         options: Option<DynamicConfigEvaluationOptionsPy>,
-    ) -> String {
+    ) -> PyResult<Py<PyDict>> {
         self.inner.use_raw_dynamic_config_with_options(
             &user.inner,
             name,
             options.map_or(DynamicConfigEvaluationOptions::default(), |o| o.into()),
-            |raw| raw.unperformant_to_json_string(),
+            |raw| raw_dynamic_config_to_py_dict(py, raw),
         )
     }
 
-    #[pyo3(name="_INTERNAL_get_dynamic_config_as_dict", signature = (user, name, options=None))]
-    pub fn _internal_get_dynamic_config_as_dict(
-        &self,
-        user: &StatsigUserPy,
-        name: &str,
-        options: Option<DynamicConfigEvaluationOptionsPy>,
-        py: Python,
-    ) -> PyResult<Py<PyDict>> {
-        let config = self.inner.get_dynamic_config_with_options(
-            &user.inner,
-            name,
-            options.map_or(DynamicConfigEvaluationOptions::default(), |o| o.into()),
-        );
-
-        dynamic_config_to_py_dict(py, &config)
-    }
-
     #[pyo3(signature = (user, name))]
     pub fn manually_log_dynamic_config_exposure(
         &self,
@@ -326,7 +299,7 @@ impl StatsigBasePy {
         name: &str,
         options: Option<ExperimentEvaluationOptionsPy>,
         py: Python,
-    ) -> String {
+    ) -> PyResult<Py<PyDict>> {
         let mut options_actual = options
             .as_ref()
             .map_or(ExperimentEvaluationOptions::default(), |o| o.into());
@@ -337,7 +310,7 @@ impl StatsigBasePy {
 
         self.inner
             .use_raw_experiment_with_options(&user.inner, name, options_actual, |raw| {
-                raw.unperformant_to_json_string()
+                raw_experiment_to_py_dict(py, raw)
             })
     }
 
@@ -605,41 +578,6 @@ fn convert_to_string(value: Option<&Bound<PyAny>>) -> Option<String> {
     value.extract::<String>().ok()
 }
 
-fn feature_gate_to_py_dict(py: Python, gate: &FeatureGate) -> PyResult<Py<PyDict>> {
-    let raw = PyDict::new(py);
-    raw.set_item("name", &gate.name)?;
-    raw.set_item("value", gate.value)?;
-    raw.set_item("ruleID", &gate.rule_id)?;
-    raw.set_item("idType", &gate.id_type)?;
-    raw.set_item("details", evaluation_details_to_py_dict(py, &gate.details)?)?;
-
-    Ok(raw.unbind())
-}
-
-fn dynamic_config_to_py_dict(py: Python, config: &DynamicConfig) -> PyResult<Py<PyDict>> {
-    let raw = PyDict::new(py);
-    raw.set_item("name", &config.name)?;
-    raw.set_item("value", map_to_py_dict_direct(py, &config.value)?)?;
-    raw.set_item("ruleID", &config.rule_id)?;
-    raw.set_item("idType", &config.id_type)?;
-    raw.set_item(
-        "details",
-        evaluation_details_to_py_dict(py, &config.details)?,
-    )?;
-
-    Ok(raw.unbind())
-}
-
-fn evaluation_details_to_py_dict(py: Python, details: &EvaluationDetails) -> PyResult<Py<PyDict>> {
-    let raw = PyDict::new(py);
-    raw.set_item("reason", &details.reason)?;
-    raw.set_item("lcut", details.lcut)?;
-    raw.set_item("received_at", details.received_at)?;
-    raw.set_item("version", details.version)?;
-
-    Ok(raw.unbind())
-}
-
 fn extract_event_metadata(metadata: Option<Bound<PyDict>>) -> Option<HashMap<String, Value>> {
     metadata.map(|m| py_dict_to_json_value_map(&m))
 }