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

{statsig_python_core-0.19.3 → 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"
+version = "0.19.4"
 dependencies = [
  "async-trait",
  "chrono",
@@ -2961,7 +2962,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.19.3"
+version = "0.19.4"
 dependencies = [
  "async-trait",
  "napi",
@@ -2976,7 +2977,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.19.3"
+version = "0.19.4"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -2991,7 +2992,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-rust"
-version = "0.19.3"
+version = "0.19.4"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3041,7 +3042,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_elixir"
-version = "0.19.3"
+version = "0.19.4"
 dependencies = [
  "async-trait",
  "parking_lot",
@@ -3054,7 +3055,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.19.3"
+version = "0.19.4"
 dependencies = [
  "async-trait",
  "cbindgen",

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: statsig_python_core
-Version: 0.19.3
+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.3 → statsig_python_core-0.19.4}/py_src/statsig_python_core/error_boundary.py

@@ -10,7 +10,11 @@ class ErrorBoundary:
 
                 def create_wrapped(method_name, orig_method):
                     def wrapped(*args, **kwargs):
-                        return ErrorBoundary._capture(method_name, lambda: orig_method(*args, **kwargs))
+                        try:
+                            return orig_method(*args, **kwargs)
+                        except Exception as error:
+                            ErrorBoundary._on_error(method_name, error)
+                            return None
 
                     wrapped._error_boundary_wrapped = True
                     return wrapped

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

@@ -124,23 +124,91 @@ class BaseConfigEvaluation(BaseEvaluation):
         return self._get_typed(self.__tag, self.value, param_name, fallback)
 
     def get_string(self, param_name: str, fallback: str) -> str:
-        return self._get_typed(self.__tag, self.value, param_name, fallback)
+        res = self.value.get(param_name, None)
+        if res is None:
+            return fallback
+
+        if fallback is None or isinstance(fallback, type(res)):
+            return res
+
+        _log_error(
+            self.__tag,
+            f"Type mismatch - '{self.name}.{param_name}'. Expected {type(fallback)}, got {type(res)}",
+        )
+        return fallback
 
     def get_integer(self, param_name: str, fallback: int) -> int:
-        return self._get_typed(self.__tag, self.value, param_name, fallback)
+        res = self.value.get(param_name, None)
+        if res is None:
+            return fallback
+
+        if fallback is None or isinstance(fallback, type(res)):
+            return res
+
+        _log_error(
+            self.__tag,
+            f"Type mismatch - '{self.name}.{param_name}'. Expected {type(fallback)}, got {type(res)}",
+        )
+        return fallback
 
     def get_float(self, param_name: str, fallback: float) -> float:
         actual_fallback = float(fallback) if isinstance(fallback, int) else fallback
-        return self._get_typed(self.__tag, self.value, param_name, actual_fallback)
+        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):
+            return float(res)
+
+        _log_error(
+            self.__tag,
+            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(self.__tag, self.value, param_name, fallback)
+        res = self.value.get(param_name, None)
+        if res is None:
+            return fallback
+
+        if fallback is None or isinstance(fallback, type(res)):
+            return res
+
+        _log_error(
+            self.__tag,
+            f"Type mismatch - '{self.name}.{param_name}'. Expected {type(fallback)}, got {type(res)}",
+        )
+        return fallback
 
     def get_array(self, param_name: str, fallback: list) -> list:
-        return self._get_typed(self.__tag, self.value, param_name, fallback)
+        res = self.value.get(param_name, None)
+        if res is None:
+            return fallback
+
+        if fallback is None or isinstance(fallback, type(res)):
+            return res
+
+        _log_error(
+            self.__tag,
+            f"Type mismatch - '{self.name}.{param_name}'. Expected {type(fallback)}, got {type(res)}",
+        )
+        return fallback
 
     def get_object(self, param_name: str, fallback: dict) -> dict:
-        return self._get_typed(self.__tag, self.value, param_name, fallback)
+        res = self.value.get(param_name, None)
+        if res is None:
+            return fallback
+
+        if fallback is None or isinstance(fallback, type(res)):
+            return res
+
+        _log_error(
+            self.__tag,
+            f"Type mismatch - '{self.name}.{param_name}'. Expected {type(fallback)}, got {type(res)}",
+        )
+        return fallback
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
@@ -223,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.3 → 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.3 → statsig_python_core-0.19.4}/statsig-pyo3/tests/test_get_dynamic_config.py

@@ -61,6 +61,29 @@ 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")
+
+    assert config.get_string("str", "fallback") == "hello"
+    assert config.get_integer("num", 0) == 13
+    assert config.get_bool("bool", False) is True
+    assert config.get_array("arr", []) == ["hi", "there"]
+    assert config.get_object("obj", {}) == {"a": "bc"}
+
+
 def test_dynamic_config_to_py_dict_round_trip_preserves_data(statsig_setup):
     statsig = statsig_setup
     user = StatsigUser("my_user")

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

@@ -1,4 +1,4 @@
-from statsig_python_core import Statsig, StatsigOptions, StatsigUser
+from statsig_python_core import DynamicConfig, Statsig, StatsigOptions, StatsigUser
 from pytest_httpserver import HTTPServer
 import json
 from utils import get_test_data_resource
@@ -6,6 +6,28 @@ import pytest
 from profile_util import profile
 
 user = StatsigUser("a-user")
+typed_config = DynamicConfig(
+    "typed_config",
+    {
+        "value": {
+            "a_string": "value",
+            "an_integer": 123,
+            "a_float": 1.5,
+            "a_bool": True,
+            "an_array": ["value"],
+            "an_object": {"key": "value"},
+        }
+    },
+)
+
+typed_config_accessor_cases = [
+    ("get_string", "a_string", "err"),
+    ("get_integer", "an_integer", 0),
+    ("get_float", "a_float", 0.0),
+    ("get_bool", "a_bool", False),
+    ("get_array", "an_array", []),
+    ("get_object", "an_object", {}),
+]
 
 
 @pytest.fixture
@@ -86,6 +108,19 @@ def test_get_dynamic_config_get_string_correctness(statsig_setup):
     assert value.startswith("TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGF")
 
 
+@pytest.mark.parametrize("method_name,param_name,fallback", typed_config_accessor_cases)
+def test_typed_config_accessors(method_name, param_name, fallback):
+    method = getattr(typed_config, method_name)
+
+    results = profile(lambda: method(param_name, fallback), iterations=10_000)
+
+    value = results["value"]
+    del results["value"]
+    print(json.dumps(results, indent=2))
+
+    assert value == typed_config.value[param_name]
+
+
 def test_get_experiment(statsig_setup):
     statsig, _baseline = statsig_setup
 

{statsig_python_core-0.19.3 → 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.3 → 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", 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.3 → statsig_python_core-0.19.4}/statsig-rust/src/evaluation/cmab_evaluator.rs

@@ -62,9 +62,9 @@ pub fn get_cmab_ranked_list(ctx: &mut EvaluatorContext, name: &str) -> Vec<CMABR
         }
     };
 
+    let hashing = ctx.hashing;
     let unit_id = get_unit_id(ctx, &cmab.id_type);
-    let input = format!("{}.{}", cmab.salt, unit_id);
-    let user_hash = ctx.hashing.evaluation_hash(&input);
+    let user_hash = hashing.evaluation_hash_dot2(cmab.salt.as_str(), unit_id);
 
     let should_sample = match user_hash {
         Some(hash) => ((hash % 10000) as f64) < (cmab.sample_rate * 10000.0),
@@ -142,9 +142,9 @@ pub(crate) fn evaluate_cmab(
     ctx.result.version = Some(cmab.version);
     ctx.result.is_experiment_active = cmab.enabled;
 
+    let hashing = ctx.hashing;
     let unit_id = get_unit_id(ctx, &cmab.id_type);
-    let input = format!("{}.{}", cmab.salt, unit_id);
-    let user_hash = ctx.hashing.evaluation_hash(&input);
+    let user_hash = hashing.evaluation_hash_dot2(cmab.salt.as_str(), unit_id);
     let config = match &cmab.config {
         Some(config) => config,
         None => {

{statsig_python_core-0.19.3 → 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);
             }
 
@@ -717,15 +717,16 @@ fn evaluate_pass_percentage(
     }
 
     let rule_salt = rule.salt.as_deref().unwrap_or(rule.id.as_str());
+    let hashing = ctx.hashing;
     let unit_id = get_unit_id(ctx, &rule.id_type);
-    let input = format!("{spec_salt}.{rule_salt}.{unit_id}");
-    match ctx.hashing.evaluation_hash(&input) {
+    match hashing.evaluation_hash_dot3(spec_salt.as_str(), rule_salt, unit_id) {
         Some(hash) => ((hash % 10000) as f64) < rule.pass_percentage * 100.0,
         None => false,
     }
 }
 
 fn get_hash_for_user_bucket(ctx: &mut EvaluatorContext, condition: &Condition) -> DynamicValue {
+    let hashing = ctx.hashing;
     let unit_id = get_unit_id(ctx, &condition.id_type);
 
     let mut salt = InternedString::empty_ref();
@@ -736,8 +737,9 @@ fn get_hash_for_user_bucket(ctx: &mut EvaluatorContext, condition: &Condition) -
         }
     }
 
-    let input = format!("{salt}.{unit_id}");
-    let hash = ctx.hashing.evaluation_hash(&input).unwrap_or(1);
+    let hash = hashing
+        .evaluation_hash_dot2(salt.as_str(), unit_id)
+        .unwrap_or(1);
     dyn_value!(hash % 1000)
 }
 

{statsig_python_core-0.19.3 → statsig_python_core-0.19.4}/statsig-rust/src/hashing/hash_util.rs

@@ -89,7 +89,42 @@ impl HashUtil {
         u64::from_be_bytes(hasher_bytes)
     }
 
-    pub fn evaluation_hash(&self, input: &String) -> Option<u64> {
+    pub fn evaluation_hash(&self, input: &str) -> Option<u64> {
         self.sha_hasher.compute_hash(input)
     }
+
+    pub fn evaluation_hash_dot2(&self, a: &str, b: &str) -> Option<u64> {
+        self.sha_hasher.compute_hash_dot2(a, b)
+    }
+
+    pub fn evaluation_hash_dot3(&self, a: &str, b: &str, c: &str) -> Option<u64> {
+        self.sha_hasher.compute_hash_dot3(a, b, c)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::HashUtil;
+
+    #[test]
+    fn evaluation_hash_dot2_matches_formatted_input() {
+        let hashing = HashUtil::new();
+        let formatted = "salt.user";
+
+        assert_eq!(
+            hashing.evaluation_hash(formatted),
+            hashing.evaluation_hash_dot2("salt", "user")
+        );
+    }
+
+    #[test]
+    fn evaluation_hash_dot3_matches_formatted_input() {
+        let hashing = HashUtil::new();
+        let formatted = "spec.rule.user";
+
+        assert_eq!(
+            hashing.evaluation_hash(formatted),
+            hashing.evaluation_hash_dot3("spec", "rule", "user")
+        );
+    }
 }

statsig_python_core-0.19.4/statsig-rust/src/hashing/memo_sha_256.rs

@@ -0,0 +1,196 @@
+use crate::log_e;
+use ahash::AHasher;
+use base64::prelude::BASE64_STANDARD;
+use base64::Engine;
+use parking_lot::Mutex;
+use sha2::digest::Output;
+use sha2::{Digest, Sha256};
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+use std::time::Duration;
+
+const MAX_CACHE_ENTRIES: usize = 10000;
+
+struct MemoState {
+    sha_hasher: Sha256,
+    user_hash_cache: HashMap<u64, Vec<(EvaluationHashKey, u64)>>,
+    user_hash_cache_entries: usize,
+}
+
+enum EvaluationHashKey {
+    Raw(String),
+    Dot2(String, String),
+    Dot3(String, String, String),
+}
+
+enum EvaluationHashKeyRef<'a> {
+    Raw(&'a str),
+    Dot2(&'a str, &'a str),
+    Dot3(&'a str, &'a str, &'a str),
+}
+
+impl EvaluationHashKey {
+    fn matches(&self, other: &EvaluationHashKeyRef) -> bool {
+        match (self, other) {
+            (EvaluationHashKey::Raw(a), EvaluationHashKeyRef::Raw(b)) => a == b,
+            (EvaluationHashKey::Dot2(a1, a2), EvaluationHashKeyRef::Dot2(b1, b2)) => {
+                a1 == b1 && a2 == b2
+            }
+            (EvaluationHashKey::Dot3(a1, a2, a3), EvaluationHashKeyRef::Dot3(b1, b2, b3)) => {
+                a1 == b1 && a2 == b2 && a3 == b3
+            }
+            _ => false,
+        }
+    }
+}
+
+impl<'a> EvaluationHashKeyRef<'a> {
+    fn fast_hash(&self) -> u64 {
+        let mut hasher = AHasher::default();
+        std::mem::discriminant(self).hash(&mut hasher);
+        match self {
+            EvaluationHashKeyRef::Raw(a) => a.hash(&mut hasher),
+            EvaluationHashKeyRef::Dot2(a, b) => {
+                a.hash(&mut hasher);
+                b.hash(&mut hasher);
+            }
+            EvaluationHashKeyRef::Dot3(a, b, c) => {
+                a.hash(&mut hasher);
+                b.hash(&mut hasher);
+                c.hash(&mut hasher);
+            }
+        }
+        hasher.finish()
+    }
+
+    fn to_owned_key(&self) -> EvaluationHashKey {
+        match self {
+            EvaluationHashKeyRef::Raw(a) => EvaluationHashKey::Raw((*a).to_string()),
+            EvaluationHashKeyRef::Dot2(a, b) => {
+                EvaluationHashKey::Dot2((*a).to_string(), (*b).to_string())
+            }
+            EvaluationHashKeyRef::Dot3(a, b, c) => {
+                EvaluationHashKey::Dot3((*a).to_string(), (*b).to_string(), (*c).to_string())
+            }
+        }
+    }
+}
+
+const TAG: &str = stringify!(MemoSha256);
+pub struct MemoSha256 {
+    inner: Mutex<MemoState>,
+}
+
+impl MemoSha256 {
+    pub fn new() -> Self {
+        Self {
+            inner: Mutex::new(MemoState {
+                sha_hasher: Sha256::new(),
+                user_hash_cache: HashMap::new(),
+                user_hash_cache_entries: 0,
+            }),
+        }
+    }
+
+    pub fn compute_hash(&self, input: &str) -> Option<u64> {
+        self.compute_hash_for_key(EvaluationHashKeyRef::Raw(input))
+    }
+
+    pub fn compute_hash_dot2(&self, a: &str, b: &str) -> Option<u64> {
+        self.compute_hash_for_key(EvaluationHashKeyRef::Dot2(a, b))
+    }
+
+    pub fn compute_hash_dot3(&self, a: &str, b: &str, c: &str) -> Option<u64> {
+        self.compute_hash_for_key(EvaluationHashKeyRef::Dot3(a, b, c))
+    }
+
+    fn compute_hash_for_key(&self, key: EvaluationHashKeyRef) -> Option<u64> {
+        let mut state = match self.inner.try_lock_for(Duration::from_secs(5)) {
+            Some(state) => state,
+            None => {
+                log_e!(
+                    TAG,
+                    "Failed to acquire lock for Sha256: Failed to lock inner"
+                );
+                return None;
+            }
+        };
+
+        let fast_hash = key.fast_hash();
+        if let Some(bucket) = state.user_hash_cache.get(&fast_hash) {
+            if let Some((_, value)) = bucket
+                .iter()
+                .find(|(cached_key, _)| cached_key.matches(&key))
+            {
+                return Some(*value);
+            }
+        }
+
+        if state.user_hash_cache_entries > MAX_CACHE_ENTRIES {
+            state.user_hash_cache.clear();
+            state.user_hash_cache_entries = 0;
+        }
+
+        let hash = self.compute_bytes_for_key(&mut state, &key);
+
+        match hash.split_at(size_of::<u64>()).0.try_into() {
+            Ok(bytes) => {
+                let u_bytes = u64::from_be_bytes(bytes);
+                state
+                    .user_hash_cache
+                    .entry(fast_hash)
+                    .or_default()
+                    .push((key.to_owned_key(), u_bytes));
+                state.user_hash_cache_entries += 1;
+                Some(u_bytes)
+            }
+            _ => None,
+        }
+    }
+
+    pub fn hash_string(&self, input: &str) -> String {
+        let mut state = match self.inner.try_lock_for(Duration::from_secs(5)) {
+            Some(state) => state,
+            None => {
+                log_e!(
+                    TAG,
+                    "Failed to acquire lock for Sha256: Failed to lock inner"
+                );
+                return "STATSIG_HASH_ERROR".to_string();
+            }
+        };
+
+        let hash = self.compute_bytes(&mut state, input);
+        BASE64_STANDARD.encode(hash)
+    }
+
+    fn compute_bytes(&self, state: &mut MemoState, input: &str) -> Output<Sha256> {
+        state.sha_hasher.update(input.as_bytes());
+        state.sha_hasher.finalize_reset()
+    }
+
+    fn compute_bytes_for_key(
+        &self,
+        state: &mut MemoState,
+        key: &EvaluationHashKeyRef,
+    ) -> Output<Sha256> {
+        match key {
+            EvaluationHashKeyRef::Raw(a) => {
+                state.sha_hasher.update(a.as_bytes());
+            }
+            EvaluationHashKeyRef::Dot2(a, b) => {
+                state.sha_hasher.update(a.as_bytes());
+                state.sha_hasher.update(b".");
+                state.sha_hasher.update(b.as_bytes());
+            }
+            EvaluationHashKeyRef::Dot3(a, b, c) => {
+                state.sha_hasher.update(a.as_bytes());
+                state.sha_hasher.update(b".");
+                state.sha_hasher.update(b.as_bytes());
+                state.sha_hasher.update(b".");
+                state.sha_hasher.update(c.as_bytes());
+            }
+        }
+        state.sha_hasher.finalize_reset()
+    }
+}