redis-lua-py 0.11.0__tar.gz → 0.13.0__tar.gz

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/.github/workflows/ci.yml

@@ -32,6 +32,9 @@ jobs:
         with:
           enable-cache: true
       - run: uv sync --dev --python ${{ matrix.python-version }}
+      # Generated modules must still run on 3.9, which libraries vendoring
+      # them may support; tests/test_codegen.py runs one there when it can.
+      - run: uv python install 3.9
       - run: uv run pytest
 
   oldest:

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

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

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/CHANGELOG.md

@@ -7,6 +7,20 @@ 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.13.0](https://github.com/IgnaceMaes/redis-lua-py/compare/v0.12.0...v0.13.0) (2026-09-26)
+
+
+### Added
+
+* run generated modules on python 3.9 and keep forwarded numbers exact ([#34](https://github.com/IgnaceMaes/redis-lua-py/issues/34)) ([7178211](https://github.com/IgnaceMaes/redis-lua-py/commit/7178211f73e2503188240d62ebe8ab18278bdba2))
+
+## [0.12.0](https://github.com/IgnaceMaes/redis-lua-py/compare/v0.11.0...v0.12.0) (2026-09-25)
+
+
+### Added
+
+* str.isdigit, partition and annotated locals ([#32](https://github.com/IgnaceMaes/redis-lua-py/issues/32)) ([38e863c](https://github.com/IgnaceMaes/redis-lua-py/commit/38e863c96a89cd0c2a82d0bc59d73771f295d164))
+
 ## [0.11.0](https://github.com/IgnaceMaes/redis-lua-py/compare/v0.10.0...v0.11.0) (2026-09-25)
 
 

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: redis-lua-py
-Version: 0.11.0
+Version: 0.13.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/
@@ -103,7 +103,7 @@ Nothing is hidden. Every script exposes the Lua it produced:
 -- Generated by redis-lua-py from src/limits.py:6. Do not edit.
 local key = KEYS[1]
 local limit = tonumber(ARGV[1])
-local ttl = tonumber(ARGV[2])
+local ttl = ARGV[2]
 local current = redis.call('INCR', key)
 if current == 1 then
   redis.call('EXPIRE', key, ttl)

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/README.md

@@ -78,7 +78,7 @@ Nothing is hidden. Every script exposes the Lua it produced:
 -- Generated by redis-lua-py from src/limits.py:6. Do not edit.
 local key = KEYS[1]
 local limit = tonumber(ARGV[1])
-local ttl = tonumber(ARGV[2])
+local ttl = ARGV[2]
 local current = redis.call('INCR', key)
 if current == 1 then
   redis.call('EXPIRE', key, ttl)

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/docs/examples.md

@@ -42,8 +42,8 @@ def claim_jobs(queue: Key, processing: Key, now: int, limit: int) -> list[bytes]
 ```lua
 local queue = KEYS[1]
 local processing = KEYS[2]
-local now = tonumber(ARGV[1])
-local limit = tonumber(ARGV[2])
+local now = ARGV[1]
+local limit = ARGV[2]
 local ids = redis.call('ZRANGEBYSCORE', queue, 0, now, 'LIMIT', 0, limit)
 local claimed = {}
 for __i1 = 1, #ids do

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/docs/guide/build-time.md

@@ -12,6 +12,12 @@ develop. What you ship is that module: plain Python that needs only the
 standard library, with a typed function per script, called exactly the way
 the `@script` would be.
 
+redis-lua-py itself needs Python 3.10 to generate the module, but what it
+generates runs on Python 3.9 as well, so a library that still supports 3.9 can
+ship it. Its annotations may use `X | Y`, since `from __future__ import
+annotations` keeps them from being evaluated; everything that runs is 3.9
+code.
+
 ## Generate a module
 
 Keep the scripts outside the package you ship, and redis-lua-py in your
@@ -68,7 +74,7 @@ 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 ttl = ARGV[2]
 local current = redis.call('INCR', key)
 if current == 1 then
   redis.call('EXPIRE', key, ttl)

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/docs/guide/generated-lua.md

@@ -11,7 +11,7 @@ Nothing is hidden. Every script exposes the Lua it produced:
 -- Generated by redis-lua-py from src/limits.py:6. Do not edit.
 local key = KEYS[1]
 local limit = tonumber(ARGV[1])
-local ttl = tonumber(ARGV[2])
+local ttl = ARGV[2]
 local current = redis.call('INCR', key)
 if current == 1 then
   redis.call('EXPIRE', key, ttl)

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/docs/guide/keys-and-arguments.md

@@ -11,7 +11,7 @@ def rate_limit(key: Key, limit: int, ttl: int) -> int: ...
 ```lua
 local key = KEYS[1]
 local limit = tonumber(ARGV[1])
-local ttl = tonumber(ARGV[2])
+local ttl = ARGV[2]
 ```
 
 !!! warning "Annotate every key"
@@ -28,18 +28,27 @@ to it on the way in.
 | Annotation | In the script |
 | --- | --- |
 | `Key` | `KEYS[n]`, and what the cluster routes on |
-| `int`, `float` | wrapped in `tonumber`, so it is a number by the time your comparison runs |
+| `int`, `float` | wrapped in `tonumber`, so it is a number by the time your comparison runs; left as text when the body only hands it to Redis |
 | `str` | passed through as the string it already is |
 | `bool` | encoded as `"1"` or `"0"`, and a Lua boolean in the body |
 | `bytes`, `memoryview` | passed through untouched — see [Binary values](binary-values.md) |
 
+### Numbers only handed to Redis stay text
+
+In `rate_limit`, `ttl` is never compared or added to, only passed to `EXPIRE`,
+so it is left as the text it arrived as: `local ttl = ARGV[2]`. A Lua number is
+a double, which rounds an integer past 2^53, and which older servers write back
+with 17 digits, `0.1` as `0.10000000000000001`. Left as text, the value reaches
+Redis exactly as the caller passed it. The parameter is still an `int` to the
+caller, and it is converted as soon as the body does anything else with it.
+
 ### `float` carries a caveat
 
-Annotate `float` for arithmetic, not for a value you mean to write back
-unchanged. `tonumber` makes it a Lua number, and Lua renders a number back to
-text with `%.14g`, so a value with more significant digits than that does not
-come back as it went in. Annotate `str` and call `str()` at the call site when
-the value is only being carried.
+Annotate `float` for arithmetic, not for a value you mean to return unchanged.
+Unless the body only hands it to Redis, it is a Lua number, and Lua renders a
+number back to text with `%.14g`, so a value with more significant digits than that
+does not come back as it went in. Annotate `str` and call `str()` at the call
+site when the value is only being carried.
 
 ### `bool` is a boolean in the body
 
@@ -70,7 +79,7 @@ delete_tagged(client, tag="purged", keys=["a", "b", "c"], stamp=1700000000)
 
 ```lua
 local tag = KEYS[1]
-local stamp = tonumber(ARGV[1])
+local stamp = ARGV[1]
 local keys = {}
 for __i1 = 2, #KEYS do
   keys[#keys + 1] = KEYS[__i1]

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/docs/guide/redis-functions.md

@@ -82,7 +82,7 @@ redis.register_function{
   function_name = 'hit',
   callback = function(KEYS, ARGV)
     local key = KEYS[1]
-    local ttl = tonumber(ARGV[1])
+    local ttl = ARGV[1]
     local current = redis.call('INCR', key)
     if current == 1 then
       redis.call('EXPIRE', key, ttl)

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/docs/installation.md

@@ -12,7 +12,8 @@ pip install redis-lua-py
 
 ## Requirements
 
-- Python 3.10 or newer
+- Python 3.10 or newer. Modules [generated ahead of time](guide/build-time.md)
+  run on Python 3.9 too, without this package installed.
 - A Redis client: [redis-py](https://github.com/redis/redis-py) 4.2 or newer,
   or [coredis](https://github.com/alisaifee/coredis)
 
@@ -28,6 +29,31 @@ cluster, Sentinel, or an in-process [fakeredis](guide/testing.md).
 [coredis](https://github.com/alisaifee/coredis) clients work as well, and are
 tested against. See [Async](guide/async.md#coredis).
 
+### A client wrapper
+
+An application that wraps its client, to prefix keys per tenant for example,
+needs one method: `register_script(source)`. It returns a callable with the
+shape of redis-py's `Script`, `(keys=..., args=..., client=...)`, and a script
+runs through it:
+
+```python
+class PrefixedScript:
+    def __init__(self, owner: "PrefixedClient", script: Script) -> None:
+        self._owner, self._script = owner, script
+
+    def __call__(self, keys=(), args=(), client=None):
+        keys = [f"{self._owner.prefix}:{key}" for key in keys]
+        return self._script(keys=keys, args=args)
+
+
+class PrefixedClient:
+    def register_script(self, source: str) -> PrefixedScript:
+        return PrefixedScript(self, self._redis.register_script(source))
+```
+
+The wrapper's other methods never come into it, so an `eval` with its own
+signature is fine.
+
 ## For testing
 
 [fakeredis](https://github.com/cunla/fakeredis-py) embeds a real Lua

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/docs/quickstart.md

@@ -56,7 +56,7 @@ print(rate_limit.lua)
 -- Generated by redis-lua-py from limits.py:5. Do not edit.
 local key = KEYS[1]
 local limit = tonumber(ARGV[1])
-local ttl = tonumber(ARGV[2])
+local ttl = ARGV[2]
 local current = redis.call('INCR', key)
 if current == 1 then
   redis.call('EXPIRE', key, ttl)

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/docs/reference/lua-vs-python.md

@@ -55,9 +55,17 @@ that is not known, it looks at the subscript:
 A value's type is known from its annotation, a literal, the builtin, method or
 operator that produced it, a `range()` or `enumerate()` loop variable, or
 every assignment to the name agreeing. So after `counts = {}`, `counts[0]` is
-the key `0`. A table that comes from elsewhere -- a Redis reply,
+the key `0`. A value that comes from elsewhere -- a Redis reply,
 `cjson.decode`, a helper's parameter -- is not known, and an integer subscript
-on it is taken to be a position.
+on it is taken to be a table position. For a string, that reads `nil`, so
+annotate the local to say what it holds:
+
+```python
+text: str | None = redis.get(key)
+```
+
+An annotation on a local is a declaration, not a conversion: it decides how
+the value is indexed and added, and changes nothing at runtime.
 
 `items[-1]` compiles to `items[#items]`, which needs a name to count back from.
 Indexing a string gives a one-character string, as it does in Python, through

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/docs/reference/supported-subset.md

@@ -5,8 +5,9 @@ language with a faithful Lua meaning is accepted.
 
 **Supported:**
 
-- **Statements:** assignment, including unpacking (`a, b = b, a`);
-  augmented assignment; `if`/`elif`/`else`; `while`; `break`; `continue`;
+- **Statements:** assignment, including unpacking (`a, b = b, a`) and
+  annotated assignment (`text: str = redis.get(key)`), whose annotation tells
+  the compiler the value's type; augmented assignment; `if`/`elif`/`else`; `while`; `break`; `continue`;
   `return`.
 - **Errors:** `try` with one `except` (bare or `Exception`), `else` and
   `finally`; `raise SomeError("message")`, and a bare `raise` inside `except`;
@@ -23,8 +24,10 @@ language with a faithful Lua meaning is accepted.
   a name, and slices of lists and strings, with a step or without.
 - **Strings:** f-strings with format specs; `%` formatting; `+` and `*` on a
   string; `str.join`, `upper`, `lower`, `strip`, `lstrip`, `rstrip`,
-  `startswith`, `endswith`, `find`, `split` and `replace`; `encode()` and
-  `decode()` in UTF-8, which leave the bytes as they are.
+  `startswith`, `endswith`, `find`, `split`, `partition` and `replace`;
+  `isdigit`, `isalpha`, `isalnum` and `isspace`, which test ASCII as they do
+  on bytes; `encode()` and `decode()` in UTF-8, which leave the bytes as they
+  are.
 - **Builtins and methods:** `len()`, `int()`, which truncates toward zero,
   `float()`, `str()`, `min()`, `max()`, `abs()`, `ord()`, `chr()`, `.append()`,
   `.insert()`, `.pop()` and `dict.get()`; `isinstance()` against `str`,

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "redis-lua-py"
-version = "0.11.0"
+version = "0.13.0"
 description = "Write Redis Lua scripts as real Python functions, not strings."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -65,6 +65,10 @@ addopts = "-q"
 src = ["src", "tests"]
 line-length = 100
 target-version = "py310"
+# Generated modules must import on Python 3.9, which libraries that vendor them
+# may still support. Linting what they are built from as 3.9 code keeps a
+# 3.10-only construct out of them, and keeps ruff from asking for one.
+per-file-target-version = { "src/redis_lua_py/_portable.py" = "py39", "tests/generated_scripts.py" = "py39" }
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP", "B", "SIM", "RUF", "N", "C4", "PT"]

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/src/redis_lua_py/__init__.py

@@ -67,7 +67,7 @@ __all__ = [
     "script",
 ]
 
-__version__ = "0.11.0"  # x-release-please-version
+__version__ = "0.13.0"  # x-release-please-version
 
 
 @overload

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/src/redis_lua_py/_compile/analysis.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import ast
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 
 from .. import _lua as lua
 
@@ -134,6 +134,32 @@ def walk_scope(root: ast.AST) -> Iterator[ast.AST]:
             pending.extend(ast.iter_child_nodes(node))
 
 
+def only_forwarded(
+    root: ast.FunctionDef, name: str, is_command: Callable[[ast.Call], bool]
+) -> bool:
+    """True if every use of a name is a whole argument to a Redis command.
+
+    Such a value is text going back to Redis, whatever it is annotated as.
+    Anything else -- arithmetic, a comparison, an assignment to it, a use in
+    a nested function that may shadow it -- makes the answer False, as does
+    no use at all.
+    """
+    forwarded = {
+        id(arg)
+        for statement in root.body
+        for node in ast.walk(statement)
+        if isinstance(node, ast.Call) and is_command(node)
+        for arg in node.args
+    }
+    uses = [
+        node
+        for statement in root.body
+        for node in ast.walk(statement)
+        if isinstance(node, ast.Name) and node.id == name
+    ]
+    return bool(uses) and all(id(use) in forwarded for use in uses)
+
+
 def target_names(target: ast.expr) -> list[str]:
     """The names an assignment or loop target binds."""
     if isinstance(target, ast.Name):

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/src/redis_lua_py/_compile/base.py

@@ -26,7 +26,7 @@ from .. import _lua as lua
 from .._runtime import _Namespace
 from ..errors import UnsupportedSyntax
 from .analysis import UNBOUND, as_literal, binop_kind, dotted_name, value_kind
-from .tables import MATH_BY_OBJECT, RECEIVER_FALLBACK, REDIS_CONSTANTS
+from .tables import MATH_BY_OBJECT, RECEIVER_FALLBACK, REDIS_CONSTANTS, STRING_TESTS
 
 
 def is_redis_py(value: object) -> bool:
@@ -82,6 +82,9 @@ class CompilerBase(ABC):
         self.helpers: set[str] = set()
         # What a parameter or loop variable is known to be; see kind().
         self.kinds: dict[str, str] = {}
+        # Kinds that an annotation on a local declares. They are the author's
+        # word, so they win over what the assigned values suggest.
+        self.declared: dict[str, str] = {}
         # Every value assigned to each name, to work out what a local holds.
         self.values: dict[str, list[ast.expr]] = {}
         # Names bound in ways that say nothing about their type.
@@ -293,6 +296,13 @@ class CompilerBase(ABC):
                     return "str"
                 if name in {"int", "float", "tonumber", "len", "abs", "ord"}:
                     return "num"
+                if name in {"min", "max"} and node.args:
+                    # Python also takes the least of strings, or of one list,
+                    # so only numbers in make a number out.
+                    sides = {self.kind(arg) for arg in node.args}
+                    if sides <= {"num", "?"}:
+                        return "?" if sides == {"?"} else "num"
+                    return None
                 return "num" if self.math_attr(node.func) is not None else None
             case ast.Call(func=ast.Attribute(value=receiver, attr=attr)):
                 if self.math_attr(node.func) is not None:
@@ -303,9 +313,9 @@ class CompilerBase(ABC):
                     return "str"
                 if attr in {"encode", "decode"}:
                     return "str"
-                if attr in {"startswith", "endswith"}:
+                if attr in {"startswith", "endswith", *STRING_TESTS}:
                     return "bool"
-                if attr == "split":
+                if attr in {"split", "partition"}:
                     return "list"
                 return "num" if attr == "find" else None
             case ast.Attribute():
@@ -321,6 +331,8 @@ class CompilerBase(ABC):
     def name_kind(self, name: str) -> str | None:
         if name not in self.known:
             return value_kind(self.globalns.get(name, UNBOUND))
+        if name in self.declared:
+            return self.declared[name]
         if name in self._resolving:
             # A name whose value depends on itself, as in `n += 1`, is whatever
             # its other assignments make it.

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/src/redis_lua_py/_compile/calls.py

@@ -18,6 +18,7 @@ from .tables import (
     METHOD_HINT,
     REDIS_DIRECT,
     STRING_METHODS,
+    STRING_TESTS,
 )
 
 
@@ -26,7 +27,12 @@ class CallCompiler(ExpressionCompiler):
 
     def call(self, node: ast.Call) -> lua.Expr:
         if node.keywords:
-            self.fail(node, "keyword arguments are not supported in a script body")
+            self.fail(
+                node,
+                "keyword arguments are not supported in a script body",
+                hint="Pass a Redis command's options positionally, as its syntax "
+                "writes them: redis.set(key, value, 'EX', ttl), not ex=ttl.",
+            )
         if (
             isinstance(node.func, ast.Name)
             and node.func.id == "isinstance"
@@ -205,7 +211,8 @@ class CallCompiler(ExpressionCompiler):
             return target
         allowed = {"get": (1, 2), "split": (0, 1), "replace": (2,)}.get(attr)
         if allowed is None:
-            allowed = (0,) if attr in {"upper", "lower", "strip", "lstrip", "rstrip"} else (1,)
+            no_args = {"upper", "lower", "strip", "lstrip", "rstrip", *STRING_TESTS}
+            allowed = (0,) if attr in no_args else (1,)
         if len(args) not in allowed:
             if attr in {"strip", "lstrip", "rstrip"}:
                 self.fail(
@@ -218,6 +225,9 @@ class CallCompiler(ExpressionCompiler):
 
         if attr in {"upper", "lower"}:
             return lua.Call(lua.Global(f"string.{attr}"), (target,))
+        if attr in STRING_TESTS:
+            found = lua.Call(lua.Global("string.find"), (target, lua.Str(STRING_TESTS[attr])))
+            return lua.BinOp("~=", found, lua.Nil())
         if attr in {"strip", "lstrip", "rstrip"}:
             pattern = {"strip": "^%s*(.-)%s*$", "lstrip": "^%s*(.*)$", "rstrip": "^(.-)%s*$"}
             return lua.Call(lua.Global("string.match"), (target, lua.Str(pattern[attr])))

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/src/redis_lua_py/_compile/helpers.py

@@ -149,6 +149,15 @@ local function __find(s, sub)
   local i = string.find(s, sub, 1, true)
   if i == nil then return -1 end
   return i - 1
+end""",
+    "__partition": """\
+-- str.partition: before, separator and after the first plain match, or the
+-- whole string and two empty strings when there is none.
+local function __partition(s, sep)
+  if sep == '' then error('empty separator', 0) end
+  local i, j = string.find(s, sep, 1, true)
+  if i == nil then return {s, '', ''} end
+  return {string.sub(s, 1, i - 1), sep, string.sub(s, j + 1)}
 end""",
     "__split": """\
 -- str.split: on a plain separator, or on runs of whitespace without one.

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/src/redis_lua_py/_compile/scope.py

@@ -5,8 +5,9 @@ from __future__ import annotations
 import ast
 
 from .. import _lua as lua
-from .analysis import declares_exactly, target_names, walk_scope
+from .analysis import declares_exactly, only_forwarded, target_names, walk_scope
 from .base import CompilerBase
+from .tables import REDIS_DIRECT
 
 
 class ScopeCompiler(CompilerBase):
@@ -44,6 +45,10 @@ class ScopeCompiler(CompilerBase):
                 node.target, ast.Name
             ):
                 record(node.target.id, node)
+                if isinstance(node, ast.AnnAssign):
+                    declared = self._annotation_kind(self._without_none(node.annotation))
+                    if declared is not None:
+                        self.declared.setdefault(node.target.id, declared)
                 if isinstance(node, ast.AugAssign):
                     value: ast.expr = ast.BinOp(left=node.target, op=node.op, right=node.value)
                     self.values.setdefault(node.target.id, []).append(value)
@@ -118,7 +123,12 @@ class ScopeCompiler(CompilerBase):
                     self.variadic_key = name
                 else:
                     if self.variadic_arg is not None:
-                        self.fail(arg, "only one list parameter of arguments is supported")
+                        self.fail(
+                            arg,
+                            "only one list parameter of arguments is supported",
+                            hint="Interleave the values in one list and index it "
+                            "with a stride, as in values[3 * i + 1].",
+                        )
                     self.variadic_arg = name
                     if self._is_numeric(item):
                         self.numeric_args.add(name)
@@ -132,9 +142,12 @@ class ScopeCompiler(CompilerBase):
                 source = lua.Index(lua.Global("ARGV"), lua.Num(len(self.args)))
                 if self._is_numeric(arg.annotation):
                     # ARGV always arrives as strings; an int/float annotation
-                    # is the author asking for the conversion.
+                    # is the author asking for the conversion. Unless the value
+                    # only goes back to Redis: a Lua number is a double, so
+                    # converting would round an integer past 2^53 on the way.
                     self.numeric_args.add(name)
-                    source = lua.Call(lua.Global("tonumber"), (source,))
+                    if not only_forwarded(self.func, name, self._is_command):
+                        source = lua.Call(lua.Global("tonumber"), (source,))
                 elif self._annotation_name(arg.annotation) == "bool":
                     # A bool arrives as "1" or "0", and "0" is a string Lua and
                     # Python both count as true. Comparing makes it a boolean.
@@ -176,6 +189,16 @@ class ScopeCompiler(CompilerBase):
             return node.value.rsplit(".", 1)[-1].split("[", 1)[0]
         return None
 
+    def _is_command(self, node: ast.Call) -> bool:
+        """A call that sends its arguments to Redis as they are."""
+        func = node.func
+        return (
+            isinstance(func, ast.Attribute)
+            and isinstance(func.value, ast.Name)
+            and self.namespace_kind(func.value.id) == "redis"
+            and (func.attr not in REDIS_DIRECT or func.attr in {"call", "pcall"})
+        )
+
     def _is_key(self, node: ast.expr | None) -> bool:
         return self._annotation_name(node) == "Key"
 
@@ -192,6 +215,26 @@ class ScopeCompiler(CompilerBase):
             return "str"
         return None
 
+    @staticmethod
+    def _without_none(node: ast.expr | None) -> ast.expr | None:
+        """``X`` from ``X | None`` or ``Optional[X]``: None is no kind of its own."""
+        if isinstance(node, ast.Constant) and isinstance(node.value, str):
+            try:
+                node = ast.parse(node.value, mode="eval").body
+            except SyntaxError:
+                return None
+        if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
+            sides = [
+                side
+                for side in (node.left, node.right)
+                if not (isinstance(side, ast.Constant) and side.value is None)
+            ]
+            return sides[0] if len(sides) == 1 else None
+        name = ScopeCompiler._annotation_name(node)
+        if isinstance(node, ast.Subscript) and name == "Optional":
+            return node.slice
+        return node
+
     @staticmethod
     def _list_item(node: ast.expr | None) -> ast.expr | None:
         """The element annotation of a ``list[...]`` parameter, if it is one."""

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/src/redis_lua_py/_compile/statements.py

@@ -272,6 +272,7 @@ class Compiler(ControlFlowCompiler):
         # What the script's names hold is known inside the function too, except
         # for its parameters, which say nothing about their type.
         child.kinds = {k: v for k, v in self.kinds.items() if k not in params}
+        child.declared = {k: v for k, v in self.declared.items() if k not in params}
         child.values = {k: list(v) for k, v in self.values.items() if k not in params}
         child.opaque = self.opaque - set(params)
         child._temp = self._temp

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/src/redis_lua_py/_compile/tables.py

@@ -133,8 +133,8 @@ MATH_BY_OBJECT: dict[object, str] = {getattr(math, name): name for name in [*MAT
 
 METHOD_HINT = (
     "Available: the redis and cjson namespaces; list append, insert and pop; str join, "
-    "upper, lower, strip, lstrip, rstrip, startswith, endswith, find, split, replace, "
-    "encode and decode; and dict get."
+    "upper, lower, strip, lstrip, rstrip, startswith, endswith, find, split, partition, "
+    "replace, isdigit, isalpha, isalnum, isspace, encode and decode; and dict get."
 )
 
 
@@ -152,9 +152,24 @@ STRING_METHODS = frozenset(
         "endswith",
         "find",
         "split",
+        "partition",
         "replace",
+        "isdigit",
+        "isalpha",
+        "isalnum",
+        "isspace",
         "encode",
         "decode",
         "get",
     }
 )
+
+
+# The str.is* tests, as Lua patterns over the whole string. Lua's classes are
+# ASCII, which is exactly what the same methods on bytes test.
+STRING_TESTS: dict[str, str] = {
+    "isdigit": "^%d+$",
+    "isalpha": "^%a+$",
+    "isalnum": "^%w+$",
+    "isspace": "^%s+$",
+}

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/src/redis_lua_py/_portable.py

@@ -8,19 +8,24 @@ stay in step: there is only one copy of this code to get right.
 So this module imports only the standard library, and nothing from the
 package, and every name it defines starts with an underscore, to stay out of
 the way of the scripts in a generated module.
+
+It is also the one module here that runs on Python 3.9, because a library
+that vendors generated code may still support it. Annotations are never
+evaluated, so they can use ``X | Y``; anything evaluated cannot, which is why
+the aliases below spell ``Union`` and ``isinstance`` takes tuples.
 """
 
 from __future__ import annotations
 
 from collections.abc import Iterable
-from typing import Any, Protocol
+from typing import Any, Protocol, Union
 from weakref import WeakKeyDictionary
 
 #: What a generated signature accepts for a key, the same as redis-py does.
-_Key = str | bytes | memoryview
+_Key = Union[str, bytes, memoryview]
 
 #: What a generated signature accepts for an argument it has no better type for.
-_Arg = str | bytes | memoryview | int | float
+_Arg = Union[str, bytes, memoryview, int, float]
 
 
 class _SyncClient(Protocol):
@@ -61,9 +66,9 @@ def _encode(
     """
     if isinstance(value, bool):
         return "1" if value else "0"
-    if isinstance(value, str | bytes | memoryview):
+    if isinstance(value, (str, bytes, memoryview)):
         return value
-    if isinstance(value, int | float):
+    if isinstance(value, (int, float)):
         return repr(value) if isinstance(value, float) else str(value)
     raise error(
         f"argument {name!r} is a {type(value).__name__}, which has no Redis representation. "
@@ -77,7 +82,7 @@ def _items(name: str, value: object, error: type[Exception] = TypeError) -> list
     A string is iterable too, and splitting a key into characters is never
     what was meant, so it is refused rather than spread.
     """
-    if isinstance(value, str | bytes | memoryview) or not isinstance(value, Iterable):
+    if isinstance(value, (str, bytes, memoryview)) or not isinstance(value, Iterable):
         raise error(
             f"argument {name!r} takes a list, got a {type(value).__name__}. "
             "Wrap a single value in a list."

{redis_lua_py-0.11.0 → redis_lua_py-0.13.0}/src/redis_lua_py/codegen.py

@@ -62,7 +62,7 @@ _IMPORTS = """\
 from __future__ import annotations
 
 from collections.abc import Awaitable, Iterable
-from typing import Any, Protocol, overload
+from typing import Any, Protocol, Union, overload
 from weakref import WeakKeyDictionary
 """