statsig-python-core 0.11.0__tar.gz → 0.11.1b2510300237__tar.gz

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510300237}/Cargo.lock

@@ -2374,7 +2374,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.11.0"
+version = "0.11.1-beta.2510300237"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2438,7 +2438,7 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "statsig-node"
-version = "0.11.0"
+version = "0.11.1-beta.2510300237"
 dependencies = [
  "async-trait",
  "napi",
@@ -2452,7 +2452,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.11.0"
+version = "0.11.1-beta.2510300237"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -2466,7 +2466,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.11.0"
+version = "0.11.1-beta.2510300237"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -2507,7 +2507,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.11.0"
+version = "0.11.1-beta.2510300237"
 dependencies = [
  "parking_lot",
  "rustler",
@@ -2519,7 +2519,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.11.0"
+version = "0.11.1-beta.2510300237"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510300237}/Cargo.toml

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

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510300237}/PKG-INFO

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

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510300237}/statsig-rust/Cargo.toml

@@ -38,7 +38,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-sigstat-grpc = { path = "../statsig-grpc", version = "0.11.0", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.11.1-beta.2510300237", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510300237}/statsig-rust/src/__tests__/spec_store_tests.rs

@@ -6,6 +6,7 @@ use parking_lot::Mutex;
 use crate::{
     data_store_interface::{DataStoreResponse, DataStoreTrait, RequestPath},
     networking::ResponseData,
+    sdk_event_emitter::SdkEventEmitter,
     SpecStore, SpecsSource, SpecsUpdate, StatsigErr, StatsigRuntime,
 };
 
@@ -65,6 +66,7 @@ async fn test_spec_store_data_store_updates_forwarded_to_data_store() {
         "test",
         "test".to_string(),
         StatsigRuntime::get_runtime(),
+        Arc::new(SdkEventEmitter::default()),
         Some(data_store.clone()),
     );
 
@@ -97,6 +99,7 @@ fn test_failure_to_update() {
         "test",
         "test".to_string(),
         StatsigRuntime::get_runtime(),
+        Arc::new(SdkEventEmitter::default()),
         None,
     );
 
@@ -116,6 +119,7 @@ fn test_no_updates() {
         "test",
         "test".to_string(),
         StatsigRuntime::get_runtime(),
+        Arc::new(SdkEventEmitter::default()),
         None,
     );
 

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510300237}/statsig-rust/src/evaluation/dynamic_returnable.rs

@@ -68,6 +68,10 @@ impl DynamicReturnable {
             },
         }
     }
+
+    pub fn get_hash(&self) -> u64 {
+        self.hash
+    }
 }
 
 impl<'de> Deserialize<'de> for DynamicReturnable {

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510300237}/statsig-rust/src/evaluation/evaluation_types.rs

@@ -1,5 +1,7 @@
 use super::dynamic_returnable::DynamicReturnable;
-use crate::interned_string::InternedString;
+use crate::{
+    evaluation::secondary_exposure_key::SecondaryExposureKey, interned_string::InternedString,
+};
 use serde::{Deserialize, Serialize};
 
 pub fn is_false(v: &bool) -> bool {
@@ -27,6 +29,16 @@ impl SecondaryExposure {
     }
 }
 
+impl From<&SecondaryExposure> for SecondaryExposureKey {
+    fn from(val: &SecondaryExposure) -> Self {
+        SecondaryExposureKey {
+            gate_name_hash: val.gate.hash,
+            rule_id_hash: val.rule_id.hash,
+            gate_value_hash: val.gate_value.hash,
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug, Default)]
 pub struct ExtraExposureInfo {
     pub sampling_rate: Option<u64>,

statsig_python_core-0.11.1b2510300237/statsig-rust/src/evaluation/evaluation_types_initialize_v2.rs

@@ -0,0 +1,95 @@
+use crate::interned_string::InternedString;
+use serde::{Deserialize, Serialize};
+use serde_with::skip_serializing_none;
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Clone)]
+pub struct BaseEvaluationInitV2 {
+    #[serde(rename = "r")]
+    pub rule_id: Option<InternedString>,
+    #[serde(rename = "s")]
+    pub secondary_exposures: Option<Vec<InternedString>>,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Clone)]
+pub struct GateEvaluationInitV2 {
+    #[serde(flatten)]
+    pub base: BaseEvaluationInitV2,
+
+    #[serde(rename = "i")]
+    pub id_type: Option<InternedString>,
+    #[serde(rename = "v")]
+    pub value: Option<bool>,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Clone)]
+pub struct DynamicConfigEvaluationInitV2 {
+    #[serde(flatten)]
+    pub base: BaseEvaluationInitV2,
+
+    #[serde(rename = "i")]
+    pub id_type: Option<InternedString>,
+    #[serde(rename = "v")]
+    pub value: InternedString,
+    #[serde(rename = "p")]
+    pub passed: bool,
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Clone)]
+pub struct ExperimentEvaluationInitV2 {
+    #[serde(flatten)]
+    pub base: BaseEvaluationInitV2,
+
+    #[serde(rename = "i")]
+    pub id_type: Option<InternedString>,
+    #[serde(rename = "v")]
+    pub value: InternedString,
+
+    #[serde(rename = "gn")]
+    pub group_name: Option<InternedString>,
+
+    #[serde(rename = "ea")]
+    pub is_experiment_active: Option<bool>,
+
+    #[serde(rename = "ue")]
+    pub is_user_in_experiment: Option<bool>,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+#[serde(untagged)]
+pub enum AnyConfigEvaluationInitV2 {
+    DynamicConfig(DynamicConfigEvaluationInitV2),
+    Experiment(ExperimentEvaluationInitV2),
+}
+
+#[skip_serializing_none]
+#[derive(Serialize, Deserialize, Clone)]
+pub struct LayerEvaluationInitV2 {
+    #[serde(flatten)]
+    pub base: BaseEvaluationInitV2,
+
+    #[serde(rename = "v")]
+    pub value: InternedString,
+
+    #[serde(rename = "i")]
+    pub id_type: Option<InternedString>,
+
+    #[serde(rename = "gn")]
+    pub group_name: Option<InternedString>,
+
+    #[serde(rename = "ea")]
+    pub is_experiment_active: Option<bool>,
+
+    #[serde(rename = "ue")]
+    pub is_user_in_experiment: Option<bool>,
+
+    #[serde(rename = "ae")]
+    pub allocated_experiment_name: Option<InternedString>,
+    #[serde(rename = "ep")]
+    pub explicit_parameters: Option<Vec<InternedString>>,
+    #[serde(rename = "us")]
+    pub undelegated_secondary_exposures: Option<Vec<InternedString>>,
+}

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510300237}/statsig-rust/src/evaluation/evaluator_result.rs

@@ -1,3 +1,7 @@
+use std::collections::HashMap;
+
+use ahash::AHashMap;
+
 use super::dynamic_returnable::DynamicReturnable;
 use super::evaluation_types::ExtraExposureInfo;
 use super::evaluation_types_v2::{
@@ -8,6 +12,11 @@ use crate::evaluation::evaluation_types::{
     BaseEvaluation, DynamicConfigEvaluation, ExperimentEvaluation, GateEvaluation, LayerEvaluation,
     SecondaryExposure,
 };
+use crate::evaluation::evaluation_types_initialize_v2::{
+    BaseEvaluationInitV2, DynamicConfigEvaluationInitV2, ExperimentEvaluationInitV2,
+    GateEvaluationInitV2, LayerEvaluationInitV2,
+};
+use crate::evaluation::secondary_exposure_key::SecondaryExposureKey;
 use crate::hashing::{HashAlgorithm, HashUtil};
 use crate::interned_string::InternedString;
 
@@ -57,6 +66,22 @@ pub fn result_to_gate_eval_v2(
     }
 }
 
+pub fn result_to_gate_eval_init_v2(
+    result: &mut EvaluatorResult,
+    expo_id_to_exposure_map: &mut HashMap<InternedString, SecondaryExposure>,
+    expo_key_to_expo_id_map: &mut AHashMap<SecondaryExposureKey, InternedString>,
+) -> GateEvaluationInitV2 {
+    let value: Option<bool> = match result.bool_value {
+        true => Some(true),
+        _ => None,
+    };
+    GateEvaluationInitV2 {
+        base: result_to_base_eval_init_v2(result, expo_id_to_exposure_map, expo_key_to_expo_id_map),
+        id_type: result.id_type.take(),
+        value,
+    }
+}
+
 pub fn result_to_experiment_eval(
     experiment_name: &str,
     spec_entity: Option<&str>,
@@ -120,6 +145,40 @@ pub fn result_to_experiment_eval_v2(
     }
 }
 
+pub fn result_to_experiment_eval_init_v2(
+    spec_entity: Option<&str>,
+    result: &mut EvaluatorResult,
+    expo_id_to_exposure_map: &mut HashMap<InternedString, SecondaryExposure>,
+    expo_key_to_expo_id_map: &mut AHashMap<SecondaryExposureKey, InternedString>,
+    value_id_to_value_map: &mut HashMap<InternedString, DynamicReturnable>,
+    value_key_to_value_id: &mut AHashMap<u64, InternedString>,
+) -> ExperimentEvaluationInitV2 {
+    let value: Option<DynamicReturnable> = result.json_value.take();
+
+    let id_type = result.id_type.take();
+
+    let mut is_experiment_active = None;
+    let mut is_user_in_experiment = None;
+
+    if let Some(spec_entity) = spec_entity {
+        if spec_entity == "experiment" {
+            is_experiment_active = Some(result.is_experiment_active);
+            is_user_in_experiment = Some(result.is_experiment_group);
+        }
+    }
+
+    let mapped_value = self::get_mapped_value(value, value_id_to_value_map, value_key_to_value_id);
+
+    ExperimentEvaluationInitV2 {
+        base: result_to_base_eval_init_v2(result, expo_id_to_exposure_map, expo_key_to_expo_id_map),
+        id_type,
+        value: mapped_value,
+        group_name: result.group_name.take(),
+        is_experiment_active,
+        is_user_in_experiment,
+    }
+}
+
 pub fn eval_result_to_experiment_eval(
     experiment_name: &str,
     result: &mut EvaluatorResult,
@@ -220,6 +279,58 @@ pub fn result_to_layer_eval_v2(
     }
 }
 
+pub fn result_to_layer_eval_init_v2(
+    result: &mut EvaluatorResult,
+    expo_id_to_exposure_map: &mut HashMap<InternedString, SecondaryExposure>,
+    expo_key_to_expo_id_map: &mut AHashMap<SecondaryExposureKey, InternedString>,
+    value_id_to_value_map: &mut HashMap<InternedString, DynamicReturnable>,
+    value_key_to_value_id: &mut AHashMap<u64, InternedString>,
+) -> LayerEvaluationInitV2 {
+    let value: Option<DynamicReturnable> = result.json_value.take();
+
+    let mut allocated_experiment_name = None;
+    let mut is_experiment_active = None;
+    let mut is_user_in_experiment = None;
+
+    if let Some(config_delegate) = result.config_delegate.take() {
+        if !config_delegate.is_empty() {
+            allocated_experiment_name = Some(config_delegate.clone());
+            is_experiment_active = Some(result.is_experiment_active);
+            is_user_in_experiment = Some(result.is_experiment_group);
+        }
+    }
+
+    let id_type = result.id_type.take();
+
+    let mapped_exposures: Option<Vec<InternedString>> = match result
+        .undelegated_secondary_exposures
+        .as_mut()
+    {
+        Some(undelegated_secondary_exposures) if !&undelegated_secondary_exposures.is_empty() => {
+            Some(self::map_exposures(
+                undelegated_secondary_exposures,
+                expo_id_to_exposure_map,
+                expo_key_to_expo_id_map,
+            ))
+        }
+        _ => None,
+    };
+
+    let mapped_value = self::get_mapped_value(value, value_id_to_value_map, value_key_to_value_id);
+
+    LayerEvaluationInitV2 {
+        base: result_to_base_eval_init_v2(result, expo_id_to_exposure_map, expo_key_to_expo_id_map),
+        id_type,
+        value: mapped_value,
+        group_name: result.group_name.take(),
+        is_experiment_active,
+        is_user_in_experiment,
+        allocated_experiment_name,
+        explicit_parameters: result.explicit_parameters.cloned(),
+        undelegated_secondary_exposures: mapped_exposures,
+    }
+}
+
 pub fn result_to_dynamic_config_eval(
     dynamic_config_name: &str,
     result: &mut EvaluatorResult,
@@ -251,6 +362,48 @@ pub fn result_to_dynamic_config_eval_v2(
     }
 }
 
+pub fn result_to_dynamic_config_eval_init_v2(
+    result: &mut EvaluatorResult,
+    expo_id_to_exposure_map: &mut HashMap<InternedString, SecondaryExposure>,
+    expo_key_to_expo_id_map: &mut AHashMap<SecondaryExposureKey, InternedString>,
+    value_id_to_value_map: &mut HashMap<InternedString, DynamicReturnable>,
+    value_key_to_value_id: &mut AHashMap<u64, InternedString>,
+) -> DynamicConfigEvaluationInitV2 {
+    let value: Option<DynamicReturnable> = result.json_value.take();
+
+    let id_type = result.id_type.take();
+
+    let mapped_value = self::get_mapped_value(value, value_id_to_value_map, value_key_to_value_id);
+
+    DynamicConfigEvaluationInitV2 {
+        base: result_to_base_eval_init_v2(result, expo_id_to_exposure_map, expo_key_to_expo_id_map),
+        id_type,
+        value: mapped_value,
+        passed: result.bool_value,
+    }
+}
+
+fn get_mapped_value(
+    value: Option<DynamicReturnable>,
+    value_id_to_value_map: &mut HashMap<InternedString, DynamicReturnable>,
+    value_key_to_value_id: &mut AHashMap<u64, InternedString>,
+) -> InternedString {
+    let val = match &value {
+        Some(v) => v,
+        None => &DynamicReturnable::empty(),
+    };
+    let hash = val.get_hash();
+    match value_key_to_value_id.get(&hash) {
+        Some(mapped_key) => mapped_key.clone(),
+        None => {
+            let value_id = InternedString::from_string(value_id_to_value_map.len().to_string());
+            value_id_to_value_map.insert(value_id.clone(), val.clone());
+            value_key_to_value_id.insert(hash, value_id.clone());
+            value_id
+        }
+    }
+}
+
 fn get_id_type_info(id_type: Option<&InternedString>) -> (InternedString, bool) {
     let id_type = id_type.cloned().unwrap_or_default();
     let is_device_based = id_type == "stableID" || id_type == "stableid";
@@ -325,6 +478,61 @@ fn result_to_base_eval_v2(
     }
 }
 
+fn result_to_base_eval_init_v2(
+    result: &mut EvaluatorResult,
+    expo_id_to_exposure_map: &mut HashMap<InternedString, SecondaryExposure>,
+    expo_key_to_expo_id_map: &mut AHashMap<SecondaryExposureKey, InternedString>,
+) -> BaseEvaluationInitV2 {
+    let rule_id = create_suffixed_rule_id(result.rule_id, result.rule_id_suffix);
+    let opt_rule_id = match rule_id.as_str() {
+        "default" => None,
+        _ => Some(rule_id),
+    };
+
+    if result.secondary_exposures.is_empty() {
+        return BaseEvaluationInitV2 {
+            rule_id: opt_rule_id,
+            secondary_exposures: None,
+        };
+    }
+
+    BaseEvaluationInitV2 {
+        rule_id: opt_rule_id,
+        secondary_exposures: Some(self::map_exposures(
+            &mut result.secondary_exposures,
+            expo_id_to_exposure_map,
+            expo_key_to_expo_id_map,
+        )),
+    }
+}
+
+fn map_exposures(
+    input_exposures: &mut Vec<SecondaryExposure>,
+    expo_id_to_exposure_map: &mut HashMap<InternedString, SecondaryExposure>,
+    expo_key_to_expo_id_map: &mut AHashMap<SecondaryExposureKey, InternedString>,
+) -> Vec<InternedString> {
+    let my_exposures = std::mem::take(input_exposures);
+    my_exposures
+        .into_iter()
+        .map(|exposure| {
+            let expo_key = SecondaryExposureKey::from(&exposure);
+
+            match expo_key_to_expo_id_map.get(&expo_key) {
+                Some(expo_id) => expo_id.clone(),
+                None => {
+                    let expo_id =
+                        InternedString::from_string(expo_id_to_exposure_map.len().to_string());
+
+                    expo_id_to_exposure_map.insert(expo_id.clone(), exposure);
+                    expo_key_to_expo_id_map.insert(expo_key, expo_id.clone());
+
+                    expo_id
+                }
+            }
+        })
+        .collect()
+}
+
 fn create_suffixed_rule_id(
     rule_id: Option<&InternedString>,
     suffix: Option<&str>,

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510300237}/statsig-rust/src/evaluation/mod.rs

@@ -3,11 +3,13 @@ pub mod dynamic_string;
 pub mod dynamic_value;
 pub mod evaluation_details;
 pub mod evaluation_types;
+pub mod evaluation_types_initialize_v2;
 pub mod evaluation_types_v2;
 pub mod evaluator;
 pub mod evaluator_context;
 pub mod evaluator_result;
 pub mod evaluator_value;
+pub mod secondary_exposure_key;
 pub mod user_agent_parsing;
 
 pub(crate) mod cmab_evaluator;

statsig_python_core-0.11.1b2510300237/statsig-rust/src/evaluation/secondary_exposure_key.rs

@@ -0,0 +1,16 @@
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub struct SecondaryExposureKey {
+    pub gate_name_hash: u64,
+    pub rule_id_hash: u64,
+    pub gate_value_hash: u64,
+}
+
+impl SecondaryExposureKey {
+    pub fn new(gate_name_hash: u64, rule_id_hash: u64, gate_value_hash: u64) -> Self {
+        Self {
+            gate_name_hash,
+            rule_id_hash,
+            gate_value_hash,
+        }
+    }
+}

{statsig_python_core-0.11.0 → statsig_python_core-0.11.1b2510300237}/statsig-rust/src/gcir/dynamic_configs_processor.rs

@@ -1,15 +1,20 @@
+use ahash::AHashMap;
 use std::collections::HashMap;
 
 use crate::{
     evaluation::{
+        dynamic_returnable::DynamicReturnable,
         evaluation_types::AnyConfigEvaluation,
+        evaluation_types_initialize_v2::AnyConfigEvaluationInitV2,
         evaluation_types_v2::AnyConfigEvaluationV2,
         evaluator::{Evaluator, SpecType},
         evaluator_context::EvaluatorContext,
         evaluator_result::{
-            result_to_dynamic_config_eval, result_to_dynamic_config_eval_v2,
-            result_to_experiment_eval, result_to_experiment_eval_v2,
+            result_to_dynamic_config_eval, result_to_dynamic_config_eval_init_v2,
+            result_to_dynamic_config_eval_v2, result_to_experiment_eval,
+            result_to_experiment_eval_init_v2, result_to_experiment_eval_v2,
         },
+        secondary_exposure_key::SecondaryExposureKey,
     },
     gcir::{
         gcir_process_iter::hash_secondary_exposures,
@@ -190,6 +195,99 @@ pub(crate) fn get_dynamic_config_evaluations_v2(
     Ok(result)
 }
 
+pub(crate) fn get_dynamic_config_evaluations_init_v2(
+    context: &mut EvaluatorContext,
+    options: &ClientInitResponseOptions,
+    expo_id_to_exposure_map: &mut HashMap<InternedString, SecondaryExposure>,
+    expo_key_to_expo_id_map: &mut AHashMap<SecondaryExposureKey, InternedString>,
+    value_id_to_value_map: &mut HashMap<InternedString, DynamicReturnable>,
+    value_key_to_value_id: &mut AHashMap<u64, InternedString>,
+) -> Result<HashMap<String, AnyConfigEvaluationInitV2>, StatsigErr> {
+    let factory = |spec_entity: &str, _: &str, ctx: &mut EvaluatorContext| {
+        if spec_entity == "dynamic_config" {
+            let mut res = result_to_dynamic_config_eval_init_v2(
+                &mut ctx.result,
+                expo_id_to_exposure_map,
+                expo_key_to_expo_id_map,
+                value_id_to_value_map,
+                value_key_to_value_id,
+            );
+            if options.remove_id_type.unwrap_or(false) {
+                res.id_type = None
+            }
+            return AnyConfigEvaluationInitV2::DynamicConfig(res);
+        }
+
+        let mut evaluation = result_to_experiment_eval_init_v2(
+            Some(spec_entity),
+            &mut ctx.result,
+            expo_id_to_exposure_map,
+            expo_key_to_expo_id_map,
+            value_id_to_value_map,
+            value_key_to_value_id,
+        );
+        if options.remove_id_type.unwrap_or(false) {
+            evaluation.id_type = None
+        }
+        AnyConfigEvaluationInitV2::Experiment(evaluation)
+    };
+
+    let mut result = gcir_process_iter(
+        context,
+        options,
+        &mut HashMap::new(),
+        &context.specs_data.dynamic_configs,
+        get_dynamic_config_type,
+        factory,
+    )?;
+
+    let cmab_configs = match &context.specs_data.cmab_configs {
+        Some(cmab_configs) => cmab_configs,
+        None => return Ok(result),
+    };
+
+    for config_name in cmab_configs.keys() {
+        let hashed_name = context
+            .hashing
+            .hash(config_name.as_str(), options.get_hash_algorithm());
+        if options
+            .experiment_filter
+            .as_ref()
+            .is_some_and(|f| !f.contains(config_name))
+        {
+            continue;
+        }
+
+        let target_app_ids = cmab_configs
+            .get(config_name)
+            .and_then(|c| c.target_app_ids.as_ref());
+        if should_filter_config_for_app(target_app_ids, &context.app_id, &options.client_sdk_key) {
+            continue;
+        }
+        context.reset_result();
+        let _ = Evaluator::evaluate(context, config_name.as_str(), &SpecType::Experiment);
+
+        let mut evaluation = result_to_experiment_eval_init_v2(
+            Some("autotune"),
+            &mut context.result,
+            expo_id_to_exposure_map,
+            expo_key_to_expo_id_map,
+            value_id_to_value_map,
+            value_key_to_value_id,
+        );
+        if options.remove_id_type.unwrap_or(false) {
+            evaluation.id_type = None
+        }
+
+        result.insert(
+            hashed_name,
+            AnyConfigEvaluationInitV2::Experiment(evaluation),
+        );
+    }
+
+    Ok(result)
+}
+
 fn get_dynamic_config_type(spec: &Spec) -> SpecType {
     if spec.entity == "dynamic_config" {
         SpecType::DynamicConfig