statsig-python-core 0.20.1rc2607140134__tar.gz → 0.20.2__tar.gz

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/Cargo.lock

@@ -2902,7 +2902,7 @@ dependencies = [
 
 [[package]]
 name = "sigstat-grpc"
-version = "0.20.1-rc.2607140134"
+version = "0.20.2"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2994,7 +2994,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.20.1-rc.2607140134"
+version = "0.20.2"
 dependencies = [
  "async-trait",
  "napi",
@@ -3009,7 +3009,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.20.1-rc.2607140134"
+version = "0.20.2"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3024,7 +3024,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.20.1-rc.2607140134"
+version = "0.20.2"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3075,7 +3075,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.20.1-rc.2607140134"
+version = "0.20.2"
 dependencies = [
  "async-trait",
  "parking_lot",
@@ -3088,7 +3088,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.20.1-rc.2607140134"
+version = "0.20.2"
 dependencies = [
  "async-trait",
  "cbindgen",

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/Cargo.toml

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

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/PKG-INFO

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

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/py_src/statsig_python_core/statsig.py

@@ -12,7 +12,13 @@ from statsig_python_core import (
 )
 from typing import Optional
 from .error_boundary import ErrorBoundary
-from .statsig_types import DynamicConfig, FeatureGate, Experiment, Layer
+from .statsig_types import (
+    DynamicConfig,
+    Experiment,
+    ExperimentGroupsResult,
+    FeatureGate,
+    Layer,
+)
 import atexit
 
 
@@ -126,6 +132,10 @@ class Statsig(StatsigBasePy):
         )
         return Experiment(experiment_name, raw)
 
+    def get_experiment_groups(self, experiment_name: str) -> ExperimentGroupsResult:
+        raw = super()._INTERNAL_get_experiment_groups(experiment_name)
+        return ExperimentGroupsResult(raw)
+
     def get_layer(
         self,
         user: StatsigUser,

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/py_src/statsig_python_core/statsig_python_core.pyi

@@ -221,6 +221,7 @@ class StatsigBasePy:
     def _INTERNAL_get_experiment(self, user: StatsigUser, name: builtins.str, options: typing.Optional[ExperimentEvaluationOptions] = None) -> dict: ...
     def _INTERNAL_get_experiment_by_group_name(self, experiment_name: builtins.str, group_name: builtins.str) -> dict: ...
     def _INTERNAL_get_experiment_by_group_id_advanced(self, experiment_name: builtins.str, group_id: builtins.str) -> dict: ...
+    def _INTERNAL_get_experiment_groups(self, experiment_name: builtins.str) -> dict: ...
     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) -> dict: ...
     def _INTERNAL_log_layer_param_exposure(self, raw: LayerParamExposureData, param_name: builtins.str) -> None: ...

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/py_src/statsig_python_core/statsig_types.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Callable, Optional
+from typing import Any, Callable, List, Optional
 
 
 def _log_error(tag: str, message: str):
@@ -334,3 +334,55 @@ class Layer(BaseEvaluation):
             return
 
         self.__exposure_func(param_name)
+
+
+class ExperimentGroup:
+    group_name: str
+    rule_id: str
+    id_type: str
+    return_value: dict
+
+    def __init__(self, raw: dict):
+        try:
+            data = raw or {}
+            self.group_name = data.get("group_name") or ""
+            self.rule_id = data.get("rule_id") or ""
+            self.id_type = data.get("id_type") or ""
+            self.return_value = data.get("return_value") or {}
+        except Exception as error:
+            self.group_name = ""
+            self.rule_id = ""
+            self.id_type = ""
+            self.return_value = {}
+            _log_error("ExperimentGroup", f"Failed to parse. {error}")
+
+    def to_dict(self) -> dict:
+        return {
+            "group_name": self.group_name,
+            "rule_id": self.rule_id,
+            "id_type": self.id_type,
+            "return_value": self.return_value,
+        }
+
+
+class ExperimentGroupsResult:
+    is_experiment_active: Optional[bool]
+    groups: List[ExperimentGroup]
+
+    def __init__(self, raw: dict):
+        try:
+            data = raw or {}
+            self.is_experiment_active = data.get("is_experiment_active")
+            self.groups = [
+                ExperimentGroup(group) for group in data.get("groups") or []
+            ]
+        except Exception as error:
+            self.is_experiment_active = None
+            self.groups = []
+            _log_error("ExperimentGroupsResult", f"Failed to parse. {error}")
+
+    def to_dict(self) -> dict:
+        return {
+            "is_experiment_active": self.is_experiment_active,
+            "groups": [group.to_dict() for group in self.groups],
+        }

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-pyo3/src/pyo_utils.rs

@@ -65,10 +65,7 @@ pub fn map_to_py_dict(py: Python, map: &HashMap<String, Value>) -> Py<PyAny> {
 pub fn py_list_to_list(py_list: &Bound<PyList>) -> PyResult<Vec<String>> {
     let mut converted_list = Vec::new();
     for value in py_list {
-        match value.extract::<String>() {
-            Ok(s) => converted_list.push(s),
-            Err(e) => return Err(e),
-        }
+        converted_list.push(value.extract::<String>()?);
     }
     Ok(converted_list)
 }

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-pyo3/src/statsig_base_py.rs

@@ -19,6 +19,7 @@ use crate::{
 use parking_lot::Mutex;
 use pyo3::{
     call::PyCallArgs,
+    exceptions::PyValueError,
     prelude::*,
     types::{PyDict, PyModule},
 };
@@ -341,6 +342,21 @@ impl StatsigBasePy {
         json_string_to_py_dict(py, &raw)
     }
 
+    #[pyo3(name="_INTERNAL_get_experiment_groups", signature = (experiment_name))]
+    pub fn _internal_get_experiment_groups(
+        &self,
+        experiment_name: &str,
+        py: Python,
+    ) -> PyResult<Py<PyDict>> {
+        let result = self.inner.get_experiment_groups(experiment_name);
+
+        let json = serde_json::to_string(&result).map_err(|e| {
+            PyValueError::new_err(format!("Failed to serialize experiment groups: {e}"))
+        })?;
+
+        json_string_to_py_dict(py, &json)
+    }
+
     #[pyo3(signature = (user, name))]
     pub fn manually_log_experiment_exposure(
         &self,
@@ -618,10 +634,11 @@ fn extract_event_metadata(metadata: Option<Bound<PyDict>>) -> Option<HashMap<Str
     metadata.map(|m| py_dict_to_json_value_map(&m))
 }
 
-// The group-targeting experiment getters only expose a JSON-string core
-// method (the camelCase ExperimentRaw shape), so parse it into a PyDict here
-// via Python's json module. The resulting keys (ruleID, idType, groupName,
-// value, details) match what the Python Experiment type reads.
+// Parses a JSON string from the core into a PyDict via Python's json module.
+// Used by the group-targeting getters (camelCase ExperimentRaw shape, whose
+// keys ruleID/idType/groupName/value/details match what the Python Experiment
+// type reads) and by get_experiment_groups (snake_case ExperimentGroupsResult
+// shape read by the Python ExperimentGroupsResult type).
 fn json_string_to_py_dict(py: Python, json_str: &str) -> PyResult<Py<PyDict>> {
     let json_module = PyModule::import(py, "json")?;
     let parsed = json_module.call_method1("loads", (json_str,))?;

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-pyo3/src/statsig_options_py.rs

@@ -479,6 +479,8 @@ fn create_inner_statsig_options(
         use_third_party_ua_parser: opts.use_third_party_ua_parser,
         disable_disk_access: opts.disable_disk_access,
         experimental_flags: opts.experimental_flags,
+        // Not exposed via the Python binding yet; defaults to the core value.
+        dcs_delta_no_progress_threshold: None,
     }
 }
 

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-pyo3/src/statsig_persistent_storage_override_adapter_py.rs

@@ -169,12 +169,8 @@ fn convert_py_lists_to_secondary_exposures(
 ) -> PyResult<Vec<SecondaryExposure>> {
     let mut exposures = Vec::new();
     for item in py_list {
-        match item.extract::<Bound<PyDict>>() {
-            Ok(e) => {
-                exposures.push(convert_py_dict_to_secondary_exposure(&e)?);
-            }
-            Err(e) => return Err(e.into()),
-        }
+        let e = item.extract::<Bound<PyDict>>()?;
+        exposures.push(convert_py_dict_to_secondary_exposure(&e)?);
     }
 
     Ok(exposures)

statsig_python_core-0.20.2/statsig-pyo3/tests/test_get_experiment_groups.py

@@ -0,0 +1,89 @@
+from statsig_python_core import (
+    ExperimentGroup,
+    ExperimentGroupsResult,
+    Statsig,
+    StatsigOptions,
+)
+from pytest_httpserver import HTTPServer
+import json
+from utils import get_test_data_resource
+import pytest
+
+
+@pytest.fixture
+def statsig_setup(httpserver: HTTPServer):
+    dcs_content = get_test_data_resource("eval_proj_dcs.json")
+    json_data = json.loads(dcs_content)
+
+    httpserver.expect_request(
+        "/v2/download_config_specs/secret-key.json"
+    ).respond_with_json(json_data)
+
+    httpserver.expect_request("/v1/log_event").respond_with_json({"success": True})
+
+    options = StatsigOptions(
+        specs_url=httpserver.url_for("/v2/download_config_specs"),
+        log_event_url=httpserver.url_for("/v1/log_event"),
+    )
+    statsig = Statsig("secret-key", options)
+
+    statsig.initialize().wait()
+
+    yield statsig
+
+    # Teardown
+    statsig.shutdown().wait()
+
+
+def test_get_experiment_groups(statsig_setup):
+    statsig = statsig_setup
+    result = statsig.get_experiment_groups("test_experiment_no_targeting")
+
+    assert result.is_experiment_active is True
+
+    groups_by_name = {group.group_name: group for group in result.groups}
+
+    # Only the experiment group rules are returned (the layerAssignment rule is excluded).
+    assert sorted(groups_by_name.keys()) == ["Control", "Test", "Test2"]
+    assert groups_by_name["Control"].return_value == {"value": "control"}
+    assert groups_by_name["Control"].rule_id == "54QJztEPRLXK7ZCvXeY9q4"
+    assert groups_by_name["Control"].id_type == "userID"
+    assert groups_by_name["Test"].return_value == {"value": "test_1"}
+    assert groups_by_name["Test2"].return_value == {"value": "test_2"}
+
+
+def test_get_experiment_groups_returns_typed_result(statsig_setup):
+    statsig = statsig_setup
+    result = statsig.get_experiment_groups("test_experiment_no_targeting")
+
+    assert isinstance(result, ExperimentGroupsResult)
+    assert all(isinstance(group, ExperimentGroup) for group in result.groups)
+
+
+def test_get_experiment_groups_returns_none_for_unknown_experiment(statsig_setup):
+    statsig = statsig_setup
+    result = statsig.get_experiment_groups("nonexistent_experiment")
+
+    assert result.is_experiment_active is None
+    assert result.groups == []
+
+
+def test_get_experiment_groups_returns_none_for_dynamic_config(statsig_setup):
+    statsig = statsig_setup
+    # Dynamic configs are not experiments; is_experiment_active should be None.
+    result = statsig.get_experiment_groups("test_max_dynamic_config_size_again")
+
+    assert result.is_experiment_active is None
+    assert result.groups == []
+
+
+def test_get_experiment_groups_returns_groups_for_inactive_experiment(statsig_setup):
+    statsig = statsig_setup
+    # test_switchback has isActive: false; groups are still returned along with the flag.
+    result = statsig.get_experiment_groups("test_switchback")
+
+    assert result.is_experiment_active is False
+
+    # Only the experiment group rules are returned (non-group rules are excluded).
+    group_names = sorted(group.group_name for group in result.groups)
+    assert group_names == ["Control", "Test"]

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/Cargo.toml

@@ -41,7 +41,7 @@ serde_json = { version = "1.0.143", features = [
 ] }
 serde_with = "3.4.0"
 sha2 = "0.10.8"
-sigstat-grpc = { path = "../statsig-grpc", version = "0.20.1-rc.2607140134", optional = true }
+sigstat-grpc = { path = "../statsig-grpc", version = "0.20.2", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/evaluation/country_lookup.rs

@@ -128,12 +128,12 @@ impl CountryLookup {
             return None;
         }
 
-        let ip = match user.get_user_value(&Some(DynamicString::from(IP.to_string()))) {
-            Some(v) => match &v.string_value {
+        let ip = {
+            let v = user.get_user_value(&Some(DynamicString::from(IP.to_string())))?;
+            match &v.string_value {
                 Some(s) => &s.value,
                 _ => return None,
-            },
-            None => return None,
+            }
         };
 
         Self::lookup(ip, evaluator_context)

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/evaluation/user_agent_parsing/statsig_uaparser/__tests__/test_ua_parser_os.rs

@@ -70,6 +70,16 @@ fn os_name_parsing_macos_no_x() {
     assert_eq!(os_version, Some("26.2.0".to_string()));
 }
 
+#[test]
+fn os_name_parsing_ipados() {
+    let user_agent = "Whatnot v26.26.0 (42), iPadOS 26.5, iPad13,19";
+    let os = UaParser::parse_os(user_agent);
+
+    assert_eq!(os.name, "iOS");
+    let os_version = os.version.get_version_string();
+    assert_eq!(os_version, Some("26.5".to_string()));
+}
+
 #[test]
 fn os_name_parsing_ubuntu() {
     let user_agent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/604.1 (KHTML, like Gecko) Version/11.0 Safari/604.1 Ubuntu/17.04 (3.24.1-0ubuntu1) Epiphany/3.24.1"; // |Ubuntu|17|04|None|None|Epiphany|3|24|1|None

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/evaluation/user_agent_parsing/statsig_uaparser/tokenizer.rs

@@ -58,6 +58,12 @@ impl Tokenizer {
 
                 win.slide_window_by(1);
             }
+            // iPadOS
+            else if curr == "iPadOS" {
+                result.add_possible_os_tag("iOS", consume_if_numeric(&mut win, next1));
+                result.ios_hint = true;
+                win.slide_window_by(1);
+            }
             // iPad
             else if curr.starts_with("iPad") {
                 result.ios_hint = true;

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/evaluation/user_agent_parsing/ua_parser.rs

@@ -42,12 +42,12 @@ impl UserAgentParser {
             _ => return None,
         };
 
-        let user_agent = match user.get_user_value(&USER_AGENT_STRING) {
-            Some(v) => match &v.string_value {
+        let user_agent = {
+            let v = user.get_user_value(&USER_AGENT_STRING)?;
+            match &v.string_value {
                 Some(s) => &s.value,
                 _ => return None,
-            },
-            None => return None,
+            }
         };
 
         if user_agent.len() > 1000 {

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/gcir/dynamic_configs_processor.rs

@@ -82,7 +82,7 @@ pub(crate) fn get_dynamic_config_evaluations(
                 .get(config_name)
                 .and_then(|c| c.target_app_ids.as_ref()),
             &context.app_id,
-            &options.client_sdk_key,
+            options,
         ) {
             continue;
         }
@@ -161,7 +161,7 @@ pub(crate) fn get_dynamic_config_evaluations_v2(
         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) {
+        if should_filter_config_for_app(target_app_ids, &context.app_id, options) {
             continue;
         }
         context.reset_result();
@@ -261,7 +261,7 @@ pub(crate) fn get_dynamic_config_evaluations_init_v2(
         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) {
+        if should_filter_config_for_app(target_app_ids, &context.app_id, options) {
             continue;
         }
         context.reset_result();

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/gcir/gcir_options.rs

@@ -7,6 +7,7 @@ use crate::{GCIRResponseFormat, HashAlgorithm};
 pub struct ClientInitResponseOptions {
     pub hash_algorithm: Option<HashAlgorithm>,
     pub client_sdk_key: Option<String>,
+    pub target_app_id: Option<String>,
     pub include_local_overrides: Option<bool>,
     pub feature_gate_filter: Option<HashSet<String>>,
     pub experiment_filter: Option<HashSet<String>>,
@@ -24,6 +25,13 @@ impl ClientInitResponseOptions {
     pub(crate) fn get_hash_algorithm(&self) -> &HashAlgorithm {
         self.hash_algorithm.as_ref().unwrap_or(&HashAlgorithm::Djb2)
     }
+
+    // Empty string means unset: bindings without nullable strings (e.g. Go) send "".
+    pub(crate) fn get_target_app_id(&self) -> Option<&String> {
+        self.target_app_id
+            .as_ref()
+            .filter(|target_app_id| !target_app_id.is_empty())
+    }
 }
 
 impl Default for ClientInitResponseOptions {
@@ -31,6 +39,7 @@ impl Default for ClientInitResponseOptions {
         Self {
             hash_algorithm: Some(HashAlgorithm::Djb2),
             client_sdk_key: None,
+            target_app_id: None,
             include_local_overrides: Some(false),
             feature_gate_filter: None,
             experiment_filter: None,

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/gcir/gcir_process_iter.rs

@@ -41,7 +41,7 @@ pub(crate) fn gcir_process_iter<T: GCIRHashable>(
             continue;
         }
 
-        if should_filter_spec_for_app(spec, &context.app_id, &options.client_sdk_key) {
+        if should_filter_spec_for_app(spec, &context.app_id, options) {
             continue;
         }
 

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/gcir/param_stores_processor.rs

@@ -34,11 +34,7 @@ pub(crate) fn get_serializeable_param_stores(
     let mut param_stores = HashMap::new();
 
     for (name, store) in stores {
-        if should_filter_config_for_app(
-            store.target_app_ids.as_ref(),
-            &context.app_id,
-            &options.client_sdk_key,
-        ) {
+        if should_filter_config_for_app(store.target_app_ids.as_ref(), &context.app_id, options) {
             continue;
         }
 

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/gcir/target_app_id_utils.rs

@@ -5,16 +5,20 @@ use crate::{
     ClientInitResponseOptions, DynamicValue, HashAlgorithm,
 };
 
-pub(crate) fn select_app_id_for_gcir<'a>(
-    options: &'a ClientInitResponseOptions,
-    dcs_values: &'a SpecsResponseFull,
+pub(crate) fn select_app_id_for_gcir(
+    options: &ClientInitResponseOptions,
+    dcs_values: &SpecsResponseFull,
     hashing: &HashUtil,
-) -> Option<&'a DynamicValue> {
+) -> Option<DynamicValue> {
+    if let Some(target_app_id) = options.get_target_app_id() {
+        return Some(DynamicValue::from(target_app_id.clone()));
+    }
+
     let mut app_id = dcs_values.app_id.as_ref();
 
     let client_sdk_key = match options.client_sdk_key.as_ref() {
         Some(client_sdk_key) => client_sdk_key,
-        None => return app_id,
+        None => return app_id.cloned(),
     };
 
     if let Some(app_id_value) = &dcs_values.sdk_keys_to_app_ids {
@@ -26,26 +30,25 @@ pub(crate) fn select_app_id_for_gcir<'a>(
         app_id = app_id_value.get(hashed_key);
     }
 
-    app_id
+    app_id.cloned()
 }
 
 pub(crate) fn should_filter_spec_for_app(
     spec: &Spec,
     app_id: &Option<&DynamicValue>,
-    client_sdk_key: &Option<String>,
+    options: &ClientInitResponseOptions,
 ) -> bool {
-    should_filter_config_for_app(spec.target_app_ids.as_ref(), app_id, client_sdk_key)
+    should_filter_config_for_app(spec.target_app_ids.as_ref(), app_id, options)
 }
 
 pub(crate) fn should_filter_config_for_app(
     target_app_ids: Option<&Vec<InternedString>>,
     app_id: &Option<&DynamicValue>,
-    client_sdk_key: &Option<String>,
+    options: &ClientInitResponseOptions,
 ) -> bool {
-    let _client_sdk_key = match client_sdk_key {
-        Some(client_sdk_key) => client_sdk_key,
-        None => return false,
-    };
+    if options.client_sdk_key.is_none() && options.get_target_app_id().is_none() {
+        return false;
+    }
 
     let app_id = match app_id {
         Some(app_id) => app_id,

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/instance_registry.rs

@@ -58,9 +58,9 @@ impl InstanceRegistry {
         // does not outlive this statement) so we never hold a DashMap guard
         // across other registry calls - that is what could otherwise deadlock
         // a sharded map.
-        let any_arc = match REGISTRY.get(id) {
-            Some(entry) => entry.value().clone(),
-            None => return None,
+        let any_arc = {
+            let entry = REGISTRY.get(id)?;
+            entry.value().clone()
         };
 
         match any_arc.downcast::<T>() {

{statsig_python_core-0.20.1rc2607140134 → statsig_python_core-0.20.2}/statsig-rust/src/specs_adapter/mod.rs

@@ -6,7 +6,9 @@ pub use statsig_bootstrap_specs_adapter::StatsigBootstrapSpecsAdapter;
 pub use statsig_customized_specs_adapter::StatsigCustomizedSpecsAdapter;
 #[cfg(feature = "with_grpc")]
 pub use statsig_grpc_specs_adapter::StatsigGrpcSpecsAdapter;
-pub use statsig_http_specs_adapter::{SpecsSyncTrigger, StatsigHttpSpecsAdapter};
+pub use statsig_http_specs_adapter::{
+    SpecsSyncTrigger, StatsigHttpSpecsAdapter, DEFAULT_DCS_DELTA_NO_PROGRESS_THRESHOLD,
+};
 pub use statsig_local_file_specs_adapter::StatsigLocalFileSpecsAdapter;
 
 mod config_spec_background_sync_metrics;