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

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

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

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

@@ -7,6 +7,18 @@ 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.4.0](https://github.com/IgnaceMaes/redis-lua-py/compare/v0.3.0...v0.4.0) (2026-09-12)
+
+
+### Added
+
+* compile variable keys, splat calls, and/or values, helper functions and dict loops ([#10](https://github.com/IgnaceMaes/redis-lua-py/issues/10)) ([271f3f6](https://github.com/IgnaceMaes/redis-lua-py/commit/271f3f6be23d78246d91cde5de4fec05cee28832))
+
+
+### Fixed
+
+* stop silently mistranslating reassigned parameters, infinity, == None and set_repl ([#8](https://github.com/IgnaceMaes/redis-lua-py/issues/8)) ([930c382](https://github.com/IgnaceMaes/redis-lua-py/commit/930c38283f366fd9042c4cc20cdf7eeb34e2d8a5))
+
 ## [0.3.0](https://github.com/IgnaceMaes/redis-lua-py/compare/v0.2.1...v0.3.0) (2026-09-12)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: redis-lua-py
-Version: 0.3.0
+Version: 0.4.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/

{redis_lua_py-0.3.0 → redis_lua_py-0.4.0}/docs/guide/calling-redis-commands.md

@@ -5,8 +5,33 @@ split into subcommand tokens, so `redis.script_load(x)` compiles to
 `redis.call('SCRIPT', 'LOAD', x)`.
 
 `redis.pcall`, `redis.error_reply`, `redis.status_reply`, `redis.sha1hex`,
-`redis.log` and `cjson.encode` / `cjson.decode` pass through under their own
-names.
+`redis.log`, `redis.set_repl`, `redis.acl_check_cmd` and `cjson.encode` /
+`cjson.decode` pass through under their own names. So do the constants they
+take: `redis.LOG_WARNING` and the other log levels, `redis.REPL_ALL` and the
+other replication modes, and `redis.REDIS_VERSION`.
+
+## Splatting a list into a command
+
+A starred argument compiles to `unpack`, which is how a list becomes the
+arguments of a command:
+
+```python
+@script
+def push_all(queue: Key, jobs: list[str]) -> int:
+    return redis.rpush(queue, *jobs)
+```
+
+```lua
+return redis.call('RPUSH', queue, unpack(jobs))
+```
+
+It has to be the last argument, because Lua's `unpack` only expands there.
+
+!!! warning "unpack has a limit"
+
+    `unpack` puts every element on Lua's stack at once, and Redis' Lua refuses
+    past roughly eight thousand values with "too many results to unpack".
+    Split a list that can grow that large into chunks, one command per chunk.
 
 ## Names are checked, not just uppercased
 

{redis_lua_py-0.3.0 → redis_lua_py-0.4.0}/docs/guide/keys-and-arguments.md

@@ -46,6 +46,42 @@ the value is only being carried.
 `bool` encodes to `"1"` or `"0"`. Paired with an `int` annotation that deletes
 the `1 if flag else 0` from the call site: pass `True`, and the body gets `1`.
 
+## A variable number of keys or arguments
+
+Annotate a parameter `list[Key]` to take any number of keys, or `list[str]`,
+`list[int]` and so on to take any number of arguments. Its elements fill
+whatever is left of `KEYS` or `ARGV` after the fixed parameters, wherever the
+list is declared, and arrive in the body as a table:
+
+```python
+@script
+def delete_tagged(tag: Key, keys: list[Key], stamp: int) -> int:
+    redis.set(tag, stamp)
+    return redis.delete(*keys)
+
+
+delete_tagged(client, tag="purged", keys=["a", "b", "c"], stamp=1700000000)
+```
+
+```lua
+local tag = KEYS[1]
+local stamp = tonumber(ARGV[1])
+local keys = {}
+for __i1 = 2, #KEYS do
+  keys[#keys + 1] = KEYS[__i1]
+end
+redis.call('SET', tag, stamp)
+return redis.call('DEL', unpack(keys))
+```
+
+A script can take one list of keys and one list of arguments, since `KEYS`
+and `ARGV` only have positions to tell them apart. Every element of a
+`list[Key]` is a declared key, so Redis Cluster routes on all of them. An
+element annotation of `int` or `float` converts each element, as it would a
+single argument. Passing a string where a list is expected raises
+[`ScriptArgumentError`](../reference/errors.md#scriptargumenterror) rather
+than spreading it into characters.
+
 ## Positional or keyword
 
 Scripts accept either; keyword is clearer at the call site and is what the

{redis_lua_py-0.3.0 → redis_lua_py-0.4.0}/docs/reference/api.md

@@ -105,8 +105,10 @@ script(client, /, *positional, **keyword) -> Awaitable[R]   # async client
 | `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` |
-| `args` | `tuple[str, ...]` | everything else |
+| `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 |
 

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

@@ -4,12 +4,11 @@ Every error this package raises carries a caret under the line at fault, and a
 hint saying what to write instead.
 
 ```
-'and'/'or' are only supported in an if or while condition
+Lua 5.1 has no 'continue' statement
   File "/srv/app/limits.py", line 12
-    flag = a and b
-           ^
-  hint: In Python these return an operand, which does not survive the
-  difference in truthiness. Use an if statement instead.
+    continue
+    ^
+  hint: Invert the condition and put the rest of the loop body inside the if.
 ```
 
 ## The hierarchy

{redis_lua_py-0.3.0 → redis_lua_py-0.4.0}/docs/reference/lua-vs-python.md

@@ -14,7 +14,8 @@ A Redis command with nothing to return hands Lua `false`, not `nil`. This is
 the classic trap: a hand-written `== nil` never matches, so the branch silently
 never runs. `x is None` compiles to a helper accepting both, which also takes
 `x` as an argument — so `if redis.hget(k, f) is None:` does not run the command
-twice.
+twice. `x == None` and `x != None` compile to the same helper, since that is
+plainly what they mean.
 
 ## Indexing is closed
 
@@ -32,10 +33,40 @@ the top of the script, so it does not silently read back `nil`.
 
 Use an f-string, which compiles to Lua's `..`.
 
-## `and` / `or` work only in conditions
+## `and`, `or` and conditional expressions are closed
 
-In Python they return an operand, not a boolean, and that does not survive the
-truthiness difference. Use an `if`.
+In Python, `a or b` returns one of its operands, chosen by Python's
+truthiness. Lua's own `or` uses Lua's truthiness, where `0` and `''` are true,
+so the Lua idiom `tonumber(x) or 0` means something different there.
+
+A right side that is a name or a literal compiles to a small `__or` / `__and`
+helper. Anything else is wrapped in a function called on the spot, so that it
+only runs when Python would run it. `flag or redis.incr(k)` does not
+increment when `flag` is set.
+
+`a if c else b` compiles to `c and a or b` when `a` is a literal. Otherwise it
+becomes the same kind of function, because `c and a or b` is wrong whenever
+`a` can be false or nil.
+
+## Dicts iterate in no particular order
+
+`.items()`, `.keys()` and `.values()` compile to Lua's `pairs()`, which visits
+entries in no fixed order. Sort the result if the order reaches the caller.
+
+Iterating a dict directly with `for k in d` walks its array part, which a dict
+does not have, so the loop never runs. Say `.keys()`.
+
+## Redis replies are flat lists, not dicts
+
+To Lua, `HGETALL` returns `[field, value, field, value, ...]`, not a table
+keyed by field, so `.items()` on it does not mean what it would in redis-py.
+Walk it in pairs instead:
+
+```python
+fields = redis.hgetall(k)
+for i in range(0, len(fields), 2):
+    redis.hset(copy, fields[i], fields[i + 1])
+```
 
 ## There is no `continue`
 

redis_lua_py-0.4.0/docs/reference/supported-subset.md

@@ -0,0 +1,43 @@
+# The supported subset
+
+A script body is Python that Python never runs, so only the part of the
+language with a faithful Lua meaning is accepted.
+
+**Supported:**
+
+- **Statements:** assignment, including unpacking (`a, b = b, a`);
+  augmented assignment; `if`/`elif`/`else`; `while`; `break`; `return`.
+- **Loops:** `for ... in` over a table, `range()`, `enumerate()`, or a dict's
+  `.items()`, `.keys()` and `.values()`, binding a name or a tuple of names.
+- **Helper functions** defined with `def` at the top level of the body. They
+  can call each other and themselves.
+- **Expressions:** comparisons; arithmetic; `and`/`or`, and `a if c else b`,
+  both as values; f-strings; list and dict literals.
+- **Builtins and methods:** `len()`, `int()`, `float()`, `str()`, `min()`,
+  `max()`, `abs()`, `.append()`, `.insert()`, `.pop()` and `str.join()`.
+- **The `math` module:** `floor`, `ceil`, `sqrt`, `fabs`, `fmod`, `exp`,
+  `log`, `log10` and `pow`, imported either way.
+- **Calls:** into `redis` and `cjson`, with `*xs` allowed as the last argument.
+- **Parameters:** `list[Key]` and `list[...]`, for a variable number of keys
+  and arguments.
+- **Module-level constants.**
+
+Everything else raises
+[`UnsupportedSyntax`](errors.md#unsupportedsyntax) when the module is imported,
+with a caret under the line at fault:
+
+```
+Lua 5.1 has no 'continue' statement
+  File "/srv/app/limits.py", line 12
+    continue
+    ^
+  hint: Invert the condition and put the rest of the loop body inside the if.
+```
+
+Failing at import, loudly, is deliberate. A body that looks like Python but is
+never run by Python is exactly where a quiet mistranslation would cost the
+most.
+
+The gaps that a supported construct still carries — truthiness, 1-based
+indexing, block scope — are covered in
+[Where Lua differs from Python](lua-vs-python.md).

{redis_lua_py-0.3.0 → redis_lua_py-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "redis-lua-py"
-version = "0.3.0"
+version = "0.4.0"
 description = "Write Redis Lua scripts as real Python functions, not strings."
 readme = "README.md"
 requires-python = ">=3.10"

{redis_lua_py-0.3.0 → redis_lua_py-0.4.0}/src/redis_lua_py/__init__.py

@@ -62,7 +62,7 @@ __all__ = [
     "script",
 ]
 
-__version__ = "0.3.0"  # x-release-please-version
+__version__ = "0.4.0"  # x-release-please-version
 
 
 @overload