oai-statsig-python-core 0.31.0rc2__tar.gz → 0.31.0rc4__tar.gz

{oai_statsig_python_core-0.31.0rc2 → oai_statsig_python_core-0.31.0rc4}/Cargo.lock

@@ -1730,7 +1730,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-grpc"
-version = "0.31.0-rc.2"
+version = "0.31.0-rc.4"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1745,7 +1745,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-rust"
-version = "0.31.0-rc.2"
+version = "0.31.0-rc.4"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3004,7 +3004,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.31.0-rc.2"
+version = "0.31.0-rc.4"
 dependencies = [
  "async-trait",
  "napi",
@@ -3019,7 +3019,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.31.0-rc.2"
+version = "0.31.0-rc.4"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3034,7 +3034,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.31.0-rc.2"
+version = "0.31.0-rc.4"
 dependencies = [
  "async-trait",
  "cbindgen",

{oai_statsig_python_core-0.31.0rc2 → oai_statsig_python_core-0.31.0rc4}/Cargo.toml

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

{oai_statsig_python_core-0.31.0rc2 → oai_statsig_python_core-0.31.0rc4}/PKG-INFO

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

{oai_statsig_python_core-0.31.0rc2 → oai_statsig_python_core-0.31.0rc4}/statsig-pyo3/src/interned_store_py.rs

@@ -8,11 +8,11 @@ use pyo3::types::PyModule;
 use pyo3::types::PyType;
 use pyo3_stub_gen::derive::*;
 
-use statsig_rust::StatsigRuntime;
 use statsig_rust::interned_values::{
     InternedStore, MmapPreloadReport as RustMmapPreloadReport, MmapReaderMemorySnapshot,
 };
 use statsig_rust::log_e;
+use statsig_rust::{StatsigErr, StatsigRuntime};
 
 const TAG: &str = stringify!(InternStorePy);
 
@@ -152,10 +152,10 @@ impl InternedStorePy {
     }
 
     #[classmethod]
-    pub fn preload_mmap(_cls: &Bound<'_, PyType>, sdk_key: &str) -> PyResult<()> {
+    pub fn preload_mmap(cls: &Bound<'_, PyType>, sdk_key: &str) -> PyResult<()> {
         if let Err(e) = InternedStore::preload_mmap(sdk_key) {
             log_e!(TAG, "Failed to load mmap data: {}", e);
-            return Err(PyRuntimeError::new_err(e.to_string()));
+            return Err(to_python_error(cls.py(), &e));
         }
 
         Ok(())
@@ -178,7 +178,7 @@ impl InternedStorePy {
     #[classmethod]
     #[pyo3(signature = (required_sdk_keys, optional_sdk_keys=None))]
     pub fn preload_mmap_multi(
-        _cls: &Bound<'_, PyType>,
+        cls: &Bound<'_, PyType>,
         required_sdk_keys: Vec<String>,
         optional_sdk_keys: Option<Vec<String>>,
     ) -> PyResult<MmapPreloadReportPy> {
@@ -196,7 +196,7 @@ impl InternedStorePy {
             Ok(report) => Ok(report.into()),
             Err(error) => {
                 log_e!(TAG, "Failed to load mmap data: {}", error);
-                Err(PyRuntimeError::new_err(error.to_string()))
+                Err(to_python_error(cls.py(), &error))
             }
         }
     }
@@ -215,3 +215,16 @@ fn call_completion_event(event: &Py<PyAny>, py: Python) {
         log_e!(TAG, "Failed to set mmap completion event: {}", e);
     }
 }
+
+fn to_python_error(py: Python, error: &StatsigErr) -> PyErr {
+    let message = error.to_string();
+    let exception = PyRuntimeError::new_err(message.clone());
+    let value = exception.value(py);
+    let result = value
+        .setattr("error_name", error.name())
+        .and_then(|_| value.setattr("error_message", message));
+    if let Err(e) = result {
+        log_e!(TAG, "Failed to set interned store error details: {}", e);
+    }
+    exception
+}

oai_statsig_python_core-0.31.0rc4/statsig-pyo3/tests/test_experiment_group_targeting_exposures.py

@@ -0,0 +1,292 @@
+import copy
+import json
+
+import pytest
+from mock_scrapi import MockScrapi
+from statsig_python_core import (
+    BulkEvaluationOptions,
+    DynamicConfigEvaluationOptions,
+    ExperimentEvaluationOptions,
+    FeatureGateEvaluationOptions,
+    LayerEvaluationOptions,
+    Statsig,
+    StatsigOptions,
+    StatsigUser,
+)
+from utils import get_test_data_resource
+
+
+@pytest.fixture
+def targeting_setup(httpserver, request):
+    target, percentage, id_type, disable_all = getattr(
+        request, "param", ("Treatment", 100, "userID", False)
+    )
+    specs = json.loads(get_test_data_resource("eval_proj_dcs.json"))
+    public_gate = copy.deepcopy(specs["feature_gates"]["test_public"])
+    gate = copy.deepcopy(public_gate)
+    gate["rules"][0].update(
+        conditions=["experiment_target"], passPercentage=percentage
+    )
+    nested_gate = copy.deepcopy(public_gate)
+    nested_gate["rules"][0]["conditions"] = ["parent_gate_target"]
+
+    source = copy.deepcopy(specs["dynamic_configs"]["test_experiment_no_targeting"])
+    source["idType"] = id_type
+    source["rules"] = [
+        {
+            "name": "treatment",
+            "id": "treatment",
+            "groupName": "Treatment",
+            "salt": "treatment",
+            "passPercentage": 100,
+            "conditions": ["source_gate_target"],
+            "returnValue": {"value": "treatment"},
+            "idType": id_type,
+            "isExperimentGroup": True,
+        }
+    ]
+    experiment = copy.deepcopy(source)
+    experiment["rules"][0]["conditions"] = ["experiment_target"]
+    config = copy.deepcopy(experiment)
+    config["entity"] = "dynamic_config"
+    config["rules"][0]["isExperimentGroup"] = False
+    layer = copy.deepcopy(config)
+    layer.update(type="layer", entity="layer", explicitParameters=["value"])
+
+    specs["feature_gates"] = {
+        "source_gate": public_gate,
+        "parent_gate": gate,
+        "nested_parent_gate": nested_gate,
+    }
+    specs["dynamic_configs"] = {
+        "source_experiment": source,
+        "parent_experiment": experiment,
+        "parent_config": config,
+    }
+    specs["layer_configs"] = {"parent_layer": layer}
+    specs["experiment_to_layer"] = {}
+    specs["condition_map"]["experiment_target"] = {
+        "type": "experiment_group",
+        "targetValue": [target],
+        "operator": "any",
+        "field": "source_experiment",
+        "additionalValues": {"experiment_name": "source_experiment"},
+        "idType": id_type,
+    }
+    for condition, name in (
+        ("source_gate_target", "source_gate"),
+        ("parent_gate_target", "parent_gate"),
+    ):
+        specs["condition_map"][condition] = {
+            "type": "pass_gate",
+            "targetValue": name,
+            "operator": None,
+            "field": None,
+            "additionalValues": {},
+            "idType": id_type,
+        }
+    specs.pop("checksum", None)
+    mock = MockScrapi(httpserver)
+    mock.stub("/v2/download_config_specs", response=json.dumps(specs), method="GET")
+    mock.stub("/v1/log_event", response='{"success":true}', method="POST")
+    sdk = Statsig(
+        "secret-test-key",
+        StatsigOptions(
+            specs_url=mock.url_for_endpoint("/v2/download_config_specs"),
+            log_event_url=mock.url_for_endpoint("/v1/log_event"),
+            fallback_to_statsig_api=False,
+            enable_id_lists=False,
+            disable_all_logging=disable_all,
+            output_log_level="none",
+        ),
+    )
+    sdk.initialize().wait()
+    user = StatsigUser(
+        "targeting-user" if id_type == "userID" else "",
+        custom_ids={"stableID": "targeting-stable-id"},
+    )
+    yield sdk, mock, user
+    sdk.shutdown().wait()
+
+
+def exposure_events(mock):
+    return [
+        event
+        for event in mock.get_logged_events()
+        if event["eventName"]
+        in {
+            "statsig::gate_exposure",
+            "statsig::config_exposure",
+            "statsig::layer_exposure",
+        }
+    ]
+
+
+def assert_direct_experiment_logs(sdk, mock, user):
+    before = len(exposure_events(mock))
+    experiment = sdk.get_experiment(user, "source_experiment")
+    assert experiment.get_string("value", "missing") == "treatment"
+    sdk.flush_events().wait()
+    events = exposure_events(mock)
+    assert len(events) == before + 1
+    event = events[-1]
+    assert event["eventName"] == "statsig::config_exposure"
+    assert event["metadata"]["config"] == "source_experiment"
+    assert event["metadata"]["ruleID"] == "treatment"
+    assert any(item["gate"] == "source_gate" for item in event["secondaryExposures"])
+
+
+@pytest.mark.parametrize(
+    "targeting_setup,method,name,disabled,expected",
+    [
+        (
+            ("Treatment", 100, "userID", False),
+            "get_feature_gate", "parent_gate", False, True,
+        ),
+        (
+            ("Treatment", 100, "userID", False),
+            "get_feature_gate", "parent_gate", True, True,
+        ),
+        (("Treatment", 100, "userID", False), "check_gate", "parent_gate", True, True),
+        (("Treatment", 0, "userID", False), "check_gate", "parent_gate", False, False),
+        (
+            ("Other", 100, "stableID", False),
+            "get_feature_gate", "parent_gate", False, False,
+        ),
+        (
+            ("Treatment", 100, "stableID", False),
+            "check_gate", "nested_parent_gate", False, True,
+        ),
+    ],
+    indirect=["targeting_setup"],
+)
+def test_gate_targeting_is_not_experiment_participation(
+    targeting_setup, method, name, disabled, expected
+):
+    sdk, mock, user = targeting_setup
+    result = getattr(sdk, method)(
+        user, name, FeatureGateEvaluationOptions(disable_exposure_logging=disabled)
+    )
+    assert (result if method == "check_gate" else result.value) is expected
+    sdk.flush_events().wait()
+    events = exposure_events(mock)
+    assert len(events) == (0 if disabled else 1)
+    if not disabled:
+        assert events[0]["eventName"] == "statsig::gate_exposure"
+        assert events[0]["metadata"]["gate"] == name
+    assert_direct_experiment_logs(sdk, mock, user)
+
+
+@pytest.mark.parametrize("kind", ["config", "experiment", "layer"])
+@pytest.mark.parametrize("disabled", [False, True])
+def test_other_parent_targeting_is_not_experiment_participation(
+    targeting_setup, kind, disabled
+):
+    sdk, mock, user = targeting_setup
+    method, options = {
+        "config": (sdk.get_dynamic_config, DynamicConfigEvaluationOptions),
+        "experiment": (sdk.get_experiment, ExperimentEvaluationOptions),
+        "layer": (sdk.get_layer, LayerEvaluationOptions),
+    }[kind]
+    parent = method(
+        user, f"parent_{kind}", options(disable_exposure_logging=disabled)
+    )
+    if kind == "layer":
+        sdk.flush_events().wait()
+        assert exposure_events(mock) == []
+    assert parent.get_string("value", "missing") == "treatment"
+    sdk.flush_events().wait()
+    events = exposure_events(mock)
+    assert len(events) == (0 if disabled else 1)
+    if not disabled:
+        assert events[0]["metadata"]["config"] == f"parent_{kind}"
+        assert events[0]["eventName"] == (
+            "statsig::layer_exposure" if kind == "layer" else "statsig::config_exposure"
+        )
+    assert_direct_experiment_logs(sdk, mock, user)
+
+
+@pytest.mark.parametrize("kind", ["gate", "config", "experiment", "layer"])
+@pytest.mark.parametrize("release", [False, True])
+def test_bulk_targeting_does_not_log_or_reserve_source_exposure(
+    targeting_setup, kind, release
+):
+    sdk, mock, user = targeting_setup
+    filters = {
+        "feature_gate_filter": [],
+        "dynamic_config_filter": [],
+        "experiment_filter": [],
+        "layer_filter": [],
+    }
+    filter_name, section = {
+        "gate": ("feature_gate_filter", "feature_gates"),
+        "config": ("dynamic_config_filter", "dynamic_configs"),
+        "experiment": ("experiment_filter", "experiments"),
+        "layer": ("layer_filter", "layer_configs"),
+    }[kind]
+    filters[filter_name] = [f"parent_{kind}"]
+    parent = sdk.bulk_evaluate(user, BulkEvaluationOptions(**filters))[section][
+        f"parent_{kind}"
+    ]
+    assert parent["value"] == (True if kind == "gate" else {"value": "treatment"})
+    token = parent["exposureToken"]
+    assert token is not None
+    sdk.flush_events().wait()
+    assert exposure_events(mock) == []
+
+    if release:
+        assert sdk.release_delayed_exposure(token)
+    elif kind == "layer":
+        assert sdk.log_delayed_layer_parameter_exposure(token, "value")
+        assert sdk.log_delayed_layer_parameter_exposure(token, "value")
+    else:
+        assert sdk.log_delayed_exposure(token)
+        assert not sdk.log_delayed_exposure(token)
+    sdk.flush_events().wait()
+    events = exposure_events(mock)
+    assert len(events) == (0 if release else 1)
+    if not release:
+        key = "gate" if kind == "gate" else "config"
+        assert events[0]["metadata"][key] == f"parent_{kind}"
+    assert_direct_experiment_logs(sdk, mock, user)
+
+
+@pytest.mark.parametrize(
+    "targeting_setup",
+    [("Treatment", 100, "userID", False), ("Treatment", 100, "stableID", False)],
+    indirect=True,
+)
+def test_unfiltered_bulk_retains_explicit_experiment_token(targeting_setup):
+    sdk, mock, user = targeting_setup
+    result = sdk.bulk_evaluate(user, BulkEvaluationOptions())
+    sdk.flush_events().wait()
+    assert exposure_events(mock) == []
+    source = result["experiments"]["source_experiment"]
+    assert source["value"] == {"value": "treatment"}
+    assert source["exposureToken"] is not None
+    parent_token = result["feature_gates"]["parent_gate"]["exposureToken"]
+    assert sdk.log_delayed_exposure(parent_token)
+    sdk.flush_events().wait()
+    assert [event["eventName"] for event in exposure_events(mock)] == [
+        "statsig::gate_exposure"
+    ]
+    assert sdk.log_delayed_exposure(source["exposureToken"])
+    sdk.flush_events().wait()
+    events = exposure_events(mock)
+    assert len(events) == 2
+    assert events[-1]["eventName"] == "statsig::config_exposure"
+    assert events[-1]["metadata"]["config"] == "source_experiment"
+
+
+@pytest.mark.parametrize(
+    "targeting_setup", [("Treatment", 100, "stableID", True)], indirect=True
+)
+def test_disabled_logging_bulk_keeps_values_without_exposure_tokens(targeting_setup):
+    sdk, mock, user = targeting_setup
+    result = sdk.bulk_evaluate(user, BulkEvaluationOptions())
+    assert result["feature_gates"]["parent_gate"]["value"] is True
+    assert result["experiments"]["source_experiment"]["value"] == {"value": "treatment"}
+    for section in ("feature_gates", "dynamic_configs", "experiments", "layer_configs"):
+        assert all(item["exposureToken"] is None for item in result[section].values())
+    sdk.flush_events().wait()
+    assert mock.get_logged_events() == []

{oai_statsig_python_core-0.31.0rc2 → oai_statsig_python_core-0.31.0rc4}/statsig-pyo3/tests/test_interned_store_preload.py

@@ -60,6 +60,10 @@ def test_interned_store_preload(server_setup):
 
 
 def test_interned_store_mmap_preload(server_setup):
+    _run_isolated("_assert_interned_store_mmap_preload", *server_setup)
+
+
+def _run_isolated(function_name, *args):
     subprocess.run(
         [
             sys.executable,
@@ -67,11 +71,11 @@ def test_interned_store_mmap_preload(server_setup):
             (
                 "import sys; "
                 "sys.path.insert(0, '.'); "
-                "from test_interned_store_preload import "
-                "_assert_interned_store_mmap_preload; "
-                "_assert_interned_store_mmap_preload(*sys.argv[1:])"
+                "import test_interned_store_preload as tests; "
+                "getattr(tests, sys.argv[1])(*sys.argv[2:])"
             ),
-            *server_setup,
+            function_name,
+            *args,
         ],
         cwd=Path(__file__).parent,
         check=True,
@@ -129,3 +133,23 @@ def _assert_interned_store_mmap_preload(specs_url, log_event_url):
     assert config.value["foo"] == 1e21
     assert isinstance(config.value["foo"], float)
     assert log_provider.error_count == 0
+
+
+def test_interned_store_mmap_missing_required():
+    _run_isolated("_assert_mmap_missing_required")
+
+
+def _assert_mmap_missing_required():
+    sdk_key = f"missing-{uuid.uuid4()}"
+    message = "Invalid operation: No committed interned mmap V2 artifact was found"
+    for preload, argument in (
+        (InternedStore.preload_mmap, sdk_key),
+        (InternedStore.preload_mmap_multi, [sdk_key]),
+    ):
+        with pytest.raises(RuntimeError) as raised:
+            preload(argument)
+        assert type(raised.value) is RuntimeError
+        assert str(raised.value) == message
+        assert raised.value.args == (message,)
+        assert raised.value.error_name == "InvalidOperation"
+        assert raised.value.error_message == message

{oai_statsig_python_core-0.31.0rc2 → oai_statsig_python_core-0.31.0rc4}/statsig-rust/Cargo.toml

@@ -46,7 +46,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.31.0-rc.2", optional = true }
+oai-statsig-grpc = { path = "../statsig-grpc", version = "0.31.0-rc.4", optional = true }
 simple_logger = { version = "5.0.0" }
 tempfile = "3.8.1"
 tokio = { version = "1.39.1", features = ["full"] }