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

{redis_lua_py-0.2.1 → redis_lua_py-0.4.0}/.github/workflows/ci.yml

@@ -25,7 +25,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.11", "3.12", "3.13"]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/setup-uv@v5
@@ -34,6 +34,21 @@ jobs:
       - run: uv sync --dev --python ${{ matrix.python-version }}
       - run: uv run pytest
 
+  oldest:
+    name: Tests (oldest supported Python and redis-py)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+      - run: uv sync --dev --python 3.10
+      # The floor in pyproject.toml is only a claim until something runs on it.
+      # fakeredis declares redis>=4.3 but works on 4.2, the first release with
+      # redis.asyncio, so the pin goes in after the resolver is done.
+      - run: uv pip install --no-deps "redis==4.2.0" async-timeout deprecated
+      - run: uv run --no-sync pytest
+
   live:
     name: Tests against a real Redis
     runs-on: ubuntu-latest

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

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

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

@@ -7,6 +7,25 @@ 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)
+
+
+### Added
+
+* support python 3.10 and redis-py 4.2 ([#6](https://github.com/IgnaceMaes/redis-lua-py/issues/6)) ([6ce6249](https://github.com/IgnaceMaes/redis-lua-py/commit/6ce6249d219756a598e83f18f3bf44e8a58722eb))
+
 ## [0.2.1](https://github.com/IgnaceMaes/redis-lua-py/compare/v0.2.0...v0.2.1) (2026-09-12)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: redis-lua-py
-Version: 0.2.1
+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/
@@ -14,13 +14,14 @@ Keywords: eval,evalsha,lua,redis,scripting,transpiler
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Lua
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Database
 Classifier: Typing :: Typed
-Requires-Python: >=3.11
-Requires-Dist: redis>=5.0
+Requires-Python: >=3.10
+Requires-Dist: redis>=4.2
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -88,7 +89,7 @@ for the script namespace, so the two never collide.
 uv add redis-lua-py
 ```
 
-Python 3.11+, and redis-py 5.0+ as the only dependency.
+Python 3.10+, and redis-py 4.2+ as the only dependency.
 
 ## What it compiles to
 

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

@@ -63,7 +63,7 @@ for the script namespace, so the two never collide.
 uv add redis-lua-py
 ```
 
-Python 3.11+, and redis-py 5.0+ as the only dependency.
+Python 3.10+, and redis-py 4.2+ as the only dependency.
 
 ## What it compiles to
 

{redis_lua_py-0.2.1 → 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.2.1 → 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.2.1 → redis_lua_py-0.4.0}/docs/installation.md

@@ -12,8 +12,8 @@ pip install redis-lua-py
 
 ## Requirements
 
-- Python 3.11 or newer
-- [redis-py](https://github.com/redis/redis-py) 5.0 or newer — the only
+- Python 3.10 or newer
+- [redis-py](https://github.com/redis/redis-py) 4.2 or newer — the only
   dependency, and installed with the package
 
 Script caching, `EVALSHA` and the `NOSCRIPT` reload are handled by redis-py's

{redis_lua_py-0.2.1 → 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.2.1 → 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.2.1 → 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.2.1 → redis_lua_py-0.4.0}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "redis-lua-py"
-version = "0.2.1"
+version = "0.4.0"
 description = "Write Redis Lua scripts as real Python functions, not strings."
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.10"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [{ name = "Ignace Maes" }]
@@ -11,6 +11,7 @@ keywords = ["redis", "lua", "eval", "evalsha", "transpiler", "scripting"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -18,7 +19,7 @@ classifiers = [
     "Topic :: Database",
     "Typing :: Typed",
 ]
-dependencies = ["redis>=5.0"]
+dependencies = ["redis>=4.2"]
 
 [project.urls]
 Homepage = "https://ignacemaes.com/redis-lua-py/"
@@ -35,6 +36,8 @@ dev = [
     "ruff>=0.16",
     "mypy>=1.15",
     "zensical>=0.0.61",
+    # typing.assert_type, for tests/test_typing.py, arrived in Python 3.11.
+    "typing_extensions>=4.2; python_version < '3.11'",
 ]
 
 [build-system]
@@ -52,7 +55,7 @@ addopts = "-q"
 [tool.ruff]
 src = ["src", "tests"]
 line-length = 100
-target-version = "py311"
+target-version = "py310"
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP", "B", "SIM", "RUF", "N", "C4", "PT"]
@@ -68,7 +71,7 @@ select = ["E", "F", "I", "UP", "B", "SIM", "RUF", "N", "C4", "PT"]
 "tests/*.py" = ["B007", "F841", "SIM108"]
 
 [tool.mypy]
-python_version = "3.11"
+python_version = "3.10"
 strict = true
 # test_typing.py carries assert_type() claims about what a call returns, which
 # are only worth anything if mypy actually reads them.

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

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