Skip to content

redis_service.operations.zset

zset

codex_platform.redis_service.operations.zset

Redis Sorted Set (ZSet) operations.

A Sorted Set is a set where every member has an associated float score. Use it for leaderboards, priority queues, and time-based event indexes.

Classes

ZSetOperations

Redis Sorted Set operations (ZADD / ZRANGE / ZRANGEBYSCORE / ZREM and more).

Accepts an already-constructed redis.asyncio.Redis client. All methods wrap Redis errors in typed exceptions.

Example::

ops = ZSetOperations(client)
await ops.add("leaderboard", {"alice": 1500.0, "bob": 1200.0})
top = await ops.range("leaderboard", 0, 9, reverse=True, with_scores=True)
Source code in src/codex_platform/redis_service/operations/zset.py 
 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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
class ZSetOperations:
    """Redis Sorted Set operations (ZADD / ZRANGE / ZRANGEBYSCORE / ZREM and more).

    Accepts an already-constructed ``redis.asyncio.Redis`` client.
    All methods wrap Redis errors in typed exceptions.

    Example::

        ops = ZSetOperations(client)
        await ops.add("leaderboard", {"alice": 1500.0, "bob": 1200.0})
        top = await ops.range("leaderboard", 0, 9, reverse=True, with_scores=True)
    """

    def __init__(self, client: Redis) -> None:
        self.client = client

    @catch_redis_errors
    async def add(self, key: "str | BaseRedisKey", mapping: dict[str, float], **kwargs: Any) -> int:
        """Add members with scores to a sorted set (ZADD).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            mapping: Dict of ``{member: score}`` pairs.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            Number of new members added (existing members with updated scores are not counted).

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        return int(await self.client.zadd(real_key, mapping))

    @catch_redis_errors
    async def score(self, key: "str | BaseRedisKey", member: str, **kwargs: Any) -> float | None:
        """Return the score of a member in a sorted set (ZSCORE).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            member: Member name.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            Float score of the member, or ``None`` if the member does not exist.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        val = await self.client.zscore(real_key, member)
        return float(val) if val is not None else None

    @catch_redis_errors
    async def rank(self, key: "str | BaseRedisKey", member: str, reverse: bool = False, **kwargs: Any) -> int | None:
        """Return the rank (position) of a member in a sorted set (ZRANK / ZREVRANK).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            member: Member name.
            reverse: If ``True``, use ZREVRANK (rank by descending score). Defaults to ``False``.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            Zero-based rank of the member, or ``None`` if the member does not exist.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        fn = self.client.zrevrank if reverse else self.client.zrank
        result = await fn(real_key, member)
        return int(result) if result is not None else None

    @catch_redis_errors
    async def range(
        self,
        key: "str | BaseRedisKey",
        start: int = 0,
        end: int = -1,
        reverse: bool = False,
        with_scores: bool = False,
        **kwargs: Any,
    ) -> list[str] | list[tuple[str, float]]:
        """Return a range of members by rank (ZRANGE / ZREVRANGE).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            start: Start rank (0-based).
            end: End rank inclusive. ``-1`` means the last member.
            reverse: If ``True``, return members in descending score order (ZREVRANGE).
            with_scores: If ``True``, return ``[(member, score), ...]`` tuples.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            List of member strings, or list of ``(member, score)`` tuples if ``with_scores=True``.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        if reverse:
            result = await self.client.zrevrange(real_key, start, end, withscores=with_scores)
        else:
            result = await self.client.zrange(real_key, start, end, withscores=with_scores)
        return result

    @catch_redis_errors
    async def range_by_score(
        self,
        key: "str | BaseRedisKey",
        min_score: float,
        max_score: float,
        with_scores: bool = False,
        **kwargs: Any,
    ) -> list[str] | list[tuple[str, float]]:
        """Return members within a score range (ZRANGEBYSCORE).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            min_score: Minimum score (inclusive).
            max_score: Maximum score (inclusive).
            with_scores: If ``True``, return ``[(member, score), ...]`` tuples.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            List of member strings, or list of ``(member, score)`` tuples if ``with_scores=True``.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        return await self.client.zrangebyscore(real_key, min_score, max_score, withscores=with_scores)

    @catch_redis_errors
    async def remove(self, key: "str | BaseRedisKey", *members: str, **kwargs: Any) -> int:
        """Remove one or more members from a sorted set (ZREM).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            *members: Member names to remove.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            Number of members actually removed.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        return int(await self.client.zrem(real_key, *members))

    @catch_redis_errors
    async def card(self, key: "str | BaseRedisKey", **kwargs: Any) -> int:
        """Return the number of members in a sorted set (ZCARD).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            Number of members. ``0`` if the key does not exist.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        return int(await self.client.zcard(real_key))

    @catch_redis_errors
    async def increment(self, key: "str | BaseRedisKey", member: str, amount: float = 1.0, **kwargs: Any) -> float:
        """Increment the score of a member by the given amount (ZINCRBY).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            member: Member name.
            amount: Increment value. Defaults to ``1.0``.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            New score of the member after incrementing.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        return float(await self.client.zincrby(real_key, amount, member))

    @catch_redis_errors
    async def count(self, key: "str | BaseRedisKey", min_score: float, max_score: float, **kwargs: Any) -> int:
        """Count members within a score range (ZCOUNT).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            min_score: Minimum score (inclusive).
            max_score: Maximum score (inclusive).
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            Number of members with score in ``[min_score, max_score]``.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        return int(await self.client.zcount(real_key, min_score, max_score))

    @catch_redis_errors
    async def remove_by_rank(self, key: "str | BaseRedisKey", start: int, end: int, **kwargs: Any) -> int:
        """Remove members by rank range (ZREMRANGEBYRANK).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            start: Start rank (inclusive, 0-based).
            end: End rank (inclusive).
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            Number of members removed.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        return int(await self.client.zremrangebyrank(real_key, start, end))

    @catch_redis_errors
    async def remove_by_score(
        self, key: "str | BaseRedisKey", min_score: float, max_score: float, **kwargs: Any
    ) -> int:
        """Remove members within a score range (ZREMRANGEBYSCORE).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            min_score: Minimum score (inclusive).
            max_score: Maximum score (inclusive).
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            Number of members removed.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        return int(await self.client.zremrangebyscore(real_key, min_score, max_score))
Functions
add(key, mapping, **kwargs) async

Add members with scores to a sorted set (ZADD).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
mapping dict[str, float]

Dict of {member: score} pairs.

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
int

Number of new members added (existing members with updated scores are not counted).

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
@catch_redis_errors
async def add(self, key: "str | BaseRedisKey", mapping: dict[str, float], **kwargs: Any) -> int:
    """Add members with scores to a sorted set (ZADD).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        mapping: Dict of ``{member: score}`` pairs.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        Number of new members added (existing members with updated scores are not counted).

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return int(await self.client.zadd(real_key, mapping))
score(key, member, **kwargs) async

Return the score of a member in a sorted set (ZSCORE).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
member str

Member name.

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
float | None

Float score of the member, or None if the member does not exist.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@catch_redis_errors
async def score(self, key: "str | BaseRedisKey", member: str, **kwargs: Any) -> float | None:
    """Return the score of a member in a sorted set (ZSCORE).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        member: Member name.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        Float score of the member, or ``None`` if the member does not exist.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    val = await self.client.zscore(real_key, member)
    return float(val) if val is not None else None
rank(key, member, reverse=False, **kwargs) async

Return the rank (position) of a member in a sorted set (ZRANK / ZREVRANK).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
member str

Member name.

 required
reverse bool

If True, use ZREVRANK (rank by descending score). Defaults to False.

 False
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
int | None

Zero-based rank of the member, or None if the member does not exist.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
@catch_redis_errors
async def rank(self, key: "str | BaseRedisKey", member: str, reverse: bool = False, **kwargs: Any) -> int | None:
    """Return the rank (position) of a member in a sorted set (ZRANK / ZREVRANK).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        member: Member name.
        reverse: If ``True``, use ZREVRANK (rank by descending score). Defaults to ``False``.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        Zero-based rank of the member, or ``None`` if the member does not exist.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    fn = self.client.zrevrank if reverse else self.client.zrank
    result = await fn(real_key, member)
    return int(result) if result is not None else None
range(key, start=0, end=-1, reverse=False, with_scores=False, **kwargs) async

Return a range of members by rank (ZRANGE / ZREVRANGE).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
start int

Start rank (0-based).

 0
end int

End rank inclusive. -1 means the last member.

 -1
reverse bool

If True, return members in descending score order (ZREVRANGE).

 False
with_scores bool

If True, return [(member, score), ...] tuples.

 False
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
list[str] | list[tuple[str, float]]

List of member strings, or list of (member, score) tuples if with_scores=True.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
@catch_redis_errors
async def range(
    self,
    key: "str | BaseRedisKey",
    start: int = 0,
    end: int = -1,
    reverse: bool = False,
    with_scores: bool = False,
    **kwargs: Any,
) -> list[str] | list[tuple[str, float]]:
    """Return a range of members by rank (ZRANGE / ZREVRANGE).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        start: Start rank (0-based).
        end: End rank inclusive. ``-1`` means the last member.
        reverse: If ``True``, return members in descending score order (ZREVRANGE).
        with_scores: If ``True``, return ``[(member, score), ...]`` tuples.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        List of member strings, or list of ``(member, score)`` tuples if ``with_scores=True``.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    if reverse:
        result = await self.client.zrevrange(real_key, start, end, withscores=with_scores)
    else:
        result = await self.client.zrange(real_key, start, end, withscores=with_scores)
    return result
range_by_score(key, min_score, max_score, with_scores=False, **kwargs) async

Return members within a score range (ZRANGEBYSCORE).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
min_score float

Minimum score (inclusive).

 required
max_score float

Maximum score (inclusive).

 required
with_scores bool

If True, return [(member, score), ...] tuples.

 False
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
list[str] | list[tuple[str, float]]

List of member strings, or list of (member, score) tuples if with_scores=True.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
@catch_redis_errors
async def range_by_score(
    self,
    key: "str | BaseRedisKey",
    min_score: float,
    max_score: float,
    with_scores: bool = False,
    **kwargs: Any,
) -> list[str] | list[tuple[str, float]]:
    """Return members within a score range (ZRANGEBYSCORE).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        min_score: Minimum score (inclusive).
        max_score: Maximum score (inclusive).
        with_scores: If ``True``, return ``[(member, score), ...]`` tuples.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        List of member strings, or list of ``(member, score)`` tuples if ``with_scores=True``.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return await self.client.zrangebyscore(real_key, min_score, max_score, withscores=with_scores)
remove(key, *members, **kwargs) async

Remove one or more members from a sorted set (ZREM).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
*members str

Member names to remove.

 ()
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
int

Number of members actually removed.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
@catch_redis_errors
async def remove(self, key: "str | BaseRedisKey", *members: str, **kwargs: Any) -> int:
    """Remove one or more members from a sorted set (ZREM).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        *members: Member names to remove.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        Number of members actually removed.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return int(await self.client.zrem(real_key, *members))
card(key, **kwargs) async

Return the number of members in a sorted set (ZCARD).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
int

Number of members. 0 if the key does not exist.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
@catch_redis_errors
async def card(self, key: "str | BaseRedisKey", **kwargs: Any) -> int:
    """Return the number of members in a sorted set (ZCARD).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        Number of members. ``0`` if the key does not exist.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return int(await self.client.zcard(real_key))
increment(key, member, amount=1.0, **kwargs) async

Increment the score of a member by the given amount (ZINCRBY).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
member str

Member name.

 required
amount float

Increment value. Defaults to 1.0.

 1.0
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
float

New score of the member after incrementing.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
@catch_redis_errors
async def increment(self, key: "str | BaseRedisKey", member: str, amount: float = 1.0, **kwargs: Any) -> float:
    """Increment the score of a member by the given amount (ZINCRBY).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        member: Member name.
        amount: Increment value. Defaults to ``1.0``.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        New score of the member after incrementing.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return float(await self.client.zincrby(real_key, amount, member))
count(key, min_score, max_score, **kwargs) async

Count members within a score range (ZCOUNT).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
min_score float

Minimum score (inclusive).

 required
max_score float

Maximum score (inclusive).

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
int

Number of members with score in [min_score, max_score].

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
@catch_redis_errors
async def count(self, key: "str | BaseRedisKey", min_score: float, max_score: float, **kwargs: Any) -> int:
    """Count members within a score range (ZCOUNT).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        min_score: Minimum score (inclusive).
        max_score: Maximum score (inclusive).
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        Number of members with score in ``[min_score, max_score]``.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return int(await self.client.zcount(real_key, min_score, max_score))
remove_by_rank(key, start, end, **kwargs) async

Remove members by rank range (ZREMRANGEBYRANK).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
start int

Start rank (inclusive, 0-based).

 required
end int

End rank (inclusive).

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
int

Number of members removed.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
@catch_redis_errors
async def remove_by_rank(self, key: "str | BaseRedisKey", start: int, end: int, **kwargs: Any) -> int:
    """Remove members by rank range (ZREMRANGEBYRANK).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        start: Start rank (inclusive, 0-based).
        end: End rank (inclusive).
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        Number of members removed.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return int(await self.client.zremrangebyrank(real_key, start, end))
remove_by_score(key, min_score, max_score, **kwargs) async

Remove members within a score range (ZREMRANGEBYSCORE).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
min_score float

Minimum score (inclusive).

 required
max_score float

Maximum score (inclusive).

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
int

Number of members removed.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/zset.py 
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
@catch_redis_errors
async def remove_by_score(
    self, key: "str | BaseRedisKey", min_score: float, max_score: float, **kwargs: Any
) -> int:
    """Remove members within a score range (ZREMRANGEBYSCORE).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        min_score: Minimum score (inclusive).
        max_score: Maximum score (inclusive).
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        Number of members removed.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return int(await self.client.zremrangebyscore(real_key, min_score, max_score))

Functions