statsig-python-core 0.10.1__tar.gz → 0.10.2__tar.gz

{statsig_python_core-0.10.1 → statsig_python_core-0.10.2}/Cargo.lock

@@ -2373,7 +2373,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.10.1"
+version = "0.10.2"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2437,7 +2437,7 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
 name = "statsig-node"
-version = "0.10.1"
+version = "0.10.2"
 dependencies = [
  "async-trait",
  "napi",
@@ -2451,7 +2451,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.10.1"
+version = "0.10.2"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -2465,7 +2465,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.10.1"
+version = "0.10.2"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -2506,7 +2506,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.10.1"
+version = "0.10.2"
 dependencies = [
  "parking_lot",
  "rustler",
@@ -2518,7 +2518,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.10.1"
+version = "0.10.2"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.10.1 → statsig_python_core-0.10.2}/Cargo.toml

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

{statsig_python_core-0.10.1 → statsig_python_core-0.10.2}/PKG-INFO

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

{statsig_python_core-0.10.1 → statsig_python_core-0.10.2}/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.10.1", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.10.2", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{statsig_python_core-0.10.1 → statsig_python_core-0.10.2}/statsig-rust/src/data_store_interface.rs

@@ -1,6 +1,7 @@
 use std::fmt::Display;
 
 use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
 
 use crate::StatsigErr;
 
@@ -38,6 +39,7 @@ impl Display for CompressFormat {
     }
 }
 
+#[derive(Deserialize, Serialize)]
 pub struct DataStoreResponse {
     pub result: Option<String>,
     pub time: Option<u64>,

{statsig_python_core-0.10.1 → statsig_python_core-0.10.2}/statsig-rust/src/evaluation/cmab_evaluator.rs

@@ -33,7 +33,7 @@ pub struct CMABRankedGroup {
 }
 
 pub fn get_cmab_ranked_list(ctx: &mut EvaluatorContext, name: &str) -> Vec<CMABRankedGroup> {
-    let cmabs = match &ctx.spec_store_data.values.cmab_configs {
+    let cmabs = match &ctx.specs_data.cmab_configs {
         Some(cmabs) => cmabs,
         None => return vec![],
     };
@@ -112,7 +112,7 @@ pub(crate) fn evaluate_cmab(
         _ => return false,
     }
 
-    let cmabs = match &ctx.spec_store_data.values.cmab_configs {
+    let cmabs = match &ctx.specs_data.cmab_configs {
         Some(cmabs) => cmabs,
         None => return false,
     };

statsig_python_core-0.10.2/statsig-rust/src/evaluation/evaluation_details.rs

@@ -0,0 +1,105 @@
+use crate::evaluation::evaluator_result::EvaluatorResult;
+use crate::SpecsSource;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Clone, PartialEq, Debug)]
+pub struct EvaluationDetails {
+    pub reason: String,
+    pub lcut: Option<u64>,
+    pub received_at: Option<u64>,
+}
+
+impl EvaluationDetails {
+    pub fn unrecognized(source: &SpecsSource, lcut: u64, received_at: Option<u64>) -> Self {
+        Self::create_from_data(
+            source,
+            lcut,
+            received_at,
+            "Unrecognized",
+            &EvaluatorResult::default(),
+        )
+    }
+
+    pub fn recognized_without_eval_result(
+        source: &SpecsSource,
+        lcut: u64,
+        received_at: Option<u64>,
+    ) -> Self {
+        Self::create_from_data(
+            source,
+            lcut,
+            received_at,
+            "Recognized",
+            &EvaluatorResult::default(),
+        )
+    }
+
+    pub fn recognized(
+        source: &SpecsSource,
+        lcut: u64,
+        received_at: Option<u64>,
+        eval_result: &EvaluatorResult,
+    ) -> Self {
+        Self::create_from_data(source, lcut, received_at, "Recognized", eval_result)
+    }
+
+    pub fn recognized_but_overridden(
+        lcut: u64,
+        received_at: Option<u64>,
+        override_reason: &str,
+    ) -> Self {
+        Self {
+            reason: format!("{override_reason}:Recognized"),
+            lcut: Some(lcut),
+            received_at,
+        }
+    }
+
+    #[must_use]
+    pub fn unrecognized_no_data() -> Self {
+        Self {
+            reason: SpecsSource::NoValues.to_string(),
+            lcut: None,
+            received_at: None,
+        }
+    }
+
+    #[must_use]
+    pub fn error(sub_reason: &str) -> Self {
+        Self {
+            reason: format!("Error:{sub_reason}"),
+            lcut: None,
+            received_at: None,
+        }
+    }
+
+    fn create_from_data(
+        source: &SpecsSource,
+        lcut: u64,
+        received_at: Option<u64>,
+        sub_reason: &str,
+        eval_result: &EvaluatorResult,
+    ) -> Self {
+        if *source == SpecsSource::Uninitialized || *source == SpecsSource::NoValues {
+            return Self {
+                reason: source.to_string(),
+                lcut: None,
+                received_at: None,
+            };
+        }
+
+        if eval_result.unsupported {
+            return Self {
+                reason: format!("{source}:Unsupported"),
+                lcut: Some(lcut),
+                received_at,
+            };
+        }
+
+        Self {
+            reason: format!("{source}:{sub_reason}"),
+            lcut: Some(lcut),
+            received_at,
+        }
+    }
+}

{statsig_python_core-0.10.1 → statsig_python_core-0.10.2}/statsig-rust/src/evaluation/evaluator.rs

@@ -7,9 +7,8 @@ use crate::evaluation::comparisons::{
     compare_time, compare_versions,
 };
 use crate::evaluation::dynamic_value::DynamicValue;
-use crate::evaluation::evaluation_details::EvaluationDetails;
 use crate::evaluation::evaluation_types::SecondaryExposure;
-use crate::evaluation::evaluator_context::EvaluatorContext;
+use crate::evaluation::evaluator_context::{EvaluatorContext, IdListResolution};
 use crate::evaluation::evaluator_value::{EvaluatorValue, MemoizedEvaluatorValue};
 use crate::evaluation::get_unit_id::get_unit_id;
 use crate::evaluation::user_agent_parsing::UserAgentParser;
@@ -46,40 +45,16 @@ pub enum Recognition {
 }
 
 impl Evaluator {
-    pub fn evaluate_with_details(
-        ctx: &mut EvaluatorContext,
-        spec_name: &str,
-        spec_type: &SpecType,
-    ) -> Result<EvaluationDetails, StatsigErr> {
-        let recognition = Self::evaluate(ctx, spec_name, spec_type)?;
-
-        if recognition == Recognition::Unrecognized {
-            return Ok(EvaluationDetails::unrecognized(ctx.spec_store_data));
-        }
-
-        if let Some(reason) = ctx.result.override_reason {
-            return Ok(EvaluationDetails::recognized_but_overridden(
-                ctx.spec_store_data,
-                reason,
-            ));
-        }
-
-        Ok(EvaluationDetails::recognized(
-            ctx.spec_store_data,
-            &ctx.result,
-        ))
-    }
-
     pub fn evaluate(
         ctx: &mut EvaluatorContext,
         spec_name: &str,
         spec_type: &SpecType,
     ) -> Result<Recognition, StatsigErr> {
         let opt_addressable_spec = match spec_type {
-            SpecType::Gate => ctx.spec_store_data.values.feature_gates.get(spec_name),
-            SpecType::DynamicConfig => ctx.spec_store_data.values.dynamic_configs.get(spec_name),
-            SpecType::Experiment => ctx.spec_store_data.values.dynamic_configs.get(spec_name),
-            SpecType::Layer => ctx.spec_store_data.values.layer_configs.get(spec_name),
+            SpecType::Gate => ctx.specs_data.feature_gates.get(spec_name),
+            SpecType::DynamicConfig => ctx.specs_data.dynamic_configs.get(spec_name),
+            SpecType::Experiment => ctx.specs_data.dynamic_configs.get(spec_name),
+            SpecType::Layer => ctx.specs_data.layer_configs.get(spec_name),
         };
 
         let opt_spec = opt_addressable_spec.map(|a| a.spec.as_ref());
@@ -178,12 +153,12 @@ fn try_apply_config_mapping(
     spec_type: &SpecType,
     opt_spec: Option<&Spec>,
 ) -> bool {
-    let overrides = match &ctx.spec_store_data.values.overrides {
+    let overrides = match &ctx.specs_data.overrides {
         Some(overrides) => overrides,
         None => return false,
     };
 
-    let override_rules = match &ctx.spec_store_data.values.override_rules {
+    let override_rules = match &ctx.specs_data.override_rules {
         Some(override_rules) => override_rules,
         None => return false,
     };
@@ -275,7 +250,7 @@ fn evaluate_rule<'a>(ctx: &mut EvaluatorContext<'a>, rule: &'a Rule) -> Result<(
     // println!("--- Eval Rule {} ---", rule.id);
     for condition_hash in &rule.conditions {
         // println!("Condition Hash {}", condition_hash);
-        let opt_condition = ctx.spec_store_data.values.condition_map.get(condition_hash);
+        let opt_condition = ctx.specs_data.condition_map.get(condition_hash);
         let condition = if let Some(c) = opt_condition {
             c
         } else {
@@ -429,22 +404,35 @@ fn evaluate_id_list(
     target_value: &MemoizedEvaluatorValue,
     value: &DynamicValue,
 ) -> bool {
-    let list_name = unwrap_or_return!(&target_value.string_value, false);
-    let id_lists = &ctx.spec_store_data.id_lists;
+    let is_in_list = is_in_id_list(ctx, target_value, value);
 
-    let list = unwrap_or_return!(id_lists.get(list_name.value.as_str()), false);
+    if op == "not_in_segment_list" {
+        return !is_in_list;
+    }
 
+    is_in_list
+}
+
+fn is_in_id_list(
+    ctx: &mut EvaluatorContext<'_>,
+    target_value: &MemoizedEvaluatorValue,
+    value: &DynamicValue,
+) -> bool {
+    let list_name = unwrap_or_return!(&target_value.string_value, false);
     let dyn_str = unwrap_or_return!(&value.string_value, false);
     let hashed = ctx.hashing.sha256(&dyn_str.value);
     let lookup_id: String = hashed.chars().take(8).collect();
 
-    let is_in_list = list.ids.contains(&lookup_id);
+    match ctx.id_list_resolver {
+        IdListResolution::MapLookup(id_lists) => {
+            let list = unwrap_or_return!(id_lists.get(list_name.value.as_str()), false);
 
-    if op == "not_in_segment_list" {
-        return !is_in_list;
+            list.ids.contains(&lookup_id)
+        }
+        IdListResolution::Callback(callback) => {
+            callback(list_name.value.as_str(), lookup_id.as_str())
+        }
     }
-
-    is_in_list
 }
 
 fn evaluate_nested_gate<'a>(
@@ -507,10 +495,7 @@ fn evaluate_config_delegate<'a>(
     rule: &'a Rule,
 ) -> Result<bool, StatsigErr> {
     let delegate = unwrap_or_return!(&rule.config_delegate, Ok(false));
-    let delegate_spec = unwrap_or_return!(
-        ctx.spec_store_data.values.dynamic_configs.get(delegate),
-        Ok(false)
-    );
+    let delegate_spec = unwrap_or_return!(ctx.specs_data.dynamic_configs.get(delegate), Ok(false));
 
     ctx.result.undelegated_secondary_exposures = Some(ctx.result.secondary_exposures.clone());
 

{statsig_python_core-0.10.1 → statsig_python_core-0.10.2}/statsig-rust/src/evaluation/evaluator_context.rs

@@ -4,18 +4,24 @@ use std::sync::Arc;
 use crate::evaluation::dynamic_value::DynamicValue;
 use crate::evaluation::evaluator_result::EvaluatorResult;
 use crate::hashing::HashUtil;
+use crate::id_lists_adapter::IdList;
 use crate::interned_string::InternedString;
-use crate::spec_store::SpecStoreData;
-use crate::specs_response::spec_types::{Rule, Spec};
+use crate::specs_response::spec_types::{Rule, Spec, SpecsResponseFull};
 use crate::user::StatsigUserInternal;
 use crate::StatsigErr::StackOverflowError;
 use crate::{OverrideAdapter, StatsigErr};
 
 const MAX_RECURSIVE_DEPTH: u16 = 300;
 
+pub enum IdListResolution<'a> {
+    MapLookup(&'a HashMap<String, IdList>),
+    Callback(&'a dyn Fn(&str, &str) -> bool),
+}
+
 pub struct EvaluatorContext<'a> {
     pub user: &'a StatsigUserInternal<'a, 'a>,
-    pub spec_store_data: &'a SpecStoreData,
+    pub specs_data: &'a SpecsResponseFull,
+    pub id_list_resolver: IdListResolution<'a>,
     pub hashing: &'a HashUtil,
     pub result: EvaluatorResult<'a>,
     pub nested_count: u16,
@@ -28,7 +34,8 @@ pub struct EvaluatorContext<'a> {
 impl<'a> EvaluatorContext<'a> {
     pub fn new(
         user: &'a StatsigUserInternal,
-        spec_store_data: &'a SpecStoreData,
+        specs_data: &'a SpecsResponseFull,
+        id_list_resolver: IdListResolution<'a>,
         hashing: &'a HashUtil,
         app_id: Option<&'a DynamicValue>,
         override_adapter: Option<&'a Arc<dyn OverrideAdapter>>,
@@ -38,7 +45,8 @@ impl<'a> EvaluatorContext<'a> {
 
         Self {
             user,
-            spec_store_data,
+            specs_data,
+            id_list_resolver,
             hashing,
             app_id,
             result,

{statsig_python_core-0.10.1 → statsig_python_core-0.10.2}/statsig-rust/src/gcir/dynamic_configs_processor.rs

@@ -51,12 +51,12 @@ pub(crate) fn get_dynamic_config_evaluations(
         context,
         options,
         sec_expo_hash_memo,
-        &context.spec_store_data.values.dynamic_configs,
+        &context.specs_data.dynamic_configs,
         get_dynamic_config_type,
         factory,
     )?;
 
-    let cmab_configs = match &context.spec_store_data.values.cmab_configs {
+    let cmab_configs = match &context.specs_data.cmab_configs {
         Some(cmab_configs) => cmab_configs,
         None => return Ok(result),
     };
@@ -131,12 +131,12 @@ pub(crate) fn get_dynamic_config_evaluations_v2(
         context,
         options,
         sec_expo_hash_memo,
-        &context.spec_store_data.values.dynamic_configs,
+        &context.specs_data.dynamic_configs,
         get_dynamic_config_type,
         factory,
     )?;
 
-    let cmab_configs = match &context.spec_store_data.values.cmab_configs {
+    let cmab_configs = match &context.specs_data.cmab_configs {
         Some(cmab_configs) => cmab_configs,
         None => return Ok(result),
     };

{statsig_python_core-0.10.1 → statsig_python_core-0.10.2}/statsig-rust/src/gcir/feature_gates_processor.rs

@@ -35,7 +35,7 @@ pub(crate) fn get_gate_evaluations(
         context,
         options,
         sec_expo_hash_memo,
-        &context.spec_store_data.values.feature_gates,
+        &context.specs_data.feature_gates,
         get_gate_spec_type,
         factory,
     )
@@ -60,7 +60,7 @@ pub(crate) fn get_gate_evaluations_v2(
         context,
         options,
         sec_expo_hash_memo,
-        &context.spec_store_data.values.feature_gates,
+        &context.specs_data.feature_gates,
         get_gate_spec_type,
         factory,
     )