redis-lua-py 0.4.0__tar.gz → 0.5.0__tar.gz

redis_lua_py-0.5.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.5.0"
+}

{redis_lua_py-0.4.0 → redis_lua_py-0.5.0}/CHANGELOG.md

@@ -7,6 +7,16 @@ are written by [release-please](https://github.com/googleapis/release-please)
 from the conventional commit subjects on `main`; see
 [CONTRIBUTING.md](CONTRIBUTING.md) for how a release is cut.
 
+## [0.5.0](https://github.com/IgnaceMaes/redis-lua-py/compare/v0.4.0...v0.5.0) (2026-09-12)
+
+
+### Added
+
+* compile continue, try/except/else/finally, raise and assert ([#11](https://github.com/IgnaceMaes/redis-lua-py/issues/11)) ([aeca575](https://github.com/IgnaceMaes/redis-lua-py/commit/aeca5757fffe42e88b49b18fa4d3fe91897fad2e))
+* compile membership, slicing, string methods and formatting, and key variables ([#13](https://github.com/IgnaceMaes/redis-lua-py/issues/13)) ([4880c81](https://github.com/IgnaceMaes/redis-lua-py/commit/4880c8156d849755259dea9a8c29cf69392ecd7e))
+* compile redis functions libraries, and script flags ([#15](https://github.com/IgnaceMaes/redis-lua-py/issues/15)) ([5980f03](https://github.com/IgnaceMaes/redis-lua-py/commit/5980f0317acbe9a7a96ffaff029f2d76143b7e32))
+* generate lua ahead of time for code that ships without redis-lua-py ([#14](https://github.com/IgnaceMaes/redis-lua-py/issues/14)) ([83d6b9d](https://github.com/IgnaceMaes/redis-lua-py/commit/83d6b9da0b540cefc0be9ec51fbead54c4d0fade))
+
 ## [0.4.0](https://github.com/IgnaceMaes/redis-lua-py/compare/v0.3.0...v0.4.0) (2026-09-12)
 
 

{redis_lua_py-0.4.0 → redis_lua_py-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: redis-lua-py
-Version: 0.4.0
+Version: 0.5.0
 Summary: Write Redis Lua scripts as real Python functions, not strings.
 Project-URL: Homepage, https://ignacemaes.com/redis-lua-py/
 Project-URL: Documentation, https://ignacemaes.com/redis-lua-py/
@@ -144,6 +144,14 @@ script cache is cold once per script rather than once per environment.
   the same script object, and
   **[`bind`](https://ignacemaes.com/redis-lua-py/guide/binding-a-client/)** when
   passing the client every time gets repetitive.
+- **[Build-time generation](https://ignacemaes.com/redis-lua-py/guide/build-time/)**
+  for libraries — `python -m redis_lua_py generate` writes the Lua to a module
+  of plain strings, so your users never depend on this package, and `--check`
+  keeps it current in CI.
+- **[Redis Functions](https://ignacemaes.com/redis-lua-py/guide/redis-functions/)** —
+  the same Python compiles into a function library, loaded with `FUNCTION LOAD`
+  on first use and called with `FCALL`, and scripts take Redis 7 flags such as
+  `no-writes`.
 - **[The gaps between Lua and Python](https://ignacemaes.com/redis-lua-py/reference/lua-vs-python/)**
   are closed or refused — truthiness, 1-based indexing, `false` versus `nil`,
   block scope, and the nil that truncates a returned table.

{redis_lua_py-0.4.0 → redis_lua_py-0.5.0}/README.md

@@ -118,6 +118,14 @@ script cache is cold once per script rather than once per environment.
   the same script object, and
   **[`bind`](https://ignacemaes.com/redis-lua-py/guide/binding-a-client/)** when
   passing the client every time gets repetitive.
+- **[Build-time generation](https://ignacemaes.com/redis-lua-py/guide/build-time/)**
+  for libraries — `python -m redis_lua_py generate` writes the Lua to a module
+  of plain strings, so your users never depend on this package, and `--check`
+  keeps it current in CI.
+- **[Redis Functions](https://ignacemaes.com/redis-lua-py/guide/redis-functions/)** —
+  the same Python compiles into a function library, loaded with `FUNCTION LOAD`
+  on first use and called with `FCALL`, and scripts take Redis 7 flags such as
+  `no-writes`.
 - **[The gaps between Lua and Python](https://ignacemaes.com/redis-lua-py/reference/lua-vs-python/)**
   are closed or refused — truthiness, 1-based indexing, `false` versus `nil`,
   block scope, and the nil that truncates a returned table.

redis_lua_py-0.5.0/docs/guide/build-time.md

@@ -0,0 +1,152 @@
+# Shipping without the dependency
+
+Calling a script needs redis-lua-py at runtime: it compiles the body when the
+module is imported, and resolves keys and arguments on every call. In an
+application that is a dependency you chose. In a library it is a dependency
+every one of your users inherits, along with the import-time compile, for Lua
+that never changes between your releases.
+
+So a library can compile ahead of time instead. You write the scripts with
+`@script`, as anywhere else, and generate plain Lua from them while you
+develop. What you ship is that Lua: no import of this package, no compile
+step, nothing added to your dependencies.
+
+## Generate a module of strings
+
+Keep the scripts outside the package you ship, and redis-lua-py in your
+development dependencies:
+
+```bash
+uv add --dev redis-lua-py
+```
+
+```
+myproj/
+├── pyproject.toml
+├── redis_scripts/
+│   └── limits.py      # the @script functions; never shipped
+└── src/myproj/
+    ├── _lua.py        # generated, checked in, shipped
+    └── limits.py      # the code that runs them
+```
+
+Then, from the project root:
+
+```bash
+python -m redis_lua_py generate redis_scripts.limits --out src/myproj/_lua.py
+```
+
+The output imports nothing. Each script is a string constant, named after the
+function in capitals, with a comment recording the order its keys and
+arguments go in:
+
+```python
+"""Redis Lua scripts compiled by redis-lua-py from redis_scripts.limits. Do not edit.
+
+Regenerate with:
+
+    python -m redis_lua_py generate redis_scripts.limits --out src/myproj/_lua.py
+"""
+
+__all__ = [
+    "RATE_LIMIT",
+]
+
+# rate_limit -- KEYS: key; ARGV: limit, ttl
+RATE_LIMIT = """\
+-- rate_limit
+-- Generated by redis-lua-py from redis_scripts/limits.py:6. Do not edit.
+local key = KEYS[1]
+local limit = tonumber(ARGV[1])
+local ttl = tonumber(ARGV[2])
+local current = redis.call('INCR', key)
+if current == 1 then
+  redis.call('EXPIRE', key, ttl)
+end
+if current > limit then
+  return -1
+end
+return limit - current
+"""
+```
+
+Your library runs it the way it would run any Lua, through redis-py:
+
+```python
+from redis import Redis
+
+from ._lua import RATE_LIMIT
+
+
+class Limiter:
+    def __init__(self, client: Redis) -> None:
+        self._rate_limit = client.register_script(RATE_LIMIT)
+
+    def hit(self, key: str, limit: int, ttl: int) -> int:
+        return self._rate_limit(keys=[key], args=[limit, ttl])
+```
+
+Every path in the file is relative to the project root, so it comes out
+byte-for-byte the same on every machine, and regenerating it without a change
+to the scripts leaves it untouched.
+
+## Or one `.lua` file per script
+
+Pass a directory instead of a `.py` path:
+
+```bash
+python -m redis_lua_py generate redis_scripts.limits --out src/myproj/lua/
+```
+
+That writes `rate_limit.lua` and a file for every other script, for a library
+that already loads its Lua from files. When a script is renamed or removed, its
+old file is deleted. Only files carrying the generated header are ever
+deleted, so hand-written Lua in the same directory is safe. The flip side is
+that a script compiled with `header=False` leaves its old file behind when it
+is renamed.
+
+## Keep it current
+
+Checking generated code in only works if something notices when it goes stale.
+`--check` writes nothing, and exits 1 with a diff if the output no longer
+matches the scripts. Run it in CI:
+
+```yaml
+- run: uv run python -m redis_lua_py generate redis_scripts.limits --out src/myproj/_lua.py --check
+```
+
+Or as a test, which fails with the same diff:
+
+```python
+from redis_lua_py import codegen
+
+
+def test_generated_lua_is_current():
+    codegen.check("redis_scripts.limits", "src/myproj/_lua.py")
+```
+
+A test imports `redis_scripts.limits` like any other module, so the project
+root has to be on the path. With pytest, set `pythonpath = ["."]` under
+`[tool.pytest.ini_options]`.
+
+## What you give up
+
+The generated Lua is identical to what a `@script` call would send, so the
+behaviour inside Redis is the same. What stays behind is the caller's side:
+
+- **Argument checking.** A call through `CompiledScript` refuses a missing,
+  misspelled or duplicated argument, and a value such as `None` that has no
+  Redis representation. With a plain string, you pass `keys` and `args` in the
+  order the comment records, and nothing checks them.
+- **Booleans.** A `CompiledScript` sends `True` as `1`. redis-py refuses a
+  `bool` outright, so convert it yourself.
+- **Cluster pipelines.** A `CompiledScript` switches to `EVAL` on a redis-py
+  cluster pipeline, which refuses `EVALSHA`. A registered string does not.
+
+Keep writing tests that call the scripts through `@script` against
+[fakeredis](testing.md#run-the-behaviour-without-a-server) as well: those run
+the same Lua, with the checks still in place.
+
+The script module itself is ordinary Python, so point your type checker and
+linter at it along with the rest of the project. Lines in the generated file
+are as long as the Lua's, so leave that one file out of any line-length rule.

redis_lua_py-0.5.0/docs/guide/redis-functions.md

@@ -0,0 +1,139 @@
+# Redis Functions
+
+A script is sent with `EVALSHA`, and lives in a cache the server is free to
+drop. Since Redis 7 there is an alternative: a **function library**. It is
+loaded once with `FUNCTION LOAD`, persists and replicates with the data, and
+each function in it is called by name with `FCALL`.
+
+The same Python compiles to either. A body follows exactly the rules of a
+script's.
+
+```python
+from redis_lua_py import Key, Library, redis
+
+limits = Library("limits")
+
+
+@limits.function
+def hit(key: Key, ttl: int) -> int:
+    current = redis.incr(key)
+    if current == 1:
+        redis.expire(key, ttl)
+    return current
+
+
+@limits.function(flags=["no-writes"])
+def peek(key: Key) -> int:
+    return int(redis.get(key) or 0)
+```
+
+```python
+hit(client, key="user:42", ttl=60)  # FCALL hit 1 user:42 60
+peek(client, key="user:42")  # FCALL_RO peek 1 user:42
+```
+
+A function is called like a script: pass a sync client and you get a value,
+an async one and you get an awaitable, and [`bind`](binding-a-client.md)
+works the same way.
+
+## Loading
+
+There is nothing to do up front. When a call finds that the server does not
+have the library, it loads it with `FUNCTION LOAD REPLACE` and tries again.
+
+To load it explicitly, at deploy time for instance:
+
+```python
+limits.load(client)
+```
+
+!!! warning "Load before a pipeline"
+
+    A call queued in a pipeline cannot load the library halfway through
+    `execute()`. Call `load()` before queueing calls to a library the server
+    may not have yet.
+
+On Redis Cluster, redis-py sends `FUNCTION LOAD` to every primary, and routes
+`FCALL` on the function's keys, as it does a script.
+
+## What the library looks like
+
+`limits.lua` is the whole library, exactly as `FUNCTION LOAD` receives it:
+
+```lua
+#!lua name=limits
+-- Generated by redis-lua-py. Do not edit.
+-- Python truthiness: 0, '', empty tables and nil are all false.
+local function __truthy(v)
+  if v == nil or v == false then return false end
+  if v == 0 or v == '' then return false end
+  if type(v) == 'table' and next(v) == nil then return false end
+  return true
+end
+-- Python's `a or b`: a when it is truthy by Python's rules, otherwise b.
+local function __or(a, b)
+  if __truthy(a) then return a end
+  return b
+end
+-- hit, from limits.py:6
+redis.register_function{
+  function_name = 'hit',
+  callback = function(KEYS, ARGV)
+    local key = KEYS[1]
+    local ttl = tonumber(ARGV[1])
+    local current = redis.call('INCR', key)
+    if current == 1 then
+      redis.call('EXPIRE', key, ttl)
+    end
+    return current
+  end,
+}
+-- peek, from limits.py:14
+redis.register_function{
+  function_name = 'peek',
+  callback = function(KEYS, ARGV)
+    local key = KEYS[1]
+    return tonumber(__or(redis.call('GET', key), 0))
+  end,
+  flags = {'no-writes'},
+}
+```
+
+A helper any function needs is emitted once, at the top, where every callback
+can see it. The callback names its parameters `KEYS` and `ARGV`, so a function
+body compiles to exactly what the same body would as a script.
+
+Library and function names take letters, digits and underscores, which is all
+Redis accepts. Function names are global on the server, so two libraries
+cannot both define a `hit`.
+
+## Flags
+
+`flags` takes the flags Redis defines: `no-writes`, `allow-oom`,
+`allow-stale`, `no-cluster` and `allow-cross-slot-keys`. A `no-writes`
+function is called with `FCALL_RO`, which a replica accepts.
+
+Scripts take the same flags. Redis 7 reads them from a `#!lua` line at the very
+top of the script, which is where they go:
+
+```python
+@script(flags=["no-writes"])
+def read(key: Key) -> bytes:
+    return redis.get(key)
+```
+
+```lua
+#!lua flags=no-writes
+-- read
+-- Generated by redis-lua-py from app/cache.py:12. Do not edit.
+local key = KEYS[1]
+return redis.call('GET', key)
+```
+
+A misspelled flag is refused at import, like everything else.
+
+## Testing
+
+fakeredis has neither `FUNCTION` nor script flags. Test a library against a
+real server, or check its source as a golden file: `limits.lua` is the whole
+of it, as [a script's `.lua` is](testing.md#snapshot-the-lua).

redis_lua_py-0.5.0/docs/reference/api.md

@@ -0,0 +1,284 @@
+# API reference
+
+Everything in `redis_lua_py.__all__`. The package is small on purpose: one
+decorator, a library for Redis Functions, one annotation, two namespaces, and
+the errors.
+
+```python
+from redis_lua_py import Key, Library, call, cjson, redis, script
+from redis_lua_py import BoundScript, CompiledScript, LibraryFunction
+```
+
+## `script`
+
+```python
+def script(
+    func: Callable[..., R] | None = None,
+    /,
+    *,
+    name: str | None = None,
+    header: bool = True,
+    flags: Iterable[str] = (),
+) -> CompiledScript[R] | Callable[[Callable[..., R]], CompiledScript[R]]
+```
+
+Compile a function into a Redis Lua script. Usable bare or called:
+
+```python
+@script
+def touch(key: Key) -> int: ...
+
+
+@script(name="touch_v2", header=False)
+def touch(key: Key) -> int: ...
+```
+
+| Parameter | Meaning |
+| --- | --- |
+| `name` | overrides the name in the generated header and in errors |
+| `header` | `False` drops the provenance comment entirely, for anyone who wants the script body and nothing else |
+| `flags` | script flags for Redis 7, such as `no-writes`, written on a `#!lua` first line; see [Redis Functions](../guide/redis-functions.md#flags) |
+
+Parameters annotated [`Key`](#key) become `KEYS`, in declaration order; every
+other parameter becomes `ARGV`. See
+[Keys and arguments](../guide/keys-and-arguments.md).
+
+The return annotation describes what the *caller* gets back, and is carried
+through to the call: `-> int` makes the script a `CompiledScript[int]`. The
+compiler itself does not read it. See
+[What the caller gets](../guide/return-values.md).
+
+Define scripts at module level, where they compile once at import.
+
+Raises [`UnsupportedSyntax`](errors.md#unsupportedsyntax) at decoration time,
+pointing at the line at fault, if the body strays outside
+[the supported subset](supported-subset.md).
+
+## `Key`
+
+```python
+class Key(str)
+```
+
+Marks a parameter as a Redis key. A `str` subclass, so it is inert at runtime
+and the annotation is the whole of it.
+
+Getting this right matters: Redis Cluster routes a script by its declared keys,
+so a key passed as an argument will be invisible to the router.
+
+## `redis`
+
+The script namespace. `redis.incr(key)` becomes `redis.call('INCR', key)`;
+underscores split into subcommand tokens, so `redis.script_load(x)` becomes
+`redis.call('SCRIPT', 'LOAD', x)`.
+
+Names are checked at compile time against Redis' own command table;
+`redis.call(...)` itself is never checked and is the escape hatch. See
+[Calling Redis commands](../guide/calling-redis-commands.md).
+
+The compiler identifies the namespace by value rather than by the name it is
+imported under, so every alias works and nothing is reserved.
+
+## `call`
+
+An alias of [`redis`](#redis), for modules that would rather not rename
+anything.
+
+## `cjson`
+
+The JSON library Redis exposes to scripts: `cjson.encode` and `cjson.decode`,
+which pass through under their own names.
+
+## `CompiledScript`
+
+```python
+class CompiledScript(Generic[R])
+```
+
+What `@script` returns. Calling it runs `EVALSHA` and falls back to `EVAL` the
+first time, or whenever the server has dropped the script from its cache.
+
+```python
+script(client, /, *positional, **keyword) -> R              # sync client
+script(client, /, *positional, **keyword) -> Awaitable[R]   # async client
+```
+
+| Attribute | Type | What it is |
+| --- | --- | --- |
+| `name` | `str` | the script's name, in the header and in errors |
+| `lua` | `str` | the full Lua source, exactly as sent to Redis |
+| `params` | `tuple[str, ...]` | every parameter, in declaration order |
+| `keys` | `tuple[str, ...]` | the parameters annotated `Key` or `list[Key]`, in `KEYS` order |
+| `args` | `tuple[str, ...]` | everything else, in `ARGV` order |
+| `variadic_key` | `str \| None` | the `list[Key]` parameter, which fills the rest of `KEYS` |
+| `variadic_arg` | `str \| None` | the list parameter that fills the rest of `ARGV` |
+| `doc` | `str \| None` | the function's docstring |
+| `source` | `str` | where it was defined, repo-relative |
+
+### `bind`
+
+```python
+def bind(self, client) -> BoundScript[R]              # sync client
+def bind(self, client) -> BoundScript[Awaitable[R]]   # async client
+```
+
+Attach a client, so calls do not have to pass one. See
+[Binding a client](../guide/binding-a-client.md).
+
+## `BoundScript`
+
+```python
+class BoundScript(Generic[T])
+```
+
+A script with its client already attached, produced by
+[`bind`](#bind). The type parameter is what a call returns: the script's own
+return type for a sync client, an awaitable of it for an async one.
+
+```python
+bound(*positional, **keyword) -> T
+```
+
+Exposes `name`, `lua`, `params`, `keys`, `args` and `doc` from the script it
+wraps, and leaves that script usable against any other client. A
+[`LibraryFunction`](#libraryfunction) binds the same way.
+
+## `Library`
+
+```python
+class Library(name: str)
+```
+
+A Redis Functions library. `name` is the library name Redis registers, and
+takes letters, digits and underscores. See
+[Redis Functions](../guide/redis-functions.md).
+
+### `function`
+
+```python
+def function(
+    self,
+    func: Callable[..., R] | None = None,
+    /,
+    *,
+    name: str | None = None,
+    flags: Iterable[str] = (),
+) -> LibraryFunction[R] | Callable[[Callable[..., R]], LibraryFunction[R]]
+```
+
+Compile a function into the library, under the same rules as
+[`script`](#script). Usable bare or called.
+
+| Parameter | Meaning |
+| --- | --- |
+| `name` | the function name Redis registers, instead of the Python name |
+| `flags` | function flags, such as `no-writes`; a `no-writes` function is called with `FCALL_RO` |
+
+### `load`
+
+```python
+def load(self, client) -> Any
+```
+
+Load the library with `FUNCTION LOAD REPLACE`. Calling a function loads the
+library when the server lacks it, so this is only needed before queueing calls
+in a pipeline, or to load at deploy time.
+
+| Attribute | Type | What it is |
+| --- | --- | --- |
+| `name` | `str` | the library name |
+| `lua` | `str` | the library source, exactly as `FUNCTION LOAD` receives it |
+| `functions` | `tuple[LibraryFunction, ...]` | the functions, in the order they were added |
+
+## `LibraryFunction`
+
+```python
+class LibraryFunction(Generic[R])
+```
+
+What `Library.function` returns. Calling it sends `FCALL`, or `FCALL_RO` for a
+`no-writes` function, and loads the library first if the server does not have
+it.
+
+```python
+function(client, /, *positional, **keyword) -> R              # sync client
+function(client, /, *positional, **keyword) -> Awaitable[R]   # async client
+```
+
+It has the same `name`, `params`, `keys`, `args`, `variadic_key`,
+`variadic_arg`, `doc` and `source` as a [`CompiledScript`](#compiledscript),
+and a `bind` that works the same way, plus:
+
+| Attribute | Type | What it is |
+| --- | --- | --- |
+| `library` | `Library` | the library the function belongs to |
+| `lua` | `str` | the source of that whole library |
+| `flags` | `tuple[str, ...]` | the function's flags |
+| `read_only` | `bool` | whether it is flagged `no-writes`, and so called with `FCALL_RO` |
+
+## `codegen`
+
+```python
+from redis_lua_py import codegen
+```
+
+Compile scripts to Lua ahead of time, for code that should not depend on this
+package at runtime. See
+[Shipping without the dependency](../guide/build-time.md). Every function takes
+the module as a module object or a dotted name, and `out` as a path:
+
+- ending in `.py`, for one module holding every script as a string constant
+  and importing nothing
+- anything else, for a directory with one `.lua` file per script
+
+### `codegen.generate`
+
+```python
+def generate(module: ModuleType | str, out: str | Path) -> list[Path]
+```
+
+Write the scripts under `out`, and return the paths that changed. A file that
+already holds the right content is left alone. In a directory, a `.lua` file
+generated earlier for a script that no longer exists is removed.
+
+### `codegen.check`
+
+```python
+def check(module: ModuleType | str, out: str | Path) -> None
+```
+
+Raise [`StaleLuaError`](errors.md#staleluaerror), with a diff, unless `out`
+holds exactly what `generate` would write. Writes nothing.
+
+### `codegen.render`
+
+```python
+def render(module: ModuleType | str, out: str | Path) -> dict[Path, str]
+```
+
+The files `generate` would write, and what each would hold.
+
+### `codegen.collect`
+
+```python
+def collect(module: ModuleType | str) -> dict[str, CompiledScript[Any]]
+```
+
+Every script a module holds, by the name it is bound to, in definition order.
+A script bound to two names is collected once, under the first.
+
+### The command line
+
+```bash
+python -m redis_lua_py generate MODULE --out PATH [--check]
+```
+
+`generate` or, with `--check`, `check`, exiting 1 on an out-of-date output, a
+module that cannot be imported, or a script that does not compile. Installing
+the package also provides the same command as `redis-lua-py`.
+
+## Errors and warnings
+
+`CompileError`, `UnsupportedSyntax`, `ScriptArgumentError`, `StaleLuaError`,
+`RedisLuaError`, `RedisLuaWarning` and `NilTruncationWarning` have
+[their own page](errors.md).

{redis_lua_py-0.4.0 → redis_lua_py-0.5.0}/docs/reference/errors.md

@@ -4,11 +4,11 @@ Every error this package raises carries a caret under the line at fault, and a
 hint saying what to write instead.
 
 ```
-Lua 5.1 has no 'continue' statement
+chained comparisons are not supported
   File "/srv/app/limits.py", line 12
-    continue
-    ^
-  hint: Invert the condition and put the rest of the loop body inside the if.
+    if 0 < n < limit:
+       ^
+  hint: Split 'a < b < c' into 'a < b and b < c'.
 ```
 
 ## The hierarchy
@@ -17,7 +17,8 @@ Lua 5.1 has no 'continue' statement
 RedisLuaError
 ├── CompileError
 │   └── UnsupportedSyntax
-└── ScriptArgumentError
+├── ScriptArgumentError
+└── StaleLuaError
 
 RedisLuaWarning  (a UserWarning)
 └── NilTruncationWarning
@@ -53,6 +54,16 @@ is the only error in the list raised at call time rather than at import.
 rate_limit() has no parameter 'tll'; did you mean 'ttl'? (parameters: key, limit, ttl)
 ```
 
+## `StaleLuaError`
+
+Lua generated ahead of time no longer matches the scripts it came from. Raised
+by [`codegen.check`](api.md#codegencheck), with a diff and the command that
+regenerates the output. See
+[Shipping without the dependency](../guide/build-time.md#keep-it-current).
+
+It is also an `AssertionError`, so a test that calls `check` reports a failed
+assertion rather than an error in the test itself.
+
 ## `RedisLuaWarning`
 
 Base class for every warning this package raises. A `UserWarning`, so it is