wedata3-feature-engineering 0.2.5.dev2__tar.gz → 0.2.6.dev1__tar.gz

{wedata3_feature_engineering-0.2.5.dev2 → wedata3_feature_engineering-0.2.6.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wedata3-feature-engineering
-Version: 0.2.5.dev2
+Version: 0.2.6.dev1
 Summary: Wedata Feature Engineering Library Development
 Home-page: 
 Author: meahqian
@@ -9,11 +9,12 @@ License: Apache 2.0
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: pandas>=1.0.0
 Requires-Dist: feast[postgres,redis]==0.49.0
 Requires-Dist: grpcio==1.74.0
+Requires-Dist: msgpack<2,>=1.0
 Requires-Dist: tencentcloud-sdk-python
 Requires-Dist: ipython
 Requires-Dist: msgpack<2.0.0,>=1.0.0
@@ -25,6 +26,7 @@ Provides-Extra: dev
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: python-dotenv; extra == "dev"
+Requires-Dist: fakeredis[lua]; extra == "dev"
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{wedata3_feature_engineering-0.2.5.dev2 → wedata3_feature_engineering-0.2.6.dev1}/setup.py

@@ -13,6 +13,7 @@ setup(
     install_requires=[
         'pandas>=1.0.0',
         'feast[redis,postgres]==0.49.0', 'grpcio==1.74.0',
+        'msgpack>=1.0,<2',
         'tencentcloud-sdk-python',
         'ipython',
         # Redis 整行打包在线存储（见 doc/plan/redis-packed-codec-design.md）
@@ -21,9 +22,9 @@ setup(
     extras_require={
         'mlflow2': ['mlflow==2.17.2',],
         'mlflow3': ['mlflow>=3.10.0,<3.11.0'],
-        'dev': ['flake8', 'pytest', 'python-dotenv'],
+        'dev': ['flake8', 'pytest', 'python-dotenv', 'fakeredis[lua]'],
     },
-    python_requires='>=3.9',
+    python_requires='>=3.10',
     author="meahqian",
     author_email="",
     description="Wedata Feature Engineering Library Development",

{wedata3_feature_engineering-0.2.5.dev2 → wedata3_feature_engineering-0.2.6.dev1}/tests/test_cleanup_packed.py

@@ -8,6 +8,9 @@ cleanup_packed 单元测试（fakeredis）。
    STALE/REJECTED 删、超时 WRITING 转 ABANDONED 删、PURGED 条目过期删
 3. 孤儿 __meta__ 清理
 4. purge_batch 幂等、extend_active_ttl 应急路径
+5. drop_all 整表删除：控制 key 与数据 key 都删，不碰其他表
+
+key 格式与 BatchInfo 统一走 common codec（与推理侧同一份实现）。
 """
 
 import time
@@ -15,10 +18,27 @@ import time
 import fakeredis
 import pytest
 
-from wedata.feature_engineering.feast.infra.online_store import packed_codec as pc
+from wedata.common.online_store import packed_codec as pc
+from wedata.common.online_store.packed_codec import SchemaMeta
 from wedata.feature_engineering.feast.infra.online_store import cleanup_packed as cp
 
-PREFIX = "1001:ab12cd34ef"
+PREFIX = "1001:ab23cd45efgh"
+
+META = SchemaMeta(
+    codec_version=pc.CODEC_VERSION,
+    schema_version="a3f2c1d8",
+    fields=(("a", "INT64"),),
+    entity_keys=("u",),
+    created_at=0,
+    source_table="cat.db.t",
+)
+
+
+def all_keys(client, prefix=PREFIX):
+    keys = set()
+    for pattern in pc.table_key_patterns(prefix):
+        keys.update(k.decode() if isinstance(k, bytes) else k for k in client.scan_iter(match=pattern))
+    return sorted(keys)
 
 
 def make_client():
@@ -29,20 +49,15 @@ def register(client, prefix, sv, dv, state, watermark=1000, run_start=None, upda
     """登记一个批次并可选写两个数据 key。"""
     member = pc.build_batch_member(sv, dv)
     info_raw = pc.build_batch_info(
-        watermark_ms=watermark,
+        watermark=watermark,
         run_start_ms=run_start if run_start is not None else int(time.time() * 1000),
         state=state,
-        updated_at_s=updated_at if updated_at is not None else int(time.time()),
+        updated_at=updated_at if updated_at is not None else int(time.time()),
+        retired_at=retired_at,
     )
-    # build_batch_info 无 retired_at 槽位，retired 状态在 hash 里补
-    if retired_at is not None:
-        import json
-        info = json.loads(info_raw)
-        info["retired_at"] = retired_at
-        info_raw = json.dumps(info, separators=(",", ":"))
     client.hset(pc.versions_key(prefix), member, info_raw)
-    client.set(pc.data_key(prefix, sv, dv, "u1"), pc.encode_row([1, 2, 3], ts_ms=watermark))
-    client.set(pc.data_key(prefix, sv, dv, "u2"), pc.encode_row([4, 5, 6], ts_ms=watermark))
+    client.set(pc.data_key(prefix, sv, dv, "u1"), pc.encode_row(META, 1, {"a": 1}))
+    client.set(pc.data_key(prefix, sv, dv, "u2"), pc.encode_row(META, 2, {"a": 2}))
     return member
 
 
@@ -73,17 +88,15 @@ class TestPrecheck:
         client = make_client()
         register(client, PREFIX, sv(1), dv(1), pc.STATE_STALE)
         cp.precheck_and_purge(client, PREFIX)
-        # STALE 批次数据已被清掉（fakeredis 返回 bytes，统一解码比较）
-        remain = sorted(k.decode() if isinstance(k, bytes) else k
-                        for k in client.scan_iter(match=f"{PREFIX}:*"))
-        assert remain == [pc.versions_key(PREFIX)]
+        # STALE 批次数据已被清掉，只剩登记表
+        assert all_keys(client) == [pc.versions_key(PREFIX)]
 
     def test_abandoned_writing_purged(self):
         client = make_client()
         # updated_at 设为 7 小时前
         register(client, PREFIX, sv(1), dv(1), pc.STATE_WRITING, updated_at=int(time.time()) - 7 * 3600)
         cp.precheck_and_purge(client, PREFIX)
-        info = pc.decode_batch_info(client.hget(pc.versions_key(PREFIX), pc.build_batch_member(sv(1), dv(1))).decode())
+        info = pc.decode_batch_info(client.hget(pc.versions_key(PREFIX), pc.build_batch_member(sv(1), dv(1))))
         assert info[pc.BATCH_STATE] == pc.STATE_PURGED
         assert not client.exists(pc.data_key(PREFIX, sv(1), dv(1), "u1"))
 
@@ -103,7 +116,7 @@ class TestCleanupRules:
         client, active = self._setup()
         cp.cleanup(client, PREFIX)
         assert client.exists(pc.data_key(PREFIX, sv(1), dv(1), "u1"))
-        info = pc.decode_batch_info(client.hget(pc.versions_key(PREFIX), active).decode())
+        info = pc.decode_batch_info(client.hget(pc.versions_key(PREFIX), active))
         assert info[pc.BATCH_STATE] == pc.STATE_ACTIVE
 
     def test_newest_retired_kept_old_retired_deleted(self):
@@ -139,19 +152,27 @@ class TestCleanupRules:
         cp.cleanup(client, PREFIX)
         assert client.hget(pc.versions_key(PREFIX), member) is None  # 登记条目也删了
 
-    def test_corrupted_entry_treated_as_abandoned(self):
+    def test_corrupted_info_treated_as_abandoned_and_purged(self):
+        client, active = self._setup()
+        member = register(client, PREFIX, sv(2), dv(2), pc.STATE_WRITING)
+        client.hset(pc.versions_key(PREFIX), member, "not-json")
+        assert cp.cleanup(client, PREFIX) == 1
+        assert not client.exists(pc.data_key(PREFIX, sv(2), dv(2), "u1"))
+        info = pc.decode_batch_info(client.hget(pc.versions_key(PREFIX), member))
+        assert info[pc.BATCH_STATE] == pc.STATE_PURGED
+
+    def test_malformed_member_dropped_without_blocking(self):
         client, active = self._setup()
         client.hset(pc.versions_key(PREFIX), "garbage-member", "not-json")
-        deleted = cp.cleanup(client, PREFIX)
-        assert deleted >= 0  # 不抛错
-        assert client.hget(pc.versions_key(PREFIX), "garbage-member") is not None  # 无法解析，原样保留
+        cp.cleanup(client, PREFIX)  # 不抛错，门禁不会被脏条目卡死
+        assert client.hget(pc.versions_key(PREFIX), "garbage-member") is None
 
     def test_orphan_meta_removed(self):
         client, active = self._setup()
         # ACTIVE 批次的 meta 正常存在
-        client.set(pc.meta_key(PREFIX, sv(1)), "{}")
+        client.set(pc.meta_key(PREFIX, sv(1)), META.to_bytes())
         # sv=99 的 meta 存在但无任何批次
-        client.set(pc.meta_key(PREFIX, sv(99)), "{}")
+        client.set(pc.meta_key(PREFIX, sv(99)), META.to_bytes())
         cp.cleanup(client, PREFIX)
         assert not client.exists(pc.meta_key(PREFIX, sv(99)))
         # active 批次的 meta 保留
@@ -169,7 +190,7 @@ class TestUtilities:
         cp.purge_batch(client, PREFIX, member)
         assert not client.exists(pc.data_key(PREFIX, sv(1), dv(1), "u1"))
         cp.purge_batch(client, PREFIX, member)  # 再跑一次不抛错
-        info = pc.decode_batch_info(client.hget(pc.versions_key(PREFIX), member).decode())
+        info = pc.decode_batch_info(client.hget(pc.versions_key(PREFIX), member))
         assert info[pc.BATCH_STATE] == pc.STATE_PURGED
 
     def test_purge_does_not_touch_other_batches(self):
@@ -193,3 +214,52 @@ class TestUtilities:
         client = make_client()
         with pytest.raises(cp.CleanupError):
             cp.extend_active_ttl(client, PREFIX, 3600)
+
+
+# ---------------------------------------------------------------------------
+# drop_all（删除在线表的清理作业）
+# ---------------------------------------------------------------------------
+
+class TestDropAll:
+    def _populate(self, client, prefix):
+        member = register(client, prefix, sv(1), dv(1), pc.STATE_ACTIVE)
+        client.set(pc.active_key(prefix), member)
+        client.set(pc.meta_key(prefix, sv(1)), META.to_bytes())
+
+    def test_removes_control_and_data_keys(self):
+        client = make_client()
+        self._populate(client, PREFIX)
+        assert len(all_keys(client)) == 5  # active / versions / meta / 2 条数据
+        assert cp.drop_all(client, PREFIX) == 5
+        assert all_keys(client) == []
+        assert cp.drop_all(client, PREFIX) == 0  # 幂等
+
+    def test_other_tables_untouched(self):
+        client = make_client()
+        self._populate(client, PREFIX)
+        for other in ("1001:ab12cd34ef0", "1002:ab12cd34ef"):
+            self._populate(client, other)
+        cp.drop_all(client, PREFIX)
+        assert all_keys(client, "1001:ab12cd34ef0") and all_keys(client, "1002:ab12cd34ef")
+
+    def test_malformed_prefix_rejected(self):
+        """防呆：畸形前缀（裸 workspaceId / 短哈希）拒绝执行，SCAN 模式会跨表清库。"""
+        import pytest
+
+        client = make_client()
+        self._populate(client, PREFIX)
+        for bad in ("1001", "1001:", "1001:ab12cd34ef", "1001:ab12cd34ef0", "vpc-1001:ab12cd34efgh"):
+            with pytest.raises(cp.CleanupError):
+                cp.drop_all(client, bad)
+        assert len(all_keys(client)) == 5  # 一个 key 都没动
+
+    def test_redis_error_propagates(self, monkeypatch):
+        client = make_client()
+        self._populate(client, PREFIX)
+
+        def boom(*args, **kwargs):
+            raise cp.redis.ConnectionError("down")
+
+        monkeypatch.setattr(client, "unlink", boom)
+        with pytest.raises(cp.redis.ConnectionError):
+            cp.drop_all(client, PREFIX)

{wedata3_feature_engineering-0.2.5.dev2 → wedata3_feature_engineering-0.2.6.dev1}/tests/test_client.py

@@ -1625,6 +1625,47 @@ class TestOnlineTableOperations:
         assert call_kwargs["trigger"] is mock_trigger
         assert call_kwargs["online_catalog_name"] == "online_cat"
 
+    def test_publish_table_redis_without_online_names(self):
+        """Redis 发布：只传离线表与类型，在线库表名保持 None 透传给内部客户端校验"""
+        client = _make_client()
+        client.publish_table(
+            catalog_name="cat", schema_name="schema", table_name="tbl", online_store_type="REDIS"
+        )
+        client._feature_table_client.publish_table.assert_called_once_with(
+            catalog_name="cat",
+            schema_name="schema",
+            table_name="tbl",
+            online_db_name=None,
+            online_table_name=None,
+            online_catalog_name=None,
+            trigger=None,
+            online_store_type="REDIS",
+        )
+
+    def test_read_table_online_delegates(self):
+        """read_table(is_online=True) 透传在线读取参数"""
+        client = _make_client()
+        client._parse_table_name = lambda n, d, c: (n, d, c)
+        rows = [{"member_id": "10086"}]
+        client.read_table("tbl", "db", "cat", is_online=True, entity_rows=rows, redis_connection_string="h:6379")
+        client._feature_table_client.read_table.assert_called_once_with(
+            name="tbl",
+            database_name="db",
+            catalog_name="cat",
+            is_online=True,
+            entity_rows=rows,
+            redis_connection_string="h:6379",
+        )
+
+    def test_read_table_offline_call_unchanged(self):
+        """默认离线读取：调用参数与改造前一致"""
+        client = _make_client()
+        client._parse_table_name = lambda n, d, c: (n, d, c)
+        client.read_table("tbl", "db", "cat")
+        client._feature_table_client.read_table.assert_called_once_with(
+            name="tbl", database_name="db", catalog_name="cat"
+        )
+
     def test_drop_online_table_delegates(self):
         """drop_online_table 应委托给 _feature_table_client.drop_online_table"""
         client = _make_client()

wedata3_feature_engineering-0.2.6.dev1/tests/test_packed_codec.py

@@ -0,0 +1,380 @@
+import datetime as dt
+import json
+import os
+import random
+import subprocess
+import sys
+from decimal import Decimal
+from pathlib import Path
+
+import msgpack
+import pytest
+
+from wedata.common.online_store import packed_codec as pc
+from wedata.common.online_store.packed_codec import (
+    PackedCodecError,
+    SchemaMeta,
+    UnsupportedCodecVersion,
+)
+
+PREFIX = "17893778831981982:ie3ton4o6vrh"
+FIELDS = (("age", "INT64"), ("city_id", "INT32"), ("ctr_7d", "DOUBLE"), ("name", "STRING"))
+
+
+def make_meta(fields=FIELDS, entity_keys=("customer_id",)):
+    return SchemaMeta(
+        codec_version=pc.CODEC_VERSION,
+        schema_version=pc.compute_schema_version(fields, entity_keys),
+        fields=tuple(fields),
+        entity_keys=tuple(entity_keys),
+        created_at=1789892926028,
+        source_table="prod_cat.dws.member_offline_feat",
+    )
+
+
+# ---------------------------------------------------------------- key（§2.6）
+
+
+def test_key_examples_match_doc():
+    assert pc.active_key(PREFIX) == "{17893778831981982:ie3ton4o6vrh}:__active__"
+    assert pc.meta_key(PREFIX, "a3f2c1d8") == "{17893778831981982:ie3ton4o6vrh}:__meta__:a3f2c1d8"
+    assert pc.versions_key(PREFIX) == "{17893778831981982:ie3ton4o6vrh}:__versions__"
+    key = pc.data_key(PREFIX, "a3f2c1d8", "mu9k18p8a7", "1000000123")
+    assert key == "17893778831981982:ie3ton4o6vrh:a3f2c1d8:mu9k18p8a7:1000000123"
+    assert len(key.encode()) == 61
+
+
+def test_control_keys_share_slot_and_data_key_has_no_braces():
+    from redis.crc import key_slot
+
+    slots = {key_slot(k.encode()) for k in (
+        pc.active_key(PREFIX), pc.meta_key(PREFIX, "a3f2c1d8"), pc.versions_key(PREFIX))}
+    assert len(slots) == 1
+    key = pc.data_key(PREFIX, "a3f2c1d8", "mu9k18p8a7", pc.build_entity_key_from_values(["{x}"]))
+    assert "{" not in key and "}" not in key
+
+
+def test_data_key_rejects_unescaped_braces_and_bad_prefix():
+    with pytest.raises(PackedCodecError):
+        pc.data_key(PREFIX, "a3f2c1d8", "mu9k18p8a7", "{grp}1")
+    with pytest.raises(PackedCodecError):
+        pc.active_key("{ws}:tid")
+    with pytest.raises(PackedCodecError):
+        pc.data_key_prefix(PREFIX, "a3:f2", "mu9k18p8a7")
+
+
+# ---------------------------------------------------------------- ek（§2.6.3）
+
+
+def test_entity_key_separator_and_percent_no_collision():
+    assert pc.build_entity_key_from_values(["a|b", "c"]) != pc.build_entity_key_from_values(["a", "b|c"])
+    assert pc.build_entity_key_from_values(["%"]) != pc.build_entity_key_from_values(["%25"])
+    assert pc.build_entity_key_from_values(["|"]) != pc.build_entity_key_from_values(["%7C"])
+    assert pc.build_entity_key_from_values(["shopA", 2026]) == "shopA|2026"
+
+
+def test_entity_key_braces_spread_over_slots():
+    from redis.crc import key_slot
+
+    base = pc.data_key_prefix(PREFIX, "a3f2c1d8", "mu9k18p8a7")
+    slots = {key_slot((base + pc.build_entity_key_from_values([f"{{grp}}{i}"])).encode()) for i in range(10000)}
+    assert len(slots) > 7000
+
+
+def test_entity_key_random_inputs_never_contain_braces():
+    rnd = random.Random(7)
+    alphabet = "{}|%:ab1 "
+    for _ in range(2000):
+        vals = ["".join(rnd.choice(alphabet) for _ in range(rnd.randint(1, 8))) for _ in range(rnd.randint(1, 3))]
+        key = pc.data_key(PREFIX, "a3f2c1d8", "mu9k18p8a7", pc.build_entity_key_from_values(vals))
+        assert "{" not in key and "}" not in key
+
+
+def test_entity_value_normalization():
+    assert pc.entity_value_to_str(1000000123) == "1000000123"
+    assert pc.entity_value_to_str(1000000123.0) == "1000000123"
+    assert pc.entity_value_to_str(True) == "true"
+    assert pc.entity_value_to_str(1.5) == "1.5"
+    for bad in (None, float("nan"), b"x", Decimal("NaN"), object()):
+        with pytest.raises(PackedCodecError):
+            pc.entity_value_to_str(bad)
+
+
+def test_entity_value_normalization_decimal():
+    assert pc.entity_value_to_str(Decimal("123")) == "123"
+    assert pc.entity_value_to_str(Decimal("123.00")) == pc.entity_value_to_str(123) == "123"
+    assert pc.entity_value_to_str(Decimal("1E+2")) == "100"
+    assert pc.entity_value_to_str(Decimal("1.50")) == pc.entity_value_to_str(1.5) == "1.5"
+    assert pc.entity_value_to_str(Decimal("-0.25")) == pc.entity_value_to_str(-0.25)
+
+
+def test_entity_value_normalization_datetime():
+    assert pc.entity_value_to_str(dt.date(2026, 1, 2)) == "2026-01-02"
+    assert pc.entity_value_to_str(dt.datetime(2026, 1, 2, 3, 4, 5)) == "2026-01-02 03:04:05"
+    assert pc.entity_value_to_str(dt.datetime(2026, 1, 2, 3, 4, 5, 120000)) == "2026-01-02 03:04:05.12"
+    cst = dt.timezone(dt.timedelta(hours=8))
+    assert pc.entity_value_to_str(dt.datetime(2026, 1, 2, 8, 0, 0, tzinfo=cst)) == "2026-01-02 00:00:00"
+
+
+def test_entity_value_normalization_numpy_and_pandas():
+    np = pytest.importorskip("numpy")
+    pd = pytest.importorskip("pandas")
+    assert pc.entity_value_to_str(np.int64(7)) == "7"
+    assert pc.entity_value_to_str(np.float64(7.0)) == "7"
+    assert pc.entity_value_to_str(np.bool_(True)) == "true"
+    ts = "2026-01-02T03:04:05.123456789"
+    # datetime64[ns].item() 是纳秒整数，必须按时间而不是整数规范化
+    assert pc.entity_value_to_str(np.datetime64(ts)) == "2026-01-02 03:04:05.123456"
+    assert pc.entity_value_to_str(pd.Timestamp("2026-01-02 03:04:05")) == "2026-01-02 03:04:05"
+    with pytest.raises(PackedCodecError):
+        pc.entity_value_to_str(pd.NaT)
+
+
+def test_build_entity_key_uses_meta_order():
+    meta = make_meta(entity_keys=("shop_id", "dt"))
+    assert pc.build_entity_key(meta, {"dt": 2026, "shop_id": "A"}) == "A|2026"
+    with pytest.raises(PackedCodecError):
+        pc.build_entity_key(meta, {"shop_id": "A"})
+
+
+# ---------------------------------------------------------------- 编解码（§3）
+
+
+def test_encode_decode_roundtrip():
+    meta = make_meta()
+    values = {"age": -5, "city_id": 0, "ctr_7d": 0.25, "name": ""}
+    ts, out = pc.decode_row(meta, pc.encode_row(meta, 123, values))
+    assert ts == 123 and out == values
+    big = {"age": 2**63 - 1}
+    assert pc.decode_row(meta, pc.encode_row(meta, None, big))[1] == big
+
+
+def test_nil_not_in_result_and_requested_projection():
+    meta = make_meta()
+    raw = pc.encode_row(meta, 1, {"age": None, "ctr_7d": float("nan"), "name": "x"})
+    _, out = pc.decode_row(meta, raw)
+    assert out == {"name": "x"}
+    assert pc.decode_row(meta, raw, requested=["name", "age"])[1] == {"name": "x"}
+    with pytest.raises(PackedCodecError):
+        pc.decode_row(meta, raw, requested=["missing"])
+
+
+def test_length_tolerance():
+    meta = make_meta()
+    short = msgpack.packb([1, 7], use_bin_type=True)
+    assert pc.decode_row(meta, short)[1] == {"age": 7}
+    long = msgpack.packb([1, 1, 2, 3.0, "n", "extra"], use_bin_type=True)
+    assert pc.decode_row(meta, long)[1] == {"age": 1, "city_id": 2, "ctr_7d": 3.0, "name": "n"}
+
+
+def test_meta_roundtrip_and_codec_version_guard():
+    meta = make_meta()
+    assert SchemaMeta.from_bytes(meta.to_bytes()) == meta
+    newer = dict(meta.to_dict(), codec_version=pc.CODEC_VERSION + 1)
+    with pytest.raises(UnsupportedCodecVersion):
+        SchemaMeta.from_bytes(msgpack.packb(newer, use_bin_type=True))
+    with pytest.raises(PackedCodecError):
+        SchemaMeta.from_bytes(b"\xc1")
+
+
+def test_validate_string_lengths():
+    pc.validate_string_lengths({"a": "x" * 64})
+    with pytest.raises(PackedCodecError):
+        pc.validate_string_lengths({"a": "x" * 65})
+
+
+# ---------------------------------------------------------------- 版本号（§4 / §2.2.2）
+
+
+def test_schema_version_order_sensitive_and_stable():
+    v1 = pc.compute_schema_version(FIELDS, ["customer_id"])
+    assert v1 == pc.compute_schema_version(list(FIELDS), ("customer_id",))
+    assert len(v1) == 8
+    assert v1 != pc.compute_schema_version(tuple(reversed(FIELDS)), ["customer_id"])
+    assert v1 != pc.compute_schema_version(FIELDS, ["user_id"])
+
+
+def test_schema_version_stable_across_processes_with_random_hash_seed():
+    code = (
+        "from wedata.common.online_store.packed_codec import compute_schema_version as c;"
+        "print(c([('age','INT64'),('ctr','DOUBLE')],['customer_id']))"
+    )
+    root = Path(__file__).resolve().parents[1]
+    outs = set()
+    for seed in ("1", "2", "random"):
+        env = dict(os.environ, PYTHONHASHSEED=seed, PYTHONPATH=str(root))
+        outs.add(subprocess.check_output([sys.executable, "-c", code], env=env, text=True).strip())
+    assert len(outs) == 1
+
+
+def test_new_data_version_format():
+    assert pc.new_data_version(1789892926028, "a7") == "mu9k18p8a7"
+    dv = pc.new_data_version(1789892926028)
+    assert len(dv) == 10 and dv.startswith("mu9k18p8")
+    assert pc.new_data_version(1, "00") == "0000000100"
+    with pytest.raises(ValueError):
+        pc.new_data_version(1, "A!")
+
+
+def test_parse_active_pointer():
+    assert pc.parse_active_pointer(b"a3f2c1d8:mu9k18p8a7") == ("a3f2c1d8", "mu9k18p8a7")
+    for bad in ("", "abc", "a:b:c", ":b", None):
+        with pytest.raises(PackedCodecError):
+            pc.parse_active_pointer(bad)
+
+
+# ---------------------------------------------------------------- feast 适配
+
+
+def test_build_meta_from_feature_view_keeps_features_order():
+    from feast import Entity, FeatureView, Field, FileSource, ValueType
+    from feast.types import Float64, Int64, String
+
+    fv = FeatureView(
+        name="fv",
+        entities=[Entity(name="customer_id", join_keys=["customer_id"], value_type=ValueType.INT64)],
+        schema=[Field(name="customer_id", dtype=Int64), Field(name="z", dtype=String),
+                Field(name="a", dtype=Float64), Field(name="m", dtype=Int64)],
+        source=FileSource(path="x.parquet", timestamp_field="ts"),
+    )
+    meta = pc.build_meta_from_feature_view(fv, "c.s.t", created_at=1)
+    assert meta.fields == (("z", "STRING"), ("a", "DOUBLE"), ("m", "INT64"))
+    assert meta.entity_keys == ("customer_id",)
+    assert meta.schema_version == pc.compute_schema_version(meta.fields, meta.entity_keys)
+    protos = pc.to_value_protos(meta, {"z": "s", "a": 1.5, "m": 3})
+    assert protos["z"].string_val == "s" and protos["a"].double_val == 1.5 and protos["m"].int64_val == 3
+
+
+# ---------------------------------------------------------------- CAS Lua（§5.2）
+
+
+def test_activate_lua_identical_to_verified_script():
+    script = Path(__file__).resolve().parents[3] / "science/doc/plan/scripts/active_cas_verify.py"
+    if not script.exists():
+        pytest.skip("验证脚本不在当前检出中")
+    src = script.read_text(encoding="utf-8")
+    start = src.index('ACTIVATE_LUA = r"""') + len('ACTIVATE_LUA = r"""')
+    assert src[start:src.index('"""', start)] == pc.ACTIVATE_LUA
+
+
+def _lua_env():
+    fakeredis = pytest.importorskip("fakeredis")
+    pytest.importorskip("lupa")
+    r = fakeredis.FakeRedis(decode_responses=True)
+    return r, r.register_script(pc.ACTIVATE_LUA)
+
+
+def _register(r, member, watermark, run_start):
+    r.hset(pc.versions_key(PREFIX), member, json.dumps(
+        {"state": "WRITING", "watermark": watermark, "run_start": run_start}))
+
+
+def _activate(script, member):
+    sw, prev, reason = script(keys=[pc.active_key(PREFIX), pc.versions_key(PREFIX)], args=[member, 0])
+    return int(sw), prev, reason
+
+
+def _state(r, member):
+    return json.loads(r.hget(pc.versions_key(PREFIX), member))["state"]
+
+
+def test_activate_lua_scenarios():
+    r, s = _lua_env()
+    active = pc.active_key(PREFIX)
+    _register(r, "sv:T", 100, 1000)
+    assert _activate(s, "sv:T")[0] == 1 and _state(r, "sv:T") == "ACTIVE"
+    _register(r, "sv:T1", 200, 2000)
+    assert _activate(s, "sv:T1")[0] == 1 and _state(r, "sv:T") == "RETIRED"
+    _register(r, "sv:retry", 150, 3000)
+    assert _activate(s, "sv:retry")[2] == "STALE" and r.get(active) == "sv:T1"
+    _register(r, "sv:rerun", 200, 2500)
+    assert _activate(s, "sv:rerun")[0] == 1
+    _register(r, "sv:early", 200, 2400)
+    assert _activate(s, "sv:early")[2] == "STALE"
+    assert _activate(s, "sv:ghost")[2] == "NEW_NOT_REGISTERED" and r.get(active) == "sv:rerun"
+
+
+def test_activate_lua_random_order_always_latest():
+    rnd = random.Random(11)
+    for _ in range(200):
+        r, s = _lua_env()
+        batches = [(f"sv:{i}", rnd.randint(1, 50), rnd.randint(1, 10_000)) for i in range(6)]
+        for m, wm, rs in batches:
+            _register(r, m, wm, rs)
+        for m, _, _ in rnd.sample(batches, len(batches)):
+            _activate(s, m)
+        expected = max(batches, key=lambda b: (b[1], b[2]))[0]
+        assert r.get(pc.active_key(PREFIX)) == expected
+        assert [m for m, _, _ in batches if _state(r, m) == "ACTIVE"] == [expected]
+
+
+# ---------------------------------------------------------------- 批次登记（§2.4）
+
+
+def test_batch_member_same_shape_as_active_pointer():
+    member = pc.build_batch_member("a3f2c1d8", "mu9k18p8a7")
+    assert member == "a3f2c1d8:mu9k18p8a7"
+    assert pc.parse_batch_member(member) == pc.parse_active_pointer(member)
+    for bad in ("", "a:b", "x{y"):
+        with pytest.raises(PackedCodecError):
+            pc.build_batch_member(bad, "mu9k18p8a7")
+
+
+def test_batch_info_roundtrip_keeps_extra_fields():
+    raw = pc.build_batch_info(
+        watermark=1760227200, run_start_ms=1760245200123, updated_at=1, rows_expected=10, exec_id=None
+    )
+    info = pc.decode_batch_info(raw.encode())
+    assert info == {
+        "state": "WRITING",
+        "watermark": 1760227200,
+        "run_start": 1760245200123,
+        "updated_at": 1,
+        "rows_expected": 10,
+    }
+    info["state"] = pc.STATE_PURGED
+    assert pc.decode_batch_info(pc.encode_batch_info(info))["rows_expected"] == 10
+
+
+@pytest.mark.parametrize(
+    "raw", ["", "not json", "[]", '{"state":"WRITING","watermark":1}', '{"watermark":1,"run_start":1}']
+)
+def test_decode_batch_info_rejects_corrupted(raw):
+    with pytest.raises(PackedCodecError):
+        pc.decode_batch_info(raw)
+
+
+def test_encode_batch_info_rejects_unknown_state():
+    with pytest.raises(PackedCodecError):
+        pc.build_batch_info(watermark=1, run_start_ms=1, state="DONE")
+
+
+def test_batch_info_works_with_activate_lua():
+    r, s = _lua_env()
+    old = pc.build_batch_member("a3f2c1d8", "aaaaaaaaaa")
+    new = pc.build_batch_member("a3f2c1d8", "bbbbbbbbbb")
+    r.hset(pc.versions_key(PREFIX), old, pc.build_batch_info(watermark=100, run_start_ms=1, rows_expected=5))
+    r.hset(pc.versions_key(PREFIX), new, pc.build_batch_info(watermark=200, run_start_ms=2))
+    assert _activate(s, old)[0] == 1
+    assert _activate(s, new)[0] == 1
+    retired = pc.decode_batch_info(r.hget(pc.versions_key(PREFIX), old))
+    assert retired["state"] == pc.STATE_RETIRED and retired["rows_expected"] == 5
+    assert pc.BATCH_RETIRED_AT in retired
+
+
+# ---------------------------------------------------------------- SCAN 匹配模式
+
+
+def test_scan_patterns_cover_exactly_one_table():
+    control, data = pc.table_key_patterns(PREFIX)
+    assert control == "{17893778831981982:ie3ton4o6vrh}:*"
+    assert data == "17893778831981982:ie3ton4o6vrh:*"
+    assert pc.batch_data_pattern(PREFIX, "a3f2c1d8", "mu9k18p8a7") == "17893778831981982:ie3ton4o6vrh:a3f2c1d8:mu9k18p8a7:*"
+    assert pc.meta_pattern(PREFIX) == "{17893778831981982:ie3ton4o6vrh}:__meta__:*"
+    assert pc.meta_key(PREFIX, "a3f2c1d8").startswith(pc.meta_key_prefix(PREFIX))
+
+
+def test_scan_patterns_escape_glob_metacharacters():
+    control, data = pc.table_key_patterns("1:a*b?[c]")
+    assert control == r"{1:a\*b\?\[c\]}:*"
+    assert data == r"1:a\*b\?\[c\]:*"