statsig-python-core 0.17.3b2603290312__tar.gz → 0.18.0__tar.gz

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/Cargo.lock

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

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/Cargo.toml

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

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/PKG-INFO

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

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/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(user, name, options)
+        raw = super()._INTERNAL_get_feature_gate_as_dict(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(user, name, options)
+        raw = super()._INTERNAL_get_dynamic_config_as_dict(user, name, options)
         return DynamicConfig(name, raw)
 
     def get_experiment(

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/py_src/statsig_python_core/statsig_python_core.pyi

@@ -178,11 +178,13 @@ 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) -> dict: ...
+    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 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) -> dict: ...
+    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 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) -> dict: ...
+    def _INTERNAL_get_experiment(self, user: StatsigUser, name: builtins.str, options: typing.Optional[ExperimentEvaluationOptions] = None) -> builtins.str: ...
     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.17.3b2603290312 → statsig_python_core-0.18.0}/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: dict):
+    def __init__(self, name: str, raw: str):
         try:
-            data = raw or {}
+            data = json.loads(raw) or {}
             super().__init__(name, data, "Experiment")
             self.group_name = data.get("groupName")
         except Exception as error:

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

@@ -3,7 +3,6 @@ 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.17.3b2603290312 → statsig_python_core-0.18.0}/statsig-pyo3/src/pyo_utils.rs

@@ -62,6 +62,16 @@ 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 {
@@ -101,6 +111,85 @@ 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.17.3b2603290312 → statsig_python_core-0.18.0}/statsig-pyo3/src/statsig_base_py.rs

@@ -1,7 +1,4 @@
-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::pyo_utils::{map_to_py_dict_direct, py_dict_to_json_value_map};
 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;
@@ -16,13 +13,11 @@ use crate::{
     statsig_user_py::StatsigUserPy,
 };
 use parking_lot::Mutex;
-use pyo3::{
-    call::PyCallArgs,
-    prelude::*,
-    types::{PyDict, PyModule},
-};
+use pyo3::{call::PyCallArgs, prelude::*, types::PyDict};
 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,
@@ -246,19 +241,35 @@ 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>,
-    ) -> PyResult<Py<PyDict>> {
+    ) -> String {
         self.inner.use_raw_feature_gate_with_options(
             &user.inner,
             name,
             options.map_or(FeatureGateEvaluationOptions::default(), |o| o.into()),
-            |raw| raw_gate_to_py_dict(py, raw),
+            |raw| raw.unperformant_to_json_string(),
         )
     }
 
+    #[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);
@@ -268,19 +279,35 @@ 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>,
-    ) -> PyResult<Py<PyDict>> {
+    ) -> String {
         self.inner.use_raw_dynamic_config_with_options(
             &user.inner,
             name,
             options.map_or(DynamicConfigEvaluationOptions::default(), |o| o.into()),
-            |raw| raw_dynamic_config_to_py_dict(py, raw),
+            |raw| raw.unperformant_to_json_string(),
         )
     }
 
+    #[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,
@@ -299,7 +326,7 @@ impl StatsigBasePy {
         name: &str,
         options: Option<ExperimentEvaluationOptionsPy>,
         py: Python,
-    ) -> PyResult<Py<PyDict>> {
+    ) -> String {
         let mut options_actual = options
             .as_ref()
             .map_or(ExperimentEvaluationOptions::default(), |o| o.into());
@@ -310,7 +337,7 @@ impl StatsigBasePy {
 
         self.inner
             .use_raw_experiment_with_options(&user.inner, name, options_actual, |raw| {
-                raw_experiment_to_py_dict(py, raw)
+                raw.unperformant_to_json_string()
             })
     }
 
@@ -578,6 +605,41 @@ 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))
 }

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/statsig-pyo3/tests/test_data_store.py

@@ -28,8 +28,6 @@ if "time" in updated_dcs_json_data:
 
 
 class MockDataStore(DataStore):
-    VERBOSE = False
-
     def __init__(self, test_param: str = ""):
         super().__init__()
         self.test_param = test_param
@@ -47,34 +45,28 @@ class MockDataStore(DataStore):
 
     def initialize(self):
         self.init_called = True
-        self._log("Initializing MockDataStore")
+        print("Initializing MockDataStore")
 
     def shutdown(self):
-        self._log("Shutting down MockDataStore")
+        print("Shutting down MockDataStore")
 
     def get(self, key: str) -> Optional[DataStoreResponse]:
-        self._log(f"Getting value for key: {key}")
+        print(f"Getting value for key: {key}")
         self.get_called_count += 1
         return DataStoreResponse(result=dcs_content, time=1234567890)
 
     def set(self, key: str, value: str, time: Optional[int] = None):
         self.content_set = value
-        self._log(f"Setting value for key: {key}")
+        print(f"Setting value for key: {key}")
 
     def support_polling_updates_for(self, key: str) -> bool:
-        self._log(
+        print(
             f"Checking if polling updates are supported for key: {key}: should_poll={self.should_poll}"
         )
         return self.should_poll
 
-    def _log(self, message: str):
-        if self.VERBOSE:
-            print(message)
-
 
 class MockBytesDataStore(DataStore):
-    VERBOSE = False
-
     def __init__(self, test_param: str = ""):
         super().__init__()
         self.test_param = test_param
@@ -95,10 +87,10 @@ class MockBytesDataStore(DataStore):
 
     def initialize(self):
         self.init_called = True
-        self._log("Initializing MockBytesDataStore")
+        print("Initializing MockBytesDataStore")
 
     def shutdown(self):
-        self._log("Shutting down MockBytesDataStore")
+        print("Shutting down MockBytesDataStore")
 
     def get(self, key: str) -> Optional[DataStoreResponse]:
         self.get_called_count += 1
@@ -106,31 +98,27 @@ class MockBytesDataStore(DataStore):
 
     def set(self, key: str, value: str, time: Optional[int] = None):
         self.set_called_count += 1
-        self._log(f"Setting value for key via string path: {key}")
+        print(f"Setting value for key via string path: {key}")
 
     def get_bytes(self, key: str) -> Optional[DataStoreBytesResponse]:
-        self._log(f"Getting bytes for key: {key}")
+        print(f"Getting bytes for key: {key}")
         self.get_bytes_called_count += 1
         return DataStoreBytesResponse(result=eval_proj_protobuf, time=1234567890)
 
     def set_bytes(self, key: str, value: bytes, time: Optional[int] = None):
         self.content_set = value
         self.set_bytes_called_count += 1
-        self._log(f"Setting bytes for key: {key}")
+        print(f"Setting bytes for key: {key}")
 
     def supports_bytes(self) -> bool:
         return True
 
     def support_polling_updates_for(self, key: str) -> bool:
-        self._log(
+        print(
             f"Checking if polling updates are supported for key: {key}: should_poll={self.should_poll}"
         )
         return self.should_poll
 
-    def _log(self, message: str):
-        if self.VERBOSE:
-            print(message)
-
 
 @pytest.fixture
 def statsig_setup(httpserver: HTTPServer):

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/statsig-pyo3/tests/test_feature_gate_serialization.py

@@ -47,7 +47,7 @@ def test_feature_gate_to_py_dict_round_trip_preserves_data(statsig_setup):
     user = StatsigUser("a-user")
     gate_name = "test_public"
 
-    raw_from_json = statsig._INTERNAL_get_feature_gate(user, gate_name)
+    raw_from_json = json.loads(statsig._INTERNAL_get_feature_gate(user, gate_name))
     expected_payload = {
         "name": raw_from_json.get("name"),
         "value": raw_from_json.get("value"),
@@ -60,3 +60,4 @@ def test_feature_gate_to_py_dict_round_trip_preserves_data(statsig_setup):
     expected_gate = FeatureGate(gate_name, expected_payload)
 
     assert gate.to_dict() == expected_gate.to_dict()
+

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/statsig-pyo3/tests/test_get_dynamic_config.py

@@ -2,7 +2,6 @@
 Tests focused on get_dynamic_config API.
 Verifies that dynamicConfig.value is a valid JSON object (dict) and tests all related functionality.
 """
-
 import json
 import pytest
 from statsig_python_core import DynamicConfig, Statsig, StatsigOptions, StatsigUser
@@ -68,7 +67,7 @@ def test_dynamic_config_to_py_dict_round_trip_preserves_data(statsig_setup):
 
     # get_dynamic_config performs:
     # Rust DynamicConfig -> dynamic_config_to_py_dict -> Python DynamicConfig
-    raw_from_json = statsig._INTERNAL_get_dynamic_config(user, config_name)
+    raw_from_json = json.loads(statsig._INTERNAL_get_dynamic_config(user, config_name))
     expected_rule_id = raw_from_json.get("rule_id", raw_from_json.get("ruleID"))
     expected_id_type = raw_from_json.get("id_type", raw_from_json.get("idType"))
     config = statsig.get_dynamic_config(user, config_name)

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/statsig-pyo3/tests/test_layer_serialization.py

@@ -33,14 +33,11 @@ def test_layer_value_is_json_dict(statsig_setup):
 
     value = layer.get_value()
     assert isinstance(value, dict)
-    assert "a_string" in value
-    assert layer.get_string("a_string", "ERR") != "ERR"
 
     json_str = json.dumps(value)
     parsed = json.loads(json_str)
     assert parsed == value
 
-
 def test_layer_to_dict_is_json_serializable(statsig_setup):
     statsig = statsig_setup
     layer = statsig.get_layer(StatsigUser("my_user"), "layer_with_many_params")

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/statsig-pyo3/tests/test_observability_client.py

@@ -19,11 +19,9 @@ class MockObservabilityClient(ObservabilityClient):
     init_called = False
     dist_called = False
     error_called = False
-    metrics: List[
-        Tuple[str, str, Any, Optional[Dict[str, str]]]
-    ] = []  # Stores (type, metric_name, value, tags)
-
-    VERBOSE = False
+    metrics: List[Tuple[str, str, Any, Optional[Dict[str, str]]]] = (
+        []
+    )  # Stores (type, metric_name, value, tags)
 
     def __new__(cls, test_param: str = ""):
         instance = super().__new__(cls)
@@ -32,40 +30,35 @@ class MockObservabilityClient(ObservabilityClient):
 
     def init(self) -> None:
         self.init_called = True
-
-        self._log("Initializing ExampleObservationClient")
+        print("Initializing ExampleObservationClient")
 
     def increment(
         self, metric_name: str, value: int = 1, tags: Optional[Dict[str, str]] = None
     ) -> None:
-        self._log(f"Incrementing {metric_name} by {value} with tags {tags}")
+        print(f"Incrementing {metric_name} by {value} with tags {tags}")
         self.metrics.append(("increment", metric_name, value, tags))
 
     def gauge(
         self, metric_name: str, value: float, tags: Optional[Dict[str, str]] = None
     ) -> None:
-        self._log(f"Gauging {metric_name} by {value} with tags {tags}")
+        print(f"Gauging {metric_name} by {value} with tags {tags}")
         self.metrics.append(("gauge", metric_name, value, tags))
 
     def dist(
         self, metric_name: str, value: float, tags: Optional[Dict[str, str]] = None
     ) -> None:
-        self._log(f"Distribution {metric_name} by {value} with tags {tags}")
+        print(f"Distribution {metric_name} by {value} with tags {tags}")
         self.dist_called = True
         self.metrics.append(("distribution", metric_name, value, tags))
 
     def error(self, tag: str, error: str) -> None:
-        self._log(f"Error callback for {tag}: {error}")
+        print(f"Error callback for {tag}: {error}")
         self.error_called = True
         self.metrics.append(("error", tag, error, None))
 
     def should_enable_high_cardinality_for_this_tag(self, tag):
         return True
 
-    def _log(self, message: str):
-        if self.VERBOSE:
-            print(message)
-
 
 @pytest.fixture
 def statsig_setup(httpserver: HTTPServer):

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/statsig-rust/Cargo.toml

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

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/statsig-rust/src/evaluation/dynamic_returnable.rs

@@ -66,22 +66,6 @@ impl DynamicReturnable {
         }
     }
 
-    pub fn get_serde_map(&self) -> Option<serde_json::Map<String, JsonValue>> {
-        let bytes = match &self.value {
-            DynamicReturnableValue::JsonPointer(bytes) => bytes.get().as_bytes(),
-            DynamicReturnableValue::JsonStatic(bytes) => bytes.get().as_bytes(),
-            _ => return None,
-        };
-
-        match serde_json::from_slice(bytes) {
-            Ok(json) => Some(json),
-            Err(e) => {
-                log_e!(TAG, "Failed to parse json. Error: {}", e);
-                None
-            }
-        }
-    }
-
     pub fn get_json(&self) -> Option<HashMap<String, JsonValue>> {
         let bytes = match &self.value {
             DynamicReturnableValue::JsonPointer(bytes) => bytes.get().as_bytes(),

{statsig_python_core-0.17.3b2603290312 → statsig_python_core-0.18.0}/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.17.3-beta.2603290312";
+pub const SDK_VERSION: &str = "0.18.0";
 
 const TAG: &str = stringify!(StatsigMetadata);