Skip to content

redis_service.operations.string

string

codex_platform.redis_service.operations.string

Redis String/Key operations.

Classes

StringOperations

Redis String and key-level operations (SET / GET / EXPIRE / TTL and more).

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

Example::

ops = StringOperations(client)
await ops.set("session:abc", "token-value", ttl=3600)
token = await ops.get("session:abc")
Source code in src/codex_platform/redis_service/operations/string.py 
 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
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
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
class StringOperations:
    """Redis String and key-level operations (SET / GET / EXPIRE / TTL and more).

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

    Example::

        ops = StringOperations(client)
        await ops.set("session:abc", "token-value", ttl=3600)
        token = await ops.get("session:abc")
    """

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

    @catch_redis_errors
    async def set(self, key: "str | BaseRedisKey", value: str, ttl: int | None = None, **kwargs: Any) -> None:
        """Set a string value (SET).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            value: String value to store.
            ttl: Expiry in seconds. ``None`` means no expiry.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        await self.client.set(real_key, value, ex=ttl)

    @catch_redis_errors
    async def setnx(self, key: "str | BaseRedisKey", value: str, ttl: int | None = None, **kwargs: Any) -> bool:
        """Set a value only if the key does not exist (SET NX).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            value: String value to store.
            ttl: Expiry in seconds. ``None`` means no expiry.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            ``True`` if the value was set, ``False`` if the key already existed.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        return bool(await self.client.set(real_key, value, ex=ttl, nx=True))

    @catch_redis_errors
    async def get(self, key: "str | BaseRedisKey", **kwargs: Any) -> str | None:
        """Retrieve a string value (GET).

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

        Returns:
            String value, or ``None`` if the key does not exist.

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

    @catch_redis_errors
    async def getset(self, key: "str | BaseRedisKey", value: str, **kwargs: Any) -> str | None:
        """Atomically set a new value and return the previous one (GETSET).

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

        Returns:
            Previous value, or ``None`` if the key did not exist.

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

    @catch_redis_errors
    async def mget(self, *keys: str) -> list[str | None]:
        """Retrieve values for multiple keys in a single request (MGET).

        Args:
            *keys: Redis key strings.

        Returns:
            List of values in the same order as ``keys``.
            ``None`` for keys that do not exist.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        values = await self.client.mget(list(keys))
        return [str(v) if v is not None else None for v in values]

    @catch_redis_errors
    async def mset(self, mapping: dict[str, str]) -> None:
        """Set values for multiple keys in a single call (MSET).

        Args:
            mapping: Dict of ``{key: value}`` pairs to write.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        await self.client.mset(mapping)

    @catch_redis_errors
    async def incr(self, key: "str | BaseRedisKey", **kwargs: Any) -> int:
        """Increment a numeric value by 1 (INCR).

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

        Returns:
            New value after incrementing.

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

    @catch_redis_errors
    async def incrby(self, key: "str | BaseRedisKey", amount: int, **kwargs: Any) -> int:
        """Increment a numeric value by a given amount (INCRBY).

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

        Returns:
            New value after incrementing.

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

    @catch_redis_errors
    async def append(self, key: "str | BaseRedisKey", value: str, **kwargs: Any) -> int:
        """Append a string to an existing value (APPEND).

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

        Returns:
            New total length of the value after appending.

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

    @catch_redis_errors
    async def delete(self, key: "str | BaseRedisKey", **kwargs: Any) -> None:
        """Delete a key (DEL).

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

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

    @catch_redis_errors
    async def delete_by_pattern(self, pattern: str) -> int:
        """Delete all keys matching a glob pattern (SCAN + DEL).

        Args:
            pattern: Glob pattern, e.g. ``"session:*"``.

        Returns:
            Number of keys deleted.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        keys = [k async for k in self.client.scan_iter(match=pattern)]
        if not keys:
            return 0
        return int(await self.client.delete(*keys))

    @catch_redis_errors
    async def expire(self, key: "str | BaseRedisKey", ttl: int, **kwargs: Any) -> bool:
        """Set a TTL (expiry) on a key in seconds (EXPIRE).

        Args:
            key: Redis key or a ``BaseRedisKey`` instance.
            ttl: Time-to-live in seconds.
            **kwargs: Extra parameters forwarded to ``resolve_key``.

        Returns:
            ``True`` if the TTL was set, ``False`` if the key does not exist.

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

    @catch_redis_errors
    async def ttl(self, key: "str | BaseRedisKey", **kwargs: Any) -> int:
        """Return the remaining TTL of a key in seconds (TTL).

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

        Returns:
            Remaining TTL in seconds. ``-1`` if no TTL is set, ``-2`` 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.ttl(real_key))

    @catch_redis_errors
    async def exists(self, key: "str | BaseRedisKey", **kwargs: Any) -> bool:
        """Check whether a key exists (EXISTS).

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

        Returns:
            ``True`` if the key exists, ``False`` otherwise.

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

    @catch_redis_errors
    async def rename(self, key: "str | BaseRedisKey", new_key: str, **kwargs: Any) -> None:
        """Rename a key (RENAME).

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

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

    @catch_redis_errors
    async def key_type(self, key: "str | BaseRedisKey", **kwargs: Any) -> str:
        """Return the data type stored at a key (TYPE).

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

        Returns:
            One of: ``"string"``, ``"list"``, ``"set"``, ``"zset"``, ``"hash"``, ``"stream"``.

        Raises:
            RedisConnectionError: Redis connection failure.
            RedisServiceError: Redis operation failure.
        """
        real_key = resolve_key(key, **kwargs)
        return await self.client.type(real_key)
Functions
set(key, value, ttl=None, **kwargs) async

Set a string value (SET).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
value str

String value to store.

 required
ttl int | None

Expiry in seconds. None means no expiry.

 None
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
@catch_redis_errors
async def set(self, key: "str | BaseRedisKey", value: str, ttl: int | None = None, **kwargs: Any) -> None:
    """Set a string value (SET).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        value: String value to store.
        ttl: Expiry in seconds. ``None`` means no expiry.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    await self.client.set(real_key, value, ex=ttl)
setnx(key, value, ttl=None, **kwargs) async

Set a value only if the key does not exist (SET NX).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
value str

String value to store.

 required
ttl int | None

Expiry in seconds. None means no expiry.

 None
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
bool

True if the value was set, False if the key already existed.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
@catch_redis_errors
async def setnx(self, key: "str | BaseRedisKey", value: str, ttl: int | None = None, **kwargs: Any) -> bool:
    """Set a value only if the key does not exist (SET NX).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        value: String value to store.
        ttl: Expiry in seconds. ``None`` means no expiry.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        ``True`` if the value was set, ``False`` if the key already existed.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return bool(await self.client.set(real_key, value, ex=ttl, nx=True))
get(key, **kwargs) async

Retrieve a string value (GET).

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
str | None

String value, or None 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/string.py 
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
@catch_redis_errors
async def get(self, key: "str | BaseRedisKey", **kwargs: Any) -> str | None:
    """Retrieve a string value (GET).

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

    Returns:
        String value, or ``None`` if the key does not exist.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    val = await self.client.get(real_key)
    return str(val) if val is not None else None
getset(key, value, **kwargs) async

Atomically set a new value and return the previous one (GETSET).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
value str

New value to store.

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
str | None

Previous value, or None if the key did not exist.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
@catch_redis_errors
async def getset(self, key: "str | BaseRedisKey", value: str, **kwargs: Any) -> str | None:
    """Atomically set a new value and return the previous one (GETSET).

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

    Returns:
        Previous value, or ``None`` if the key did not exist.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    val = await self.client.getset(real_key, value)
    return str(val) if val is not None else None
mget(*keys) async

Retrieve values for multiple keys in a single request (MGET).

Parameters:

Name Type Description Default
*keys str

Redis key strings.

 ()

Returns:

Type Description
list[str | None]

List of values in the same order as keys.
list[str | None]

None for keys that do not exist.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
@catch_redis_errors
async def mget(self, *keys: str) -> list[str | None]:
    """Retrieve values for multiple keys in a single request (MGET).

    Args:
        *keys: Redis key strings.

    Returns:
        List of values in the same order as ``keys``.
        ``None`` for keys that do not exist.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    values = await self.client.mget(list(keys))
    return [str(v) if v is not None else None for v in values]
mset(mapping) async

Set values for multiple keys in a single call (MSET).

Parameters:

Name Type Description Default
mapping dict[str, str]

Dict of {key: value} pairs to write.

 required

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
128
129
130
131
132
133
134
135
136
137
138
139
@catch_redis_errors
async def mset(self, mapping: dict[str, str]) -> None:
    """Set values for multiple keys in a single call (MSET).

    Args:
        mapping: Dict of ``{key: value}`` pairs to write.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    await self.client.mset(mapping)
incr(key, **kwargs) async

Increment a numeric value by 1 (INCR).

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

New value after incrementing.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
@catch_redis_errors
async def incr(self, key: "str | BaseRedisKey", **kwargs: Any) -> int:
    """Increment a numeric value by 1 (INCR).

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

    Returns:
        New value after incrementing.

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

Increment a numeric value by a given amount (INCRBY).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
amount int

Increment step.

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
int

New value after incrementing.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
@catch_redis_errors
async def incrby(self, key: "str | BaseRedisKey", amount: int, **kwargs: Any) -> int:
    """Increment a numeric value by a given amount (INCRBY).

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

    Returns:
        New value after incrementing.

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

Append a string to an existing value (APPEND).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
value str

String to append.

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
int

New total length of the value after appending.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
@catch_redis_errors
async def append(self, key: "str | BaseRedisKey", value: str, **kwargs: Any) -> int:
    """Append a string to an existing value (APPEND).

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

    Returns:
        New total length of the value after appending.

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

Delete a key (DEL).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
197
198
199
200
201
202
203
204
205
206
207
208
209
210
@catch_redis_errors
async def delete(self, key: "str | BaseRedisKey", **kwargs: Any) -> None:
    """Delete a key (DEL).

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

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    await self.client.delete(real_key)
delete_by_pattern(pattern) async

Delete all keys matching a glob pattern (SCAN + DEL).

Parameters:

Name Type Description Default
pattern str

Glob pattern, e.g. "session:*".

 required

Returns:

Type Description
int

Number of keys deleted.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
@catch_redis_errors
async def delete_by_pattern(self, pattern: str) -> int:
    """Delete all keys matching a glob pattern (SCAN + DEL).

    Args:
        pattern: Glob pattern, e.g. ``"session:*"``.

    Returns:
        Number of keys deleted.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    keys = [k async for k in self.client.scan_iter(match=pattern)]
    if not keys:
        return 0
    return int(await self.client.delete(*keys))
expire(key, ttl, **kwargs) async

Set a TTL (expiry) on a key in seconds (EXPIRE).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
ttl int

Time-to-live in seconds.

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Returns:

Type Description
bool

True if the TTL was set, False 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/string.py 
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
@catch_redis_errors
async def expire(self, key: "str | BaseRedisKey", ttl: int, **kwargs: Any) -> bool:
    """Set a TTL (expiry) on a key in seconds (EXPIRE).

    Args:
        key: Redis key or a ``BaseRedisKey`` instance.
        ttl: Time-to-live in seconds.
        **kwargs: Extra parameters forwarded to ``resolve_key``.

    Returns:
        ``True`` if the TTL was set, ``False`` if the key does not exist.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return bool(await self.client.expire(real_key, ttl))
ttl(key, **kwargs) async

Return the remaining TTL of a key in seconds (TTL).

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

Remaining TTL in seconds. -1 if no TTL is set, -2 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/string.py 
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
@catch_redis_errors
async def ttl(self, key: "str | BaseRedisKey", **kwargs: Any) -> int:
    """Return the remaining TTL of a key in seconds (TTL).

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

    Returns:
        Remaining TTL in seconds. ``-1`` if no TTL is set, ``-2`` 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.ttl(real_key))
exists(key, **kwargs) async

Check whether a key exists (EXISTS).

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
bool

True if the key exists, False otherwise.

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
@catch_redis_errors
async def exists(self, key: "str | BaseRedisKey", **kwargs: Any) -> bool:
    """Check whether a key exists (EXISTS).

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

    Returns:
        ``True`` if the key exists, ``False`` otherwise.

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    return bool(await self.client.exists(real_key))
rename(key, new_key, **kwargs) async

Rename a key (RENAME).

Parameters:

Name Type Description Default
key str | BaseRedisKey

Redis key or a BaseRedisKey instance.

 required
new_key str

Target key name.

 required
**kwargs Any

Extra parameters forwarded to resolve_key.

 {}

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
@catch_redis_errors
async def rename(self, key: "str | BaseRedisKey", new_key: str, **kwargs: Any) -> None:
    """Rename a key (RENAME).

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

    Raises:
        RedisConnectionError: Redis connection failure.
        RedisServiceError: Redis operation failure.
    """
    real_key = resolve_key(key, **kwargs)
    await self.client.rename(real_key, new_key)
key_type(key, **kwargs) async

Return the data type stored at a key (TYPE).

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
str

One of: "string", "list", "set", "zset", "hash", "stream".

Raises:

Type Description
RedisConnectionError

Redis connection failure.
RedisServiceError

Redis operation failure.
Source code in src/codex_platform/redis_service/operations/string.py 
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
@catch_redis_errors
async def key_type(self, key: "str | BaseRedisKey", **kwargs: Any) -> str:
    """Return the data type stored at a key (TYPE).

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

    Returns:
        One of: ``"string"``, ``"list"``, ``"set"``, ``"zset"``, ``"hash"``, ``"stream"``.

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

Functions