statsig-python-core 0.19.3b2604211739__tar.gz → 0.19.4__tar.gz

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/Cargo.lock

@@ -2530,6 +2530,7 @@ checksum = "f04a7b61bf2db5495d6c0d2eb4b3f0f366864d47f2482834656e25d1b25fe290"
 dependencies = [
  "inventory",
  "libloading",
+ "num-bigint",
  "regex-lite",
  "rustler_codegen",
  "serde",
@@ -2869,7 +2870,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.19.3-beta.2604211739"
+version = "0.19.4"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2961,7 +2962,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.19.3-beta.2604211739"
+version = "0.19.4"
 dependencies = [
  "async-trait",
  "napi",
@@ -2976,7 +2977,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.19.3-beta.2604211739"
+version = "0.19.4"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -2991,7 +2992,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.19.3-beta.2604211739"
+version = "0.19.4"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3041,7 +3042,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.19.3-beta.2604211739"
+version = "0.19.4"
 dependencies = [
  "async-trait",
  "parking_lot",
@@ -3054,7 +3055,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.19.3-beta.2604211739"
+version = "0.19.4"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/Cargo.toml

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

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/PKG-INFO

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

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/py_src/statsig_python_core/statsig_types.py

@@ -157,8 +157,10 @@ class BaseConfigEvaluation(BaseEvaluation):
         if res is None:
             return actual_fallback
 
-        if actual_fallback is None or isinstance(actual_fallback, type(res)):
-            return res
+        # Ints stored in Statsig (e.g. a value saved as `1` rather than `1.0`) are valid
+        # floats — coerce them. `bool` subclasses `int` in Python, so exclude it.
+        if isinstance(res, (int, float)) and not isinstance(res, bool):
+            return float(res)
 
         _log_error(
             self.__tag,
@@ -289,13 +291,21 @@ class Layer(BaseEvaluation):
 
     def get_float(self, param_name: str, fallback: float) -> float:
         actual_fallback = float(fallback) if isinstance(fallback, int) else fallback
-        return self._get_typed(
+        res = self.__value.get(param_name, None)
+        if res is None:
+            return actual_fallback
+
+        # Ints stored in Statsig (e.g. a value saved as `1` rather than `1.0`) are valid
+        # floats — coerce them. `bool` subclasses `int` in Python, so exclude it.
+        if isinstance(res, (int, float)) and not isinstance(res, bool):
+            self._log_layer_param_exposure(param_name)
+            return float(res)
+
+        _log_error(
             "Layer",
-            self.__value,
-            param_name,
-            actual_fallback,
-            self._log_layer_param_exposure,
+            f"Type mismatch - '{self.name}.{param_name}'. Expected {type(actual_fallback)}, got {type(res)}",
         )
+        return actual_fallback
 
     def get_bool(self, param_name: str, fallback: bool) -> bool:
         return self._get_typed(

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/statsig-pyo3/src/pyo_utils.rs

@@ -260,6 +260,10 @@ fn py_any_ref_to_dynamic_value(value: &Bound<'_, PyAny>) -> Option<DynamicValue>
         return Some(DynamicValue::from(int));
     }
 
+    if let Some(float) = try_as_overflowing_int(value) {
+        return Some(DynamicValue::from(float));
+    }
+
     if let Some(list) = try_as_list(value) {
         return Some(DynamicValue::from(list));
     }
@@ -349,6 +353,17 @@ fn try_as_int<'py>(value: &'py Bound<'py, PyAny>) -> Option<i64> {
     Some(value)
 }
 
+// Python ints have arbitrary precision; values above `i64::MAX` fail `try_as_int`. Fall
+// back to f64 (lossy above 2^53) so the entry is preserved instead of dropped — matches
+// the JS bridge, which always uses doubles. Only meaningful after `try_as_int`.
+fn try_as_overflowing_int<'py>(value: &'py Bound<'py, PyAny>) -> Option<f64> {
+    if !PyInt::type_check(value) {
+        return None;
+    }
+
+    value.extract::<f64>().ok()
+}
+
 fn try_as_float<'py>(value: &'py Bound<'py, PyAny>) -> Option<f64> {
     if !PyFloat::type_check(value) {
         return None;

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/statsig-pyo3/tests/test_get_dynamic_config.py

@@ -61,6 +61,18 @@ def test_dynamic_config_get_methods(statsig_setup):
     assert "non_existent_key" not in config.value
 
 
+def test_get_float_coerces_int_param(statsig_setup):
+    statsig = statsig_setup
+    config = statsig.get_dynamic_config(StatsigUser("my_user"), "big_number")
+
+    # `rar` is stored as an int (9999999999). get_float should coerce to float
+    # rather than returning the fallback. Mirrors the user-reported behavior where
+    # a Statsig param saved as `1` was being skipped by get_float(name, 0.99).
+    result = config.get_float("rar", 0.99)
+    assert result == 9999999999.0
+    assert isinstance(result, float)
+
+
 def test_dynamic_config_typed_get_methods(statsig_setup):
     statsig = statsig_setup
     config = statsig.get_dynamic_config(StatsigUser("my_user"), "operating_system_config")

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/statsig-pyo3/tests/test_statsig_user.py

@@ -97,7 +97,9 @@ def test_various_custom_attr_types():
     assert custom["big_int"] == sys.maxsize
     assert isinstance(custom["big_int"], int)
     assert isinstance(custom["too_big_float"], float)
-    assert custom.get("too_big_int") is None
+    # Python ints that overflow i64 are kept as f64 (lossy) rather than dropped.
+    assert isinstance(custom["too_big_int"], float)
+    assert custom["too_big_int"] == float(999999999999999999999999999999)
 
     assert isinstance(custom["arr"][0], bool)
     assert isinstance(custom["arr"][1], str)

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/statsig-rust/Cargo.toml

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

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/statsig-rust/src/evaluation/evaluator.rs

@@ -125,7 +125,7 @@ impl Evaluator {
             }
 
             if evaluate_config_delegate(ctx, rule)? {
-                ctx.finalize_evaluation(spec, Some(rule));
+                ctx.finalize_evaluation(spec, None);
                 return Ok(Recognition::Recognized);
             }
 

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/statsig-rust/src/specs_response/proto_specs.rs

@@ -707,7 +707,9 @@ fn rules_from_pb(rules: Vec<pb::Rule>) -> Result<Vec<Rule>, StatsigErr> {
         .map(|pb_rule| {
             let rule = Rule {
                 name: InternedString::from_string(pb_rule.name),
-                pass_percentage: pb_rule.pass_percentage as f64,
+                pass_percentage: pb_rule
+                    .pass_percentage_float
+                    .unwrap_or(pb_rule.pass_percentage as f64),
                 id: InternedString::from_string(pb_rule.id),
                 salt: pb_rule.salt.map(InternedString::from_string),
                 conditions: pb_rule
@@ -907,9 +909,76 @@ mod tests {
             is_experiment_group: None,
             is_control_group: None,
             sampling_rate: Some(201.0),
+            pass_percentage_float: None,
         }])
         .expect("protobuf rule should parse");
 
         assert_eq!(rules[0].sampling_rate, Some(201));
     }
+
+    #[test]
+    fn rules_from_pb_prefers_float_pass_percentage() {
+        let rules = rules_from_pb(vec![pb::Rule {
+            name: "rule".to_string(),
+            pass_percentage: 0,
+            id: "rule-id".to_string(),
+            salt: None,
+            conditions: vec![],
+            id_type: None,
+            return_value: None,
+            group_name: None,
+            config_delegate: None,
+            is_experiment_group: None,
+            is_control_group: None,
+            sampling_rate: None,
+            pass_percentage_float: Some(0.5),
+        }])
+        .expect("protobuf rule should parse");
+
+        assert_eq!(rules[0].pass_percentage, 0.5);
+    }
+
+    #[test]
+    fn rules_from_pb_respects_explicit_zero_float_pass_percentage() {
+        let rules = rules_from_pb(vec![pb::Rule {
+            name: "rule".to_string(),
+            pass_percentage: 100,
+            id: "rule-id".to_string(),
+            salt: None,
+            conditions: vec![],
+            id_type: None,
+            return_value: None,
+            group_name: None,
+            config_delegate: None,
+            is_experiment_group: None,
+            is_control_group: None,
+            sampling_rate: None,
+            pass_percentage_float: Some(0.0),
+        }])
+        .expect("protobuf rule should parse");
+
+        assert_eq!(rules[0].pass_percentage, 0.0);
+    }
+
+    #[test]
+    fn rules_from_pb_falls_back_to_legacy_pass_percentage() {
+        let rules = rules_from_pb(vec![pb::Rule {
+            name: "rule".to_string(),
+            pass_percentage: 42,
+            id: "rule-id".to_string(),
+            salt: None,
+            conditions: vec![],
+            id_type: None,
+            return_value: None,
+            group_name: None,
+            config_delegate: None,
+            is_experiment_group: None,
+            is_control_group: None,
+            sampling_rate: None,
+            pass_percentage_float: None,
+        }])
+        .expect("protobuf rule should parse");
+
+        assert_eq!(rules[0].pass_percentage, 42.0);
+    }
 }

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/statsig-rust/src/specs_response/statsig_config_specs.rs

@@ -60,6 +60,7 @@ pub struct Spec {
 pub struct Rule {
     #[prost(string, tag = "1")]
     pub name: ::prost::alloc::string::String,
+    /// Legacy (See pass_percentage_float)
     #[prost(uint32, tag = "2")]
     pub pass_percentage: u32,
     #[prost(string, tag = "3")]
@@ -82,6 +83,8 @@ pub struct Rule {
     pub is_control_group: ::core::option::Option<bool>,
     #[prost(float, optional, tag = "12")]
     pub sampling_rate: ::core::option::Option<f32>,
+    #[prost(double, optional, tag = "13")]
+    pub pass_percentage_float: ::core::option::Option<f64>,
 }
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Condition {

{statsig_python_core-0.19.3b2604211739 → statsig_python_core-0.19.4}/statsig-rust/src/statsig_metadata.rs

@@ -10,7 +10,7 @@ lazy_static! {
     static ref STATSIG_METADATA: RwLock<StatsigMetadata> = RwLock::new(StatsigMetadata::new());
 }
 
-pub const SDK_VERSION: &str = "0.19.3-beta.2604211739";
+pub const SDK_VERSION: &str = "0.19.4";
 
 const TAG: &str = stringify!(StatsigMetadata);