cachebind 1.0.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- cachebind/__init__.py +121 -0
- cachebind/indexes/__init__.py +61 -0
- cachebind/indexes/_breadcrumb.py +10 -0
- cachebind/indexes/_builder.py +171 -0
- cachebind/indexes/_serializer.py +17 -0
- cachebind/indexes/base.py +51 -0
- cachebind/indexes/evict.py +21 -0
- cachebind/indexes/key_value/__init__.py +14 -0
- cachebind/indexes/key_value/async_index.py +145 -0
- cachebind/indexes/key_value/base.py +30 -0
- cachebind/indexes/key_value/builder.py +170 -0
- cachebind/indexes/key_value/index.py +142 -0
- cachebind/indexes/ordered_sets/__init__.py +17 -0
- cachebind/indexes/ordered_sets/async_index.py +221 -0
- cachebind/indexes/ordered_sets/base.py +38 -0
- cachebind/indexes/ordered_sets/builder.py +146 -0
- cachebind/indexes/ordered_sets/index.py +218 -0
- cachebind/indexes/registry.py +38 -0
- cachebind/indexes/sets/__init__.py +14 -0
- cachebind/indexes/sets/async_index.py +124 -0
- cachebind/indexes/sets/base.py +24 -0
- cachebind/indexes/sets/builder.py +146 -0
- cachebind/indexes/sets/index.py +121 -0
- cachebind/indexes/tries/__init__.py +14 -0
- cachebind/indexes/tries/async_index.py +113 -0
- cachebind/indexes/tries/base.py +25 -0
- cachebind/indexes/tries/builder.py +141 -0
- cachebind/indexes/tries/index.py +113 -0
- cachebind/serializers/__init__.py +29 -0
- cachebind/serializers/bool_serializer.py +21 -0
- cachebind/serializers/dataclass_serializer.py +102 -0
- cachebind/serializers/datetime_serializer.py +22 -0
- cachebind/serializers/dict_serializer.py +29 -0
- cachebind/serializers/float_serializer.py +18 -0
- cachebind/serializers/int_serializer.py +20 -0
- cachebind/serializers/noop_serializer.py +19 -0
- cachebind/serializers/pydantic_serializer.py +29 -0
- cachebind/serializers/serializer.py +24 -0
- cachebind/serializers/str_serializer.py +13 -0
- cachebind/serializers/uuid_serializer.py +22 -0
- cachebind/storage/__init__.py +67 -0
- cachebind/storage/_redis.py +80 -0
- cachebind/storage/key_value/__init__.py +37 -0
- cachebind/storage/key_value/async_redis_hash_storage.py +73 -0
- cachebind/storage/key_value/async_redis_string_storage.py +72 -0
- cachebind/storage/key_value/async_storage.py +76 -0
- cachebind/storage/key_value/redis_hash_storage.py +73 -0
- cachebind/storage/key_value/redis_string_storage.py +72 -0
- cachebind/storage/key_value/storage.py +74 -0
- cachebind/storage/ordered_sets/__init__.py +29 -0
- cachebind/storage/ordered_sets/_values.py +60 -0
- cachebind/storage/ordered_sets/async_redis_ordered_set_storage.py +91 -0
- cachebind/storage/ordered_sets/async_storage.py +89 -0
- cachebind/storage/ordered_sets/redis_ordered_set_storage.py +88 -0
- cachebind/storage/ordered_sets/storage.py +85 -0
- cachebind/storage/sets/__init__.py +27 -0
- cachebind/storage/sets/async_redis_set_storage.py +54 -0
- cachebind/storage/sets/async_storage.py +49 -0
- cachebind/storage/sets/redis_set_storage.py +52 -0
- cachebind/storage/sets/storage.py +49 -0
- cachebind/storage/tries/__init__.py +27 -0
- cachebind/storage/tries/_reply.py +20 -0
- cachebind/storage/tries/_values.py +36 -0
- cachebind/storage/tries/async_redis_trie_storage.py +81 -0
- cachebind/storage/tries/async_storage.py +78 -0
- cachebind/storage/tries/redis_trie_storage.py +79 -0
- cachebind/storage/tries/storage.py +78 -0
- cachebind/tagging/__init__.py +19 -0
- cachebind/tagging/breadcrumbs/__init__.py +11 -0
- cachebind/tagging/breadcrumbs/colon_breadcrumbs.py +20 -0
- cachebind/tagging/breadcrumbs/noop_breadcrumbs.py +15 -0
- cachebind/tagging/breadcrumbs/protocol.py +15 -0
- cachebind/tagging/tag_keeper/__init__.py +12 -0
- cachebind/tagging/tag_keeper/_keys.py +10 -0
- cachebind/tagging/tag_keeper/async_set_tag_keeper.py +47 -0
- cachebind/tagging/tag_keeper/protocol.py +37 -0
- cachebind/tagging/tag_keeper/set_tag_keeper.py +47 -0
- cachebind-1.0.0.dist-info/METADATA +171 -0
- cachebind-1.0.0.dist-info/RECORD +81 -0
- cachebind-1.0.0.dist-info/WHEEL +4 -0
- cachebind-1.0.0.dist-info/licenses/LICENSE +21 -0
|
@@ -0,0 +1,146 @@
|
|
|
1
|
+
"""Build a registered ordered-set index from its parts and check that those parts agree."""
|
|
2
|
+
|
|
3
|
+
from collections.abc import Hashable
|
|
4
|
+
from typing import Any, cast
|
|
5
|
+
|
|
6
|
+
from cachebind.indexes._builder import (
|
|
7
|
+
check_key,
|
|
8
|
+
check_storage_type,
|
|
9
|
+
check_value_type,
|
|
10
|
+
index_class,
|
|
11
|
+
instance_class,
|
|
12
|
+
protocol_args,
|
|
13
|
+
serializer_class,
|
|
14
|
+
serializer_types,
|
|
15
|
+
storage_client_type,
|
|
16
|
+
)
|
|
17
|
+
from cachebind.indexes.ordered_sets.async_index import AsyncOrderedSetIndex
|
|
18
|
+
from cachebind.indexes.ordered_sets.index import OrderedSetIndex
|
|
19
|
+
from cachebind.serializers.serializer import Serializer
|
|
20
|
+
from cachebind.tagging import Breadcrumbs, ColonBreadcrumbs, NoopBreadcrumbs
|
|
21
|
+
from cachebind.storage.ordered_sets.async_storage import AsyncOrderedSetStorage
|
|
22
|
+
from cachebind.storage.ordered_sets.storage import OrderedSetStorage
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
def build_ordered_set_index[
|
|
26
|
+
ClientType,
|
|
27
|
+
MemberType,
|
|
28
|
+
StorageType: Hashable,
|
|
29
|
+
Storage: OrderedSetStorage[ClientType, StorageType],
|
|
30
|
+
](
|
|
31
|
+
key: str,
|
|
32
|
+
*,
|
|
33
|
+
member_type: type[MemberType],
|
|
34
|
+
serializer: Serializer[MemberType, StorageType],
|
|
35
|
+
storage: Storage,
|
|
36
|
+
breadcrumbs: Breadcrumbs | None = None,
|
|
37
|
+
) -> OrderedSetIndex[ClientType, MemberType, StorageType]:
|
|
38
|
+
"""Register a sync ordered-set index whose member, serializer, and storage types agree.
|
|
39
|
+
|
|
40
|
+
``serializer`` and ``storage`` are instances. The returned index is registered
|
|
41
|
+
and ready to use. Pass the storage client to each index method.
|
|
42
|
+
"""
|
|
43
|
+
return cast(
|
|
44
|
+
OrderedSetIndex[ClientType, MemberType, StorageType],
|
|
45
|
+
_build(
|
|
46
|
+
key,
|
|
47
|
+
member_type=member_type,
|
|
48
|
+
serializer=serializer,
|
|
49
|
+
storage=storage,
|
|
50
|
+
breadcrumbs=breadcrumbs,
|
|
51
|
+
base=OrderedSetIndex,
|
|
52
|
+
protocol=OrderedSetStorage,
|
|
53
|
+
other=AsyncOrderedSetStorage,
|
|
54
|
+
),
|
|
55
|
+
)
|
|
56
|
+
|
|
57
|
+
|
|
58
|
+
def build_async_ordered_set_index[
|
|
59
|
+
ClientType,
|
|
60
|
+
MemberType,
|
|
61
|
+
StorageType: Hashable,
|
|
62
|
+
Storage: AsyncOrderedSetStorage[ClientType, StorageType],
|
|
63
|
+
](
|
|
64
|
+
key: str,
|
|
65
|
+
*,
|
|
66
|
+
member_type: type[MemberType],
|
|
67
|
+
serializer: Serializer[MemberType, StorageType],
|
|
68
|
+
storage: Storage,
|
|
69
|
+
breadcrumbs: Breadcrumbs | None = None,
|
|
70
|
+
) -> AsyncOrderedSetIndex[ClientType, MemberType, StorageType]:
|
|
71
|
+
"""Register an async ordered-set index whose member, serializer, and storage types agree.
|
|
72
|
+
|
|
73
|
+
``serializer`` and ``storage`` are instances. The returned index is registered
|
|
74
|
+
and ready to use. Pass the storage client to each index method.
|
|
75
|
+
"""
|
|
76
|
+
return cast(
|
|
77
|
+
AsyncOrderedSetIndex[ClientType, MemberType, StorageType],
|
|
78
|
+
_build(
|
|
79
|
+
key,
|
|
80
|
+
member_type=member_type,
|
|
81
|
+
serializer=serializer,
|
|
82
|
+
storage=storage,
|
|
83
|
+
breadcrumbs=breadcrumbs,
|
|
84
|
+
base=AsyncOrderedSetIndex,
|
|
85
|
+
protocol=AsyncOrderedSetStorage,
|
|
86
|
+
other=OrderedSetStorage,
|
|
87
|
+
),
|
|
88
|
+
)
|
|
89
|
+
|
|
90
|
+
|
|
91
|
+
def _build(
|
|
92
|
+
key: str,
|
|
93
|
+
*,
|
|
94
|
+
member_type: Any,
|
|
95
|
+
serializer: Any,
|
|
96
|
+
storage: Any,
|
|
97
|
+
breadcrumbs: Breadcrumbs | None,
|
|
98
|
+
base: type[OrderedSetIndex[Any, Any, Any]] | type[AsyncOrderedSetIndex[Any, Any, Any]],
|
|
99
|
+
protocol: type[OrderedSetStorage[Any, Any]] | type[AsyncOrderedSetStorage[Any, Any]],
|
|
100
|
+
other: type[OrderedSetStorage[Any, Any]] | type[AsyncOrderedSetStorage[Any, Any]],
|
|
101
|
+
) -> Any:
|
|
102
|
+
check_key(key)
|
|
103
|
+
instance_class(key, serializer, label="serializer")
|
|
104
|
+
value_type, serializer_storage = serializer_types(key, serializer_class(serializer))
|
|
105
|
+
check_value_type(key, member_type, value_type, label="member type")
|
|
106
|
+
storage_cls = instance_class(key, storage, label="storage")
|
|
107
|
+
storage_type = _storage_type(key, storage_cls, protocol, other)
|
|
108
|
+
check_storage_type(key, serializer_storage, storage_type, storage_cls)
|
|
109
|
+
client_type = storage_client_type(key, storage_cls, protocol)
|
|
110
|
+
if breadcrumbs is None:
|
|
111
|
+
breadcrumbs = ColonBreadcrumbs()
|
|
112
|
+
else:
|
|
113
|
+
instance_class(key, breadcrumbs, label="breadcrumbs")
|
|
114
|
+
return index_class(
|
|
115
|
+
key,
|
|
116
|
+
serializer_instance=serializer,
|
|
117
|
+
storage=storage,
|
|
118
|
+
base=base,
|
|
119
|
+
module=__name__,
|
|
120
|
+
attributes={"member": member_type, "client_type": client_type, "breadcrumbs": breadcrumbs},
|
|
121
|
+
)
|
|
122
|
+
|
|
123
|
+
|
|
124
|
+
def _storage_type(
|
|
125
|
+
key: str,
|
|
126
|
+
storage: type,
|
|
127
|
+
protocol: type,
|
|
128
|
+
other: type,
|
|
129
|
+
) -> Any:
|
|
130
|
+
args = protocol_args(storage, protocol)
|
|
131
|
+
if args is None or len(args) != 2:
|
|
132
|
+
if protocol_args(storage, other) is not None:
|
|
133
|
+
if protocol is OrderedSetStorage:
|
|
134
|
+
raise TypeError(
|
|
135
|
+
f"index {key!r}: {storage.__name__} is asynchronous; "
|
|
136
|
+
"build_ordered_set_index requires OrderedSetStorage"
|
|
137
|
+
)
|
|
138
|
+
raise TypeError(
|
|
139
|
+
f"index {key!r}: {storage.__name__} is synchronous; "
|
|
140
|
+
"build_async_ordered_set_index requires AsyncOrderedSetStorage"
|
|
141
|
+
)
|
|
142
|
+
raise TypeError(
|
|
143
|
+
f"index {key!r}: {storage.__name__} does not declare "
|
|
144
|
+
f"{protocol.__name__}[ClientType, MemberType]"
|
|
145
|
+
)
|
|
146
|
+
return args[1]
|
|
@@ -0,0 +1,218 @@
|
|
|
1
|
+
"""Synchronous ordered-set index."""
|
|
2
|
+
|
|
3
|
+
from collections.abc import Hashable, Iterable, Iterator, Sequence
|
|
4
|
+
from typing import Self, cast
|
|
5
|
+
|
|
6
|
+
from cachebind.indexes._serializer import resolve_serializer
|
|
7
|
+
from cachebind.indexes._breadcrumb import storage_identifier
|
|
8
|
+
from cachebind.indexes.ordered_sets.base import OrderedSetBase, _empty_range
|
|
9
|
+
from cachebind.serializers.serializer import Serializer
|
|
10
|
+
from cachebind.storage.ordered_sets.storage import OrderedSetStorage
|
|
11
|
+
|
|
12
|
+
BATCH = 100
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
class OrderedSetIndex[ClientType, MemberType, StorageType: Hashable](
|
|
16
|
+
OrderedSetBase[ClientType, MemberType, StorageType]
|
|
17
|
+
):
|
|
18
|
+
"""Sync ordered-set index: member binding, storage key, and the storage that persists it.
|
|
19
|
+
|
|
20
|
+
Writes serialize the member and pass the score through. Reads deserialize members.
|
|
21
|
+
"""
|
|
22
|
+
|
|
23
|
+
storage: OrderedSetStorage[ClientType, StorageType]
|
|
24
|
+
|
|
25
|
+
def add(
|
|
26
|
+
self,
|
|
27
|
+
client: ClientType,
|
|
28
|
+
member: MemberType,
|
|
29
|
+
score: float,
|
|
30
|
+
**kwargs,
|
|
31
|
+
) -> str:
|
|
32
|
+
"""Add ``member`` with ``score``. A member that is already present gets the new score."""
|
|
33
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
34
|
+
stored = serializer.serialize(member)
|
|
35
|
+
self.storage.add(client, self.key, stored, score)
|
|
36
|
+
return self.breadcrumbs.encode(self.key, storage_identifier(stored))
|
|
37
|
+
|
|
38
|
+
def madd(
|
|
39
|
+
self,
|
|
40
|
+
client: ClientType,
|
|
41
|
+
members: Sequence[tuple[MemberType, float]],
|
|
42
|
+
**kwargs,
|
|
43
|
+
) -> list[str]:
|
|
44
|
+
"""Add every member with its score. A repeated member keeps the last score."""
|
|
45
|
+
if not members:
|
|
46
|
+
return []
|
|
47
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
48
|
+
serialized = serializer.mserialize([member for member, _score in members])
|
|
49
|
+
scores = (score for _member, score in members)
|
|
50
|
+
self.storage.madd(client, self.key, list(zip(serialized, scores, strict=True)))
|
|
51
|
+
return [
|
|
52
|
+
self.breadcrumbs.encode(self.key, storage_identifier(value)) for value in serialized
|
|
53
|
+
]
|
|
54
|
+
|
|
55
|
+
def remove(
|
|
56
|
+
self,
|
|
57
|
+
client: ClientType,
|
|
58
|
+
member: MemberType,
|
|
59
|
+
**kwargs,
|
|
60
|
+
) -> None:
|
|
61
|
+
"""Remove ``member``. A missing member is not an error."""
|
|
62
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
63
|
+
self.storage.remove(client, self.key, serializer.serialize(member))
|
|
64
|
+
|
|
65
|
+
def evict(self, client: ClientType, identifier: str) -> None:
|
|
66
|
+
"""Remove the entry for ``identifier``. A missing entry is not an error.
|
|
67
|
+
|
|
68
|
+
``identifier`` is the tag payload for one member (not the full encoded tag).
|
|
69
|
+
"""
|
|
70
|
+
self.storage.remove(client, self.key, cast(StorageType, identifier))
|
|
71
|
+
|
|
72
|
+
def mremove(
|
|
73
|
+
self,
|
|
74
|
+
client: ClientType,
|
|
75
|
+
members: Sequence[MemberType],
|
|
76
|
+
**kwargs,
|
|
77
|
+
) -> None:
|
|
78
|
+
"""Remove every member. Missing members are not an error."""
|
|
79
|
+
if not members:
|
|
80
|
+
return
|
|
81
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
82
|
+
self.storage.mremove(client, self.key, serializer.mserialize(members))
|
|
83
|
+
|
|
84
|
+
def contains(
|
|
85
|
+
self,
|
|
86
|
+
client: ClientType,
|
|
87
|
+
member: MemberType,
|
|
88
|
+
**kwargs,
|
|
89
|
+
) -> bool:
|
|
90
|
+
"""Return whether ``member`` is in the ordered set."""
|
|
91
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
92
|
+
return self.storage.contains(client, self.key, serializer.serialize(member))
|
|
93
|
+
|
|
94
|
+
def score(
|
|
95
|
+
self,
|
|
96
|
+
client: ClientType,
|
|
97
|
+
member: MemberType,
|
|
98
|
+
**kwargs,
|
|
99
|
+
) -> float | None:
|
|
100
|
+
"""Return the score of ``member``, or ``None`` when it is missing."""
|
|
101
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
102
|
+
return self.storage.score(client, self.key, serializer.serialize(member))
|
|
103
|
+
|
|
104
|
+
def rank(
|
|
105
|
+
self,
|
|
106
|
+
client: ClientType,
|
|
107
|
+
member: MemberType,
|
|
108
|
+
**kwargs,
|
|
109
|
+
) -> int | None:
|
|
110
|
+
"""Return the 0-based ascending rank of ``member``, or ``None`` when it is missing."""
|
|
111
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
112
|
+
return self.storage.rank(client, self.key, serializer.serialize(member))
|
|
113
|
+
|
|
114
|
+
def range(
|
|
115
|
+
self,
|
|
116
|
+
client: ClientType,
|
|
117
|
+
start: int,
|
|
118
|
+
stop: int,
|
|
119
|
+
**kwargs,
|
|
120
|
+
) -> list[MemberType]:
|
|
121
|
+
"""Return members from ``start`` through ``stop``, both inclusive."""
|
|
122
|
+
if _empty_range(start, stop):
|
|
123
|
+
return []
|
|
124
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
125
|
+
raw = self.storage.range(client, self.key, start, stop)
|
|
126
|
+
return serializer.mdeserialize(raw)
|
|
127
|
+
|
|
128
|
+
def range_with_scores(
|
|
129
|
+
self,
|
|
130
|
+
client: ClientType,
|
|
131
|
+
start: int,
|
|
132
|
+
stop: int,
|
|
133
|
+
**kwargs,
|
|
134
|
+
) -> list[tuple[MemberType, float]]:
|
|
135
|
+
"""Return members and scores from ``start`` through ``stop``, both inclusive."""
|
|
136
|
+
if _empty_range(start, stop):
|
|
137
|
+
return []
|
|
138
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
139
|
+
raw = self.storage.range_with_scores(client, self.key, start, stop)
|
|
140
|
+
members = serializer.mdeserialize([member for member, _score in raw])
|
|
141
|
+
return list(zip(members, (score for _member, score in raw), strict=True))
|
|
142
|
+
|
|
143
|
+
def rev_rank(
|
|
144
|
+
self,
|
|
145
|
+
client: ClientType,
|
|
146
|
+
member: MemberType,
|
|
147
|
+
**kwargs,
|
|
148
|
+
) -> int | None:
|
|
149
|
+
"""Return the 0-based descending rank of ``member``, or ``None`` when it is missing."""
|
|
150
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
151
|
+
return self.storage.rev_rank(client, self.key, serializer.serialize(member))
|
|
152
|
+
|
|
153
|
+
def rev_range(
|
|
154
|
+
self,
|
|
155
|
+
client: ClientType,
|
|
156
|
+
start: int,
|
|
157
|
+
stop: int,
|
|
158
|
+
**kwargs,
|
|
159
|
+
) -> list[MemberType]:
|
|
160
|
+
"""Return members from ``start`` through ``stop``, both inclusive, highest score first."""
|
|
161
|
+
if _empty_range(start, stop):
|
|
162
|
+
return []
|
|
163
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
164
|
+
raw = self.storage.rev_range(client, self.key, start, stop)
|
|
165
|
+
return serializer.mdeserialize(raw)
|
|
166
|
+
|
|
167
|
+
def rev_range_with_scores(
|
|
168
|
+
self,
|
|
169
|
+
client: ClientType,
|
|
170
|
+
start: int,
|
|
171
|
+
stop: int,
|
|
172
|
+
**kwargs,
|
|
173
|
+
) -> list[tuple[MemberType, float]]:
|
|
174
|
+
"""Return members and scores from ``start`` through ``stop``, highest score first."""
|
|
175
|
+
if _empty_range(start, stop):
|
|
176
|
+
return []
|
|
177
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
178
|
+
raw = self.storage.rev_range_with_scores(client, self.key, start, stop)
|
|
179
|
+
members = serializer.mdeserialize([member for member, _score in raw])
|
|
180
|
+
return list(zip(members, (score for _member, score in raw), strict=True))
|
|
181
|
+
|
|
182
|
+
def swap(self, client: ClientType) -> Self:
|
|
183
|
+
"""Rename this index aside and return an unregistered index for that data."""
|
|
184
|
+
return self.detach(self.storage.swap(client, self.key))
|
|
185
|
+
|
|
186
|
+
def drop(self, client: ClientType) -> None:
|
|
187
|
+
"""Delete the key this index is bound to. A missing key is not an error."""
|
|
188
|
+
self.storage.drop(client, self.key)
|
|
189
|
+
|
|
190
|
+
def iter(
|
|
191
|
+
self,
|
|
192
|
+
client: ClientType,
|
|
193
|
+
**kwargs,
|
|
194
|
+
) -> Iterator[tuple[MemberType, float]]:
|
|
195
|
+
"""Yield each member and score under this index key, lowest score first."""
|
|
196
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
197
|
+
return scored(self.storage.iter(client, self.key), serializer)
|
|
198
|
+
|
|
199
|
+
|
|
200
|
+
def scored[StorageType, ValueType](
|
|
201
|
+
raw: Iterable[tuple[StorageType, float]], serializer: Serializer[ValueType, StorageType]
|
|
202
|
+
) -> Iterator[tuple[ValueType, float]]:
|
|
203
|
+
"""Yield deserialized members and their scores, one ``mdeserialize`` per batch."""
|
|
204
|
+
batch: list[tuple[StorageType, float]] = []
|
|
205
|
+
for item in raw:
|
|
206
|
+
batch.append(item)
|
|
207
|
+
if len(batch) == BATCH:
|
|
208
|
+
yield from _scored(batch, serializer)
|
|
209
|
+
batch = []
|
|
210
|
+
if batch:
|
|
211
|
+
yield from _scored(batch, serializer)
|
|
212
|
+
|
|
213
|
+
|
|
214
|
+
def _scored[StorageType, ValueType](
|
|
215
|
+
batch: list[tuple[StorageType, float]], serializer: Serializer[ValueType, StorageType]
|
|
216
|
+
) -> Iterator[tuple[ValueType, float]]:
|
|
217
|
+
decoded = serializer.mdeserialize([member for member, _score in batch])
|
|
218
|
+
return zip(decoded, (score for _member, score in batch), strict=True)
|
|
@@ -0,0 +1,38 @@
|
|
|
1
|
+
"""Indexes registered for one storage client type."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Iterator
|
|
6
|
+
from typing import TYPE_CHECKING
|
|
7
|
+
|
|
8
|
+
if TYPE_CHECKING:
|
|
9
|
+
from cachebind.indexes.base import Index
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
class IndexRegistry:
|
|
13
|
+
"""Indexes that share one storage client type."""
|
|
14
|
+
|
|
15
|
+
def __init__(self, client_type: type) -> None:
|
|
16
|
+
self.client_type = client_type
|
|
17
|
+
self._indexes: dict[str, Index] = {}
|
|
18
|
+
|
|
19
|
+
def get(self, name: str) -> Index:
|
|
20
|
+
"""Return the index registered under this name."""
|
|
21
|
+
try:
|
|
22
|
+
return self._indexes[name]
|
|
23
|
+
except KeyError:
|
|
24
|
+
raise KeyError(
|
|
25
|
+
f"no index {name!r} registered for {self.client_type.__name__}"
|
|
26
|
+
) from None
|
|
27
|
+
|
|
28
|
+
def set(self, name: str, index: Index) -> None:
|
|
29
|
+
"""Register an index under this name."""
|
|
30
|
+
if name in self._indexes:
|
|
31
|
+
raise ValueError(f"index key {name!r} is already registered")
|
|
32
|
+
self._indexes[name] = index
|
|
33
|
+
|
|
34
|
+
def __contains__(self, name: object) -> bool:
|
|
35
|
+
return name in self._indexes
|
|
36
|
+
|
|
37
|
+
def __iter__(self) -> Iterator[str]:
|
|
38
|
+
return iter(self._indexes)
|
|
@@ -0,0 +1,14 @@
|
|
|
1
|
+
"""Set indexes bind a member to set storage and register that binding by key."""
|
|
2
|
+
|
|
3
|
+
from cachebind.indexes.sets.async_index import AsyncSetIndex
|
|
4
|
+
from cachebind.indexes.sets.base import SetBase
|
|
5
|
+
from cachebind.indexes.sets.builder import build_async_set_index, build_set_index
|
|
6
|
+
from cachebind.indexes.sets.index import SetIndex
|
|
7
|
+
|
|
8
|
+
__all__ = [
|
|
9
|
+
"AsyncSetIndex",
|
|
10
|
+
"SetBase",
|
|
11
|
+
"SetIndex",
|
|
12
|
+
"build_async_set_index",
|
|
13
|
+
"build_set_index",
|
|
14
|
+
]
|
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
"""Asynchronous set index."""
|
|
2
|
+
|
|
3
|
+
from collections.abc import AsyncIterable, AsyncIterator, Hashable, Sequence
|
|
4
|
+
from typing import Self, cast
|
|
5
|
+
|
|
6
|
+
from cachebind.indexes._serializer import resolve_serializer
|
|
7
|
+
from cachebind.indexes._breadcrumb import storage_identifier
|
|
8
|
+
from cachebind.indexes.sets.base import SetBase
|
|
9
|
+
from cachebind.serializers.serializer import Serializer
|
|
10
|
+
from cachebind.storage.sets.async_storage import AsyncSetStorage
|
|
11
|
+
|
|
12
|
+
BATCH = 100
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
class AsyncSetIndex[ClientType, MemberType, StorageType: Hashable](
|
|
16
|
+
SetBase[ClientType, MemberType, StorageType]
|
|
17
|
+
):
|
|
18
|
+
"""Async set index: member binding, storage key, and the storage that persists it.
|
|
19
|
+
|
|
20
|
+
Writes serialize the member. ``contains`` serializes the lookup value.
|
|
21
|
+
"""
|
|
22
|
+
|
|
23
|
+
storage: AsyncSetStorage[ClientType, StorageType]
|
|
24
|
+
|
|
25
|
+
async def add(
|
|
26
|
+
self,
|
|
27
|
+
client: ClientType,
|
|
28
|
+
member: MemberType,
|
|
29
|
+
**kwargs,
|
|
30
|
+
) -> str:
|
|
31
|
+
"""Add ``member``. A member that is already present is not an error."""
|
|
32
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
33
|
+
stored = serializer.serialize(member)
|
|
34
|
+
await self.storage.add(client, self.key, stored)
|
|
35
|
+
return self.breadcrumbs.encode(self.key, storage_identifier(stored))
|
|
36
|
+
|
|
37
|
+
async def madd(
|
|
38
|
+
self,
|
|
39
|
+
client: ClientType,
|
|
40
|
+
members: Sequence[MemberType],
|
|
41
|
+
**kwargs,
|
|
42
|
+
) -> list[str]:
|
|
43
|
+
"""Add every member."""
|
|
44
|
+
if not members:
|
|
45
|
+
return []
|
|
46
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
47
|
+
stored = serializer.mserialize(members)
|
|
48
|
+
await self.storage.madd(client, self.key, stored)
|
|
49
|
+
return [
|
|
50
|
+
self.breadcrumbs.encode(self.key, storage_identifier(value)) for value in stored
|
|
51
|
+
]
|
|
52
|
+
|
|
53
|
+
async def remove(
|
|
54
|
+
self,
|
|
55
|
+
client: ClientType,
|
|
56
|
+
member: MemberType,
|
|
57
|
+
**kwargs,
|
|
58
|
+
) -> None:
|
|
59
|
+
"""Remove ``member``. A missing member is not an error."""
|
|
60
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
61
|
+
await self.storage.remove(client, self.key, serializer.serialize(member))
|
|
62
|
+
|
|
63
|
+
async def evict(self, client: ClientType, identifier: str) -> None:
|
|
64
|
+
"""Remove the entry for ``identifier``. A missing entry is not an error.
|
|
65
|
+
|
|
66
|
+
``identifier`` is the tag payload for one member (not the full encoded tag).
|
|
67
|
+
"""
|
|
68
|
+
await self.storage.remove(client, self.key, cast(StorageType, identifier))
|
|
69
|
+
|
|
70
|
+
async def mremove(
|
|
71
|
+
self,
|
|
72
|
+
client: ClientType,
|
|
73
|
+
members: Sequence[MemberType],
|
|
74
|
+
**kwargs,
|
|
75
|
+
) -> None:
|
|
76
|
+
"""Remove every member. Missing members are not an error."""
|
|
77
|
+
if not members:
|
|
78
|
+
return
|
|
79
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
80
|
+
await self.storage.mremove(client, self.key, serializer.mserialize(members))
|
|
81
|
+
|
|
82
|
+
async def contains(
|
|
83
|
+
self,
|
|
84
|
+
client: ClientType,
|
|
85
|
+
member: MemberType,
|
|
86
|
+
**kwargs,
|
|
87
|
+
) -> bool:
|
|
88
|
+
"""Return whether ``member`` is in the set."""
|
|
89
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
90
|
+
return await self.storage.contains(client, self.key, serializer.serialize(member))
|
|
91
|
+
|
|
92
|
+
async def swap(self, client: ClientType) -> Self:
|
|
93
|
+
"""Rename this index aside and return an unregistered index for that data."""
|
|
94
|
+
return self.detach(await self.storage.swap(client, self.key))
|
|
95
|
+
|
|
96
|
+
async def drop(self, client: ClientType) -> None:
|
|
97
|
+
"""Delete the key this index is bound to. A missing key is not an error."""
|
|
98
|
+
await self.storage.drop(client, self.key)
|
|
99
|
+
|
|
100
|
+
async def iter(
|
|
101
|
+
self,
|
|
102
|
+
client: ClientType,
|
|
103
|
+
**kwargs,
|
|
104
|
+
) -> AsyncIterator[MemberType]:
|
|
105
|
+
"""Yield each member stored under this index key."""
|
|
106
|
+
serializer = resolve_serializer(self.serializer, kwargs)
|
|
107
|
+
async for member in async_values(self.storage.iter(client, self.key), serializer):
|
|
108
|
+
yield member
|
|
109
|
+
|
|
110
|
+
|
|
111
|
+
async def async_values[StorageType, ValueType](
|
|
112
|
+
raw: AsyncIterable[StorageType], serializer: Serializer[ValueType, StorageType]
|
|
113
|
+
) -> AsyncIterator[ValueType]:
|
|
114
|
+
"""Yield deserialized values, calling ``mdeserialize`` once per batch."""
|
|
115
|
+
batch: list[StorageType] = []
|
|
116
|
+
async for value in raw:
|
|
117
|
+
batch.append(value)
|
|
118
|
+
if len(batch) == BATCH:
|
|
119
|
+
for decoded in serializer.mdeserialize(batch):
|
|
120
|
+
yield decoded
|
|
121
|
+
batch = []
|
|
122
|
+
if batch:
|
|
123
|
+
for decoded in serializer.mdeserialize(batch):
|
|
124
|
+
yield decoded
|
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
"""Shared set index attributes."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Hashable
|
|
6
|
+
|
|
7
|
+
from cachebind.indexes.base import Index
|
|
8
|
+
from cachebind.serializers.serializer import Serializer
|
|
9
|
+
from cachebind.tagging import Breadcrumbs, NoopBreadcrumbs
|
|
10
|
+
from cachebind.storage.sets.async_storage import AsyncSetStorage
|
|
11
|
+
from cachebind.storage.sets.storage import SetStorage
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
class SetBase[ClientType, MemberType, StorageType: Hashable](Index):
|
|
15
|
+
"""Member, serializer, storage key, and storage for a set index.
|
|
16
|
+
|
|
17
|
+
``key`` is the set name. ``storage`` stores serialized members.
|
|
18
|
+
Each call receives the storage client.
|
|
19
|
+
"""
|
|
20
|
+
|
|
21
|
+
member: type[MemberType]
|
|
22
|
+
breadcrumbs: Breadcrumbs = NoopBreadcrumbs()
|
|
23
|
+
serializer: Serializer[MemberType, StorageType]
|
|
24
|
+
storage: SetStorage[ClientType, StorageType] | AsyncSetStorage[ClientType, StorageType]
|