warm-rust 0.6.5

Local-first search engine and agent memory: fast approximate nearest-neighbor and BM25 full-text search, encrypted stores, provable deletion, built on vector-symbolic architectures.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

# Copyright 2024-2026 WritersLogic Contributors
# SPDX-License-Identifier: Apache-2.0

import pytest

import writerslogic_warm as hm


@pytest.mark.parametrize("dim,n", [(3, 16), (5, 16), (4, 15), (4, 17)])
def test_incompatible_members_raise_value_error(dim, n):
    a = hm.PhaseHVec.random(4, 16, 1)
    b = hm.PhaseHVec.random(dim, n, 2)
    for action in [
        lambda: hm.PhaseHVec.bundle([a, b]),
        lambda: hm.resonator_factorize(a, [[a, b]]),
        lambda: hm.resonator_factorize(a, [[b]]),
        lambda: hm.resonator_factorize(a, [[a], [b]]),
    ]:
        with pytest.raises(ValueError, match="dimension or resolution"):
            action()


def test_empty_collections_follow_the_declared_contract():
    a = hm.PhaseHVec.random(4, 16, 1)
    with pytest.raises(ValueError, match="empty list"):
        hm.PhaseHVec.bundle([])
    for books in [[[]], [[a], []], [[], [a]]]:
        with pytest.raises(ValueError, match="must not be empty"):
            hm.resonator_factorize(a, books)
    assert hm.resonator_factorize(a, []) == []


@pytest.mark.parametrize("dim", [65535, 65536, 65537])
def test_dimension_limit(dim):
    if dim > 65536:
        with pytest.raises(ValueError, match="phase dimensions"):
            hm.PhaseHVec.random(dim, 16, 1)
    else:
        assert hm.PhaseHVec.random(dim, 16, 1).dim == dim


@pytest.mark.parametrize("count", [65535, 65536, 65537])
def test_bundle_item_limit_without_cloning_vectors(count):
    a = hm.PhaseHVec.random(0, 16, 1)
    if count > 65536:
        with pytest.raises(ValueError, match="phase items"):
            hm.PhaseHVec.bundle([a] * count)
    else:
        assert hm.PhaseHVec.bundle([a] * count).phases() == []


@pytest.mark.parametrize("count", [63, 64, 65])
def test_bundle_element_limit(count):
    a = hm.PhaseHVec.random(65536, 2, 1)
    if count > 64:
        with pytest.raises(ValueError, match="phase elements"):
            hm.PhaseHVec.bundle([a] * count)
    else:
        assert hm.PhaseHVec.bundle([a] * count).phases() == a.phases()


@pytest.mark.parametrize("count", [63, 64, 65])
def test_factor_limit(count):
    a = hm.PhaseHVec.random(1, 16, 1)
    if count > 64:
        with pytest.raises(ValueError, match="resonator factors"):
            hm.resonator_factorize(a, [[a]] * count, max_iter=0)
    else:
        assert len(hm.resonator_factorize(a, [[a]] * count, max_iter=0)) == count


@pytest.mark.parametrize("iterations", [999, 1000, 1001])
def test_iteration_limit(iterations):
    a = hm.PhaseHVec.random(1, 16, 1)
    if iterations > 1000:
        with pytest.raises(ValueError, match="resonator iterations"):
            hm.resonator_factorize(a, [[a]], max_iter=iterations)
    else:
        assert hm.resonator_factorize(a, [[a]], max_iter=iterations) == [(0, pytest.approx(1.0))]


def test_work_admission_and_valid_algebra():
    large = hm.PhaseHVec.random(65536, 16, 1)
    with pytest.raises(ValueError, match="resonator work"):
        hm.resonator_factorize(large, [[large]] * 64)
    a = hm.PhaseHVec.random(128, 16, 1)
    b = hm.PhaseHVec.random(128, 16, 2)
    assert a.bind(b).unbind(b).phases() == a.phases()
    assert hm.PhaseHVec.bundle([a]).phases() == a.phases()
    assert hm.PhaseHVec.bundle([a, b]).phases() == hm.PhaseHVec.bundle([b, a]).phases()
    factors = hm.resonator_factorize(a.bind(b), [[a], [b]])
    assert [index for index, _ in factors] == [0, 0]
    assert all(score == pytest.approx(1.0) for _, score in factors)


@pytest.mark.parametrize("entries", [33332, 33333, 33334])
def test_work_limit_accounts_for_codebook_scans_and_iterations(entries):
    a = hm.PhaseHVec.random(1, 16, 1)
    # (3 * entries + factors**2) * dimensions * (iterations + 1).
    if entries > 33333:
        with pytest.raises(ValueError, match="resonator work"):
            hm.resonator_factorize(a, [[a] * entries], max_iter=999)
    else:
        assert hm.resonator_factorize(a, [[a] * entries], max_iter=999) == [(entries - 1, pytest.approx(1.0))]


@pytest.mark.parametrize("resolution", [1, 2, 3, 65535, 65536, 65537])
def test_resolution_boundaries(resolution):
    if resolution < 2 or resolution > 65536:
        with pytest.raises(ValueError, match="resolution"):
            hm.PhaseHVec.random(1, resolution, 1)
    else:
        assert hm.PhaseHVec.random(1, resolution, 1).n == resolution