oai-statsig-python-core 0.26.0rc2__tar.gz → 0.27.0__tar.gz

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/Cargo.lock

@@ -769,6 +769,16 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "fs4"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e72ed92b67c146290f88e9c89d60ca163ea417a446f61ffd7b72df3e7f1dfd5"
+dependencies = [
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "futures"
 version = "0.3.31"
@@ -1403,9 +1413,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.174"
+version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
 [[package]]
 name = "libloading"
@@ -1423,6 +1433,12 @@ version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
 [[package]]
 name = "litemap"
 version = "0.7.4"
@@ -1722,7 +1738,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-grpc"
-version = "0.26.0-rc.2"
+version = "0.27.0"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1737,7 +1753,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-rust"
-version = "0.26.0-rc.2"
+version = "0.27.0"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -1751,6 +1767,7 @@ dependencies = [
  "fancy-regex",
  "file-guard",
  "flate2",
+ "fs4",
  "futures",
  "indexmap 2.13.0",
  "lazy_static",
@@ -1782,6 +1799,7 @@ dependencies = [
  "tonic-prost-build",
  "uaparser",
  "uuid",
+ "windows-sys 0.61.2",
  "wiremock",
  "zstd",
 ]
@@ -2584,10 +2602,23 @@ dependencies = [
  "bitflags 2.8.0",
  "errno",
  "libc",
- "linux-raw-sys",
+ "linux-raw-sys 0.4.15",
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.8.0",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.12.1",
+ "windows-sys 0.60.2",
+]
+
 [[package]]
 name = "rustler"
 version = "0.36.1"
@@ -3012,7 +3043,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.26.0-rc.2"
+version = "0.27.0"
 dependencies = [
  "async-trait",
  "napi",
@@ -3027,7 +3058,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.26.0-rc.2"
+version = "0.27.0"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3042,7 +3073,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.26.0-rc.2"
+version = "0.27.0"
 dependencies = [
  "async-trait",
  "oai-statsig-rust",
@@ -3055,7 +3086,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.26.0-rc.2"
+version = "0.27.0"
 dependencies = [
  "async-trait",
  "cbindgen",
@@ -3145,7 +3176,7 @@ dependencies = [
  "fastrand",
  "getrandom 0.3.1",
  "once_cell",
- "rustix",
+ "rustix 0.38.44",
  "windows-sys 0.59.0",
 ]
 
@@ -4011,6 +4042,15 @@ dependencies = [
  "windows-targets 0.53.5",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.42.2"

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/Cargo.toml

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

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oai_statsig_python_core
-Version: 0.26.0rc2
+Version: 0.27.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/statsig-rust/Cargo.toml

@@ -18,6 +18,7 @@ base64 = "0.22.1"
 chrono = "0.4.40"
 dashmap = "6.1.0"
 file-guard = "0.2.0"
+fs4 = "1.1.0"
 flate2 = "1.0.35"
 futures = "0.3.30"
 indexmap = { version = "2.13.0", features = ["serde"], optional = true }
@@ -44,7 +45,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-oai-statsig-grpc = { path = "../statsig-grpc", version = "0.26.0-rc.2", optional = true }
+oai-statsig-grpc = { path = "../statsig-grpc", version = "0.27.0", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }
@@ -62,6 +63,12 @@ ouroboros = "0.18.0"
 [target.'cfg(target_env = "gnu")'.dependencies]
 libc = "0.2"
 
+[target.'cfg(windows)'.dependencies]
+windows-sys = { version = "0.61.2", features = [
+    "Win32_Foundation",
+    "Win32_Storage_FileSystem",
+] }
+
 [build-dependencies]
 tonic-prost-build = "0.14"
 

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/statsig-rust/src/evaluation/__tests__/dynamic_returnable_tests.rs

@@ -50,6 +50,30 @@ fn test_memoization_from_json_bool() {
     assert_eq!(get_memo_len(), 0, "Bools are not memoized");
 }
 
+#[test]
+#[serial]
+fn test_stable_hash_ignores_object_order() {
+    let first = serde_json::from_str::<DynamicReturnable>(
+        r#"{"first":1,"nested":{"alpha":true,"beta":false}}"#,
+    )
+    .unwrap();
+    let second = serde_json::from_str::<DynamicReturnable>(
+        r#"{"nested":{"beta":false,"alpha":true},"first":1}"#,
+    )
+    .unwrap();
+
+    assert_eq!(first.get_stable_hash(), second.get_stable_hash());
+}
+
+#[test]
+#[serial]
+fn test_stable_hash_preserves_array_order() {
+    let first = serde_json::from_str::<DynamicReturnable>(r#"{"values":[1,2]}"#).unwrap();
+    let second = serde_json::from_str::<DynamicReturnable>(r#"{"values":[2,1]}"#).unwrap();
+
+    assert_ne!(first.get_stable_hash(), second.get_stable_hash());
+}
+
 fn get_memo_len() -> usize {
     InternedStore::get_memoized_len().1
 }

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/statsig-rust/src/evaluation/cmab_evaluator.rs

@@ -62,7 +62,7 @@ pub fn get_cmab_ranked_list(ctx: &mut EvaluatorContext, name: &str) -> Vec<CMABR
         }
     };
 
-    let unit_id = get_unit_id(ctx, &cmab.id_type);
+    let unit_id = get_unit_id(ctx, (&cmab.id_type).into());
     let input = format!("{}.{}", cmab.salt, unit_id);
     let user_hash = ctx.hashing.evaluation_hash(&input);
 
@@ -119,7 +119,7 @@ pub(crate) fn evaluate_cmab(
     let cmab = unwrap_or_return!(cmabs.get(spec_name), false);
 
     if !is_cmab_started(cmab) {
-        ctx.result.id_type = Some(InternedString::from_str_ref(&cmab.id_type.value));
+        ctx.result.id_type = Some(cmab.id_type.value.clone());
         ctx.result.version = Some(cmab.version);
         ctx.result.is_experiment_active = cmab.enabled;
         ctx.result.bool_value = false;
@@ -129,7 +129,7 @@ pub(crate) fn evaluate_cmab(
     }
 
     if !get_passes_targeting(ctx, cmab) {
-        ctx.result.id_type = Some(InternedString::from_dynamic_string(&cmab.id_type));
+        ctx.result.id_type = Some(cmab.id_type.value.clone());
         ctx.result.version = Some(cmab.version);
         ctx.result.is_experiment_active = cmab.enabled;
         ctx.result.bool_value = false;
@@ -138,11 +138,11 @@ pub(crate) fn evaluate_cmab(
         return true;
     }
 
-    ctx.result.id_type = Some(InternedString::from_dynamic_string(&cmab.id_type));
+    ctx.result.id_type = Some(cmab.id_type.value.clone());
     ctx.result.version = Some(cmab.version);
     ctx.result.is_experiment_active = cmab.enabled;
 
-    let unit_id = get_unit_id(ctx, &cmab.id_type);
+    let unit_id = get_unit_id(ctx, (&cmab.id_type).into());
     let input = format!("{}.{}", cmab.salt, unit_id);
     let user_hash = ctx.hashing.evaluation_hash(&input);
     let config = match &cmab.config {
@@ -180,7 +180,7 @@ fn get_passes_targeting<'a>(ctx: &mut EvaluatorContext<'a>, cmab: &'a CMABConfig
         }
     }
 
-    let result = match Evaluator::evaluate(ctx, targeting_gate_name.as_str(), &SpecType::Gate) {
+    let result = match Evaluator::evaluate_with_name(ctx, targeting_gate_name, &SpecType::Gate) {
         Ok(_) => ctx.result.bool_value,
         Err(_) => false,
     };
@@ -222,7 +222,7 @@ fn apply_random_group<'a>(
     ctx.result.bool_value = true;
     ctx.result.rule_id = Some(group.id.clone());
     ctx.result.rule_id_suffix = Some(EXPLORE_RULE_ID_SUFFIX);
-    ctx.result.group_name = Some(InternedString::from_str_ref(&group.name));
+    ctx.result.group_name = Some(InternedString::from_string_uninterned(group.name.clone()));
     ctx.result.json_value = Some(group.parameter_values.clone());
 }
 
@@ -253,7 +253,8 @@ fn apply_sampling_group<'a>(
             ctx.result.rule_id = Some(group.id.clone());
             ctx.result.rule_id_suffix = Some(EXPLORE_RULE_ID_SUFFIX);
             ctx.result.bool_value = true;
-            ctx.result.group_name = Some(InternedString::from_str_ref(&group.name));
+            ctx.result.group_name =
+                Some(InternedString::from_string_uninterned(group.name.clone()));
             ctx.result.json_value = Some(group.parameter_values.clone());
             return true;
         }
@@ -294,7 +295,9 @@ fn apply_best_group<'a>(
     }
     ctx.result.bool_value = true;
     ctx.result.rule_id = Some(best_group.id.clone());
-    ctx.result.group_name = Some(InternedString::from_str_ref(&best_group.name));
+    ctx.result.group_name = Some(InternedString::from_string_uninterned(
+        best_group.name.clone(),
+    ));
     ctx.result.json_value = Some(best_group.parameter_values.clone());
 }
 

oai_statsig_python_core-0.27.0/statsig-rust/src/evaluation/comparisons/compare_arrays.rs

@@ -0,0 +1,126 @@
+use crate::{
+    evaluation::evaluator_value::EvaluatorValueRef, specs_response::spec_types::ConditionOperator,
+    unwrap_or_return, user::user_value::UserValueRef,
+};
+use ahash::AHashSet;
+
+pub(crate) fn compare_arrays<'a>(
+    value: UserValueRef<'_>,
+    target_value: impl Into<EvaluatorValueRef<'a>>,
+    op: ConditionOperator,
+) -> bool {
+    let target_value = target_value.into();
+    unwrap_or_return!(target_value.array_len(), false);
+    let value_len = unwrap_or_return!(value.array_len(), false);
+    let value_set: AHashSet<&str> = AHashSet::from_iter((0..value_len).map(|index| {
+        value
+            .array_item(index)
+            .and_then(UserValueRef::string_value)
+            .unwrap_or_default()
+    }));
+
+    let short_circuit = target_value.any_array_entry(|_, _, item| match op {
+        ConditionOperator::ArrayContainsAll => !value_set.contains(item),
+        ConditionOperator::ArrayContainsAny => value_set.contains(item),
+        ConditionOperator::ArrayContainsNone => value_set.contains(item),
+        ConditionOperator::NotArrayContainsAll => !value_set.contains(item),
+        _ => true,
+    });
+
+    match op {
+        ConditionOperator::ArrayContainsAll => !short_circuit,
+        ConditionOperator::ArrayContainsAny => short_circuit,
+        ConditionOperator::ArrayContainsNone => !short_circuit,
+        ConditionOperator::NotArrayContainsAll => short_circuit,
+        _ => false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::compare_arrays;
+    use crate::{
+        dyn_value,
+        evaluation::evaluator_value::{EvaluatorValueType, MemoizedEvaluatorValue},
+        specs_response::spec_types::ConditionOperator,
+        test_only_make_eval_value,
+    };
+    use serde_json::json;
+
+    fn compare(
+        value: serde_json::Value,
+        target: &MemoizedEvaluatorValue,
+        op: ConditionOperator,
+    ) -> bool {
+        let value = dyn_value!(value);
+        compare_arrays((&value).into(), target, op)
+    }
+
+    #[test]
+    fn array_operators_preserve_quantifier_semantics() {
+        let target = test_only_make_eval_value!(["a", "b"]);
+
+        let cases = [
+            (json!(["a", "b", "c"]), true, true, false, false),
+            (json!(["a"]), false, true, false, true),
+            (json!(["z"]), false, false, true, true),
+            (json!([]), false, false, true, true),
+        ];
+
+        for (value, all, any, none, not_all) in cases {
+            assert_eq!(
+                compare(value.clone(), &target, ConditionOperator::ArrayContainsAll),
+                all
+            );
+            assert_eq!(
+                compare(value.clone(), &target, ConditionOperator::ArrayContainsAny),
+                any
+            );
+            assert_eq!(
+                compare(value.clone(), &target, ConditionOperator::ArrayContainsNone),
+                none
+            );
+            assert_eq!(
+                compare(value, &target, ConditionOperator::NotArrayContainsAll),
+                not_all
+            );
+        }
+    }
+
+    #[test]
+    fn empty_and_missing_targets_keep_existing_behavior() {
+        let empty = MemoizedEvaluatorValue::from(json!([]));
+        let value = json!(["a"]);
+
+        assert!(compare(
+            value.clone(),
+            &empty,
+            ConditionOperator::ArrayContainsAll
+        ));
+        assert!(!compare(
+            value.clone(),
+            &empty,
+            ConditionOperator::ArrayContainsAny
+        ));
+        assert!(compare(
+            value.clone(),
+            &empty,
+            ConditionOperator::ArrayContainsNone
+        ));
+        assert!(!compare(
+            value.clone(),
+            &empty,
+            ConditionOperator::NotArrayContainsAll
+        ));
+
+        let missing = MemoizedEvaluatorValue::new(EvaluatorValueType::Array);
+        for op in [
+            ConditionOperator::ArrayContainsAll,
+            ConditionOperator::ArrayContainsAny,
+            ConditionOperator::ArrayContainsNone,
+            ConditionOperator::NotArrayContainsAll,
+        ] {
+            assert!(!compare(value.clone(), &missing, op));
+        }
+    }
+}

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/statsig-rust/src/evaluation/comparisons/compare_numbers.rs

@@ -1,16 +1,16 @@
 use crate::{
-    evaluation::evaluator_value::MemoizedEvaluatorValue,
-    specs_response::spec_types::ConditionOperator, unwrap_or_return,
-    user::user_value::UserValueRef,
+    evaluation::evaluator_value::EvaluatorValueRef, specs_response::spec_types::ConditionOperator,
+    unwrap_or_return, user::user_value::UserValueRef,
 };
 
-pub(crate) fn compare_numbers(
+pub(crate) fn compare_numbers<'a>(
     left: UserValueRef<'_>,
-    right: &MemoizedEvaluatorValue,
+    right: impl Into<EvaluatorValueRef<'a>>,
     op: ConditionOperator,
 ) -> bool {
+    let right = right.into();
     let left_num = unwrap_or_return!(left.float_value(), false);
-    let right_num = unwrap_or_return!(right.float_value, false);
+    let right_num = unwrap_or_return!(right.float_value(), false);
 
     match op {
         ConditionOperator::Gt => left_num > right_num,

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/statsig-rust/src/evaluation/comparisons/compare_str_with_regex.rs

@@ -1,16 +1,17 @@
 use crate::{
-    evaluation::evaluator_value::MemoizedEvaluatorValue, log_w, unwrap_or_return,
+    evaluation::evaluator_value::EvaluatorValueRef, log_w, unwrap_or_return,
     user::user_value::UserValueRef,
 };
 
 const TAG: &str = "CompareStrWithRegex";
 
-pub(crate) fn compare_str_with_regex(
+pub(crate) fn compare_str_with_regex<'a>(
     value: UserValueRef<'_>,
-    regex_value: &MemoizedEvaluatorValue,
+    regex_value: impl Into<EvaluatorValueRef<'a>>,
 ) -> bool {
+    let regex_value = regex_value.into();
     let value_str = unwrap_or_return!(value.string_value(), false);
-    let regex = match &regex_value.regex_value {
+    let regex = match regex_value.regex_value() {
         Some(regex) => regex,
         None => {
             log_w!(

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/statsig-rust/src/evaluation/comparisons/compare_strings_in_array.rs

@@ -1,14 +1,14 @@
 use crate::{
-    evaluation::evaluator_value::MemoizedEvaluatorValue,
-    specs_response::spec_types::ConditionOperator, unwrap_or_return,
-    user::user_value::UserValueRef,
+    evaluation::evaluator_value::EvaluatorValueRef, specs_response::spec_types::ConditionOperator,
+    unwrap_or_return, user::user_value::UserValueRef,
 };
 
-pub(crate) fn compare_strings_in_array(
+pub(crate) fn compare_strings_in_array<'a>(
     value: UserValueRef<'_>,
-    target_value: &MemoizedEvaluatorValue,
+    target_value: impl Into<EvaluatorValueRef<'a>>,
     op: ConditionOperator,
 ) -> bool {
+    let target_value = target_value.into();
     let ignore_case = !matches!(
         op,
         ConditionOperator::AnyCaseSensitive | ConditionOperator::NoneCaseSensitive
@@ -28,46 +28,35 @@ pub(crate) fn compare_strings_in_array(
 
 fn compare_strings_in_array_impl(
     value: UserValueRef<'_>,
-    target_value: &MemoizedEvaluatorValue,
+    target_value: EvaluatorValueRef<'_>,
     op: ConditionOperator,
     ignore_case: bool,
 ) -> bool {
-    if let Some(keyed_lookup) = &target_value.object_value {
-        if matches!(op, ConditionOperator::Any | ConditionOperator::NoneOf) {
-            let contains = match value.lowercased_lookup_key() {
-                Some(key) => keyed_lookup.contains_key(key),
-                None => value
-                    .lowercased_string_value()
-                    .is_some_and(|lowercased_value| {
-                        keyed_lookup
-                            .keys()
-                            .any(|value| value.as_str() == lowercased_value.as_ref())
-                    }),
-            };
-            return contains;
-        }
+    if target_value.object_len().is_some()
+        && matches!(op, ConditionOperator::Any | ConditionOperator::NoneOf)
+    {
+        return match value.lowercased_lookup_key() {
+            Some(key) => target_value.object_contains_key(key),
+            None => value
+                .lowercased_string_value()
+                .is_some_and(|value| target_value.object_contains_key_str(value.as_ref())),
+        };
     }
 
-    let array_value = unwrap_or_return!(&target_value.array_value, false);
+    unwrap_or_return!(target_value.array_len(), false);
     if matches!(op, ConditionOperator::Any | ConditionOperator::NoneOf) {
-        let contains = match value.lowercased_lookup_key() {
-            Some(key) => array_value.contains_key(key),
+        return match value.lowercased_lookup_key() {
+            Some(key) => target_value.array_contains_key(key),
             None => value
                 .lowercased_string_value()
-                .is_some_and(|lowercased_value| {
-                    array_value
-                        .keys()
-                        .any(|value| value.as_str() == lowercased_value.as_ref())
-                }),
+                .is_some_and(|value| target_value.array_contains_lowercase(value.as_ref())),
         };
-        return contains;
     }
 
     let value_str = value.string_value().unwrap_or_default();
     let lowercased_value = value.lowercased_string_value().unwrap_or_default();
 
-    let mut comparison_result = false;
-    for (lowercase_str, (_, current_str)) in array_value {
+    target_value.any_array_entry(|lowercase_str, _, current_str| {
         let left = if ignore_case {
             lowercased_value.as_ref()
         } else {
@@ -80,25 +69,19 @@ fn compare_strings_in_array_impl(
             current_str
         };
 
-        comparison_result = match op {
+        match op {
             ConditionOperator::Any
             | ConditionOperator::NoneOf
             | ConditionOperator::AnyCaseSensitive
-            | ConditionOperator::NoneCaseSensitive => left == right.as_str(),
-            ConditionOperator::StrStartsWithAny => left.starts_with(right.as_str()),
-            ConditionOperator::StrEndsWithAny => left.ends_with(right.as_str()),
+            | ConditionOperator::NoneCaseSensitive => left == right,
+            ConditionOperator::StrStartsWithAny => left.starts_with(right),
+            ConditionOperator::StrEndsWithAny => left.ends_with(right),
             ConditionOperator::StrContainsAny | ConditionOperator::StrContainsNone => {
-                contains_substring(left, right.as_str())
+                contains_substring(left, right)
             }
             _ => false, // todo: unsupported?
-        };
-
-        if comparison_result {
-            break;
         }
-    }
-
-    comparison_result
+    })
 }
 
 #[inline]

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/statsig-rust/src/evaluation/comparisons/compare_time.rs

@@ -1,23 +1,23 @@
 use crate::{
-    evaluation::evaluator_value::MemoizedEvaluatorValue,
-    specs_response::spec_types::ConditionOperator, unwrap_or_return,
-    user::user_value::UserValueRef,
+    evaluation::evaluator_value::EvaluatorValueRef, specs_response::spec_types::ConditionOperator,
+    unwrap_or_return, user::user_value::UserValueRef,
 };
 use chrono::Duration;
 
-pub(crate) fn compare_time(
+pub(crate) fn compare_time<'a>(
     left: UserValueRef<'_>,
-    right: &MemoizedEvaluatorValue,
+    right: impl Into<EvaluatorValueRef<'a>>,
     op: ConditionOperator,
 ) -> bool {
+    let right = right.into();
     let raw_left_ts = unwrap_or_return!(left.timestamp_value().or(left.int_value()), false);
     let left_ts = to_millis(raw_left_ts);
 
     // dcs will always be in milliseconds
     let right_ts = unwrap_or_return!(
         right
-            .timestamp_value
-            .or(right.float_value.map(|x| x as i64)),
+            .timestamp_value()
+            .or_else(|| right.float_value().map(|x| x as i64)),
         false
     );
 

{oai_statsig_python_core-0.26.0rc2 → oai_statsig_python_core-0.27.0}/statsig-rust/src/evaluation/comparisons/compare_versions.rs

@@ -1,18 +1,16 @@
 use crate::{
-    evaluation::evaluator_value::MemoizedEvaluatorValue,
-    specs_response::spec_types::ConditionOperator, unwrap_or_return,
-    user::user_value::UserValueRef,
+    evaluation::evaluator_value::EvaluatorValueRef, specs_response::spec_types::ConditionOperator,
+    unwrap_or_return, user::user_value::UserValueRef,
 };
 
-pub(crate) fn compare_versions(
+pub(crate) fn compare_versions<'a>(
     left: UserValueRef<'_>,
-    right: &MemoizedEvaluatorValue,
+    right: impl Into<EvaluatorValueRef<'a>>,
     op: ConditionOperator,
 ) -> bool {
+    let right = right.into();
     let left_str = unwrap_or_return!(left.string_value(), false);
-    let right_dyn_str = unwrap_or_return!(&right.string_value, false);
-
-    let right_str = &right_dyn_str.value;
+    let right_str = unwrap_or_return!(right.string_value(), false);
 
     let result = match compare_versions_impl(left_str, right_str) {
         ComparisonResult::Ok(result) => result,