redis-lua-py 0.10.0__tar.gz → 0.12.0__tar.gz

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

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

{redis_lua_py-0.10.0 → redis_lua_py-0.12.0}/CHANGELOG.md

@@ -7,6 +7,26 @@ 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.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)
+
+
+### Added
+
+* compile isinstance and cjson.null in script bodies ([373c4b7](https://github.com/IgnaceMaes/redis-lua-py/commit/373c4b79d58994e7a67ada0db9572496839af8da))
+
+
+### Fixed
+
+* rename locals that would shadow the Lua globals scripts rely on ([373c4b7](https://github.com/IgnaceMaes/redis-lua-py/commit/373c4b79d58994e7a67ada0db9572496839af8da))
+* type a client wrapper with getattr forwarding as sync, not async ([373c4b7](https://github.com/IgnaceMaes/redis-lua-py/commit/373c4b79d58994e7a67ada0db9572496839af8da))
+
 ## [0.10.0](https://github.com/IgnaceMaes/redis-lua-py/compare/v0.9.0...v0.10.0) (2026-09-14)
 
 

{redis_lua_py-0.10.0 → redis_lua_py-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: redis-lua-py
-Version: 0.10.0
+Version: 0.12.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.10.0 → redis_lua_py-0.12.0}/docs/guide/async.md

@@ -22,6 +22,11 @@ a = rate_limit(sync_client, key="u:1", limit=10, ttl=60)  # int
 b = rate_limit(async_client, key="u:1", limit=10, ttl=60)  # Awaitable[int]
 ```
 
+A client is typed as sync when it has `__enter__`, as every redis-py sync
+client does, and as async when it has `__aenter__`. The sync overload comes
+first, so a wrapper of your own that forwards attributes through `__getattr__`,
+which mypy takes to provide both, is typed as the sync client it wraps.
+
 Script caching, `EVALSHA`, and the `NOSCRIPT` reload are handled by redis-py's
 own script machinery, which this defers to rather than reimplementing.
 

{redis_lua_py-0.10.0 → redis_lua_py-0.12.0}/docs/guide/build-time.md

@@ -81,6 +81,8 @@ return limit - current
 _RATE_LIMIT_CLIENTS: WeakKeyDictionary[Any, Any] = WeakKeyDictionary()
 
 
+@overload
+def rate_limit(client: _SyncClient, /, key: _Key, limit: int, ttl: int) -> int: ...
 @overload
 def rate_limit(
     client: _AsyncClient,

{redis_lua_py-0.10.0 → redis_lua_py-0.12.0}/docs/installation.md

@@ -28,6 +28,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.10.0 → redis_lua_py-0.12.0}/docs/reference/api.md

@@ -92,6 +92,8 @@ anything.
 
 The JSON library Redis exposes to scripts: `cjson.encode` and `cjson.decode`,
 which pass through under their own names.
+`cjson.null` is JSON `null`, which `None` is not: a field set to `None` is
+dropped from an encoded object.
 
 ## `CompiledScript`
 

{redis_lua_py-0.10.0 → redis_lua_py-0.12.0}/docs/reference/lua-vs-python.md

@@ -19,6 +19,24 @@ never runs. `x is None` compiles to a helper accepting both, which also takes
 twice. `x == None` and `x != None` compile to the same helper, since that is
 plainly what they mean.
 
+`cjson.decode` gives JSON `null` as `cjson.null`, which is neither: compare
+with `== cjson.null`. Setting a field to `None` removes it, so write
+`cjson.null` where the encoded object should keep the field as `null`.
+
+## `isinstance` has Lua's types
+
+`isinstance(x, dict)` compiles to `type(x) == 'table'`, the usual guard on a
+decoded JSON value before reading its fields. Lua has fewer types than Python,
+so some tests answer for more than their name says:
+
+- `int` and `float` both test for a number, which may have a fraction;
+- `dict` and `list` both test for a table;
+- `str` and `bytes` both test for a string;
+- `bool` is not a number, so `isinstance(True, int)` is false.
+
+A tuple or a `|` union of types tests for any of them. A class of your own has
+no Lua counterpart, and is refused.
+
 ## Indexing is closed
 
 Lua tables are 1-based. `items[0]` compiles to `items[1]`. Write Python indices
@@ -37,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
@@ -53,6 +79,15 @@ Python scopes a name to the whole function; Lua's `local` scopes it to the
 enclosing block. A name assigned inside an `if` and read after it is hoisted to
 the top of the script, so it does not silently read back `nil`.
 
+## Names Lua already uses are closed
+
+The generated Lua calls globals such as `type`, `error`, `tostring` and
+`pairs`, and reads `KEYS` and `ARGV`. A local of the same name would shadow
+them for the rest of the script, so a parameter named `error` would break
+every `raise` after it. Such a name is renamed with a trailing underscore
+instead: `local error_ = ARGV[1]`. The keyword argument on the Python side
+keeps its name.
+
 ## Strings are closed
 
 Lua's `+` is only arithmetic. It will add `"1" + "2"` to `3`. So `+`

{redis_lua_py-0.10.0 → redis_lua_py-0.12.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,14 +24,18 @@ 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()`.
+  `.insert()`, `.pop()` and `dict.get()`; `isinstance()` against `str`,
+  `bytes`, `int`, `float`, `bool`, `dict` and `list`.
 - **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.
+- **Calls:** into `redis` and `cjson`, with `*xs` allowed as the last argument,
+  and `cjson.null` for a JSON null.
 - **Parameters:** `list[Key]` and `list[...]`, for a variable number of keys
   and arguments.
 - **Module-level constants.**

{redis_lua_py-0.10.0 → redis_lua_py-0.12.0}/pyproject.toml

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

{redis_lua_py-0.10.0 → redis_lua_py-0.12.0}/src/redis_lua_py/__init__.py

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

{redis_lua_py-0.10.0 → redis_lua_py-0.12.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.
@@ -150,7 +153,9 @@ class CompilerBase(ABC):
                 and parts[1] in REDIS_CONSTANTS
                 and self.namespace_kind(parts[0]) == "redis"
             ):
-                return lua.Index(lua.Name("redis"), lua.Str(parts[1]))
+                return lua.Index(lua.Global("redis"), lua.Str(parts[1]))
+            if parts[1:] == ("null",) and self.namespace_kind(parts[0]) == "cjson":
+                return lua.Index(lua.Global("cjson"), lua.Str("null"))
             root = self.globalns.get(parts[0], UNBOUND)
             # A namespace answers to every attribute with a call stub, and
             # redis-py has a clearer error of its own; neither is a constant.
@@ -285,6 +290,8 @@ class CompilerBase(ABC):
             case ast.Subscript(value=value):
                 return "str" if self.kind(value) == "str" else None
             case ast.Call(func=ast.Name(id=name)) if not self.is_callable(name):
+                if name == "isinstance":
+                    return "bool"
                 if name in {"str", "tostring", "chr"}:
                     return "str"
                 if name in {"int", "float", "tonumber", "len", "abs", "ord"}:
@@ -299,9 +306,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():
@@ -317,6 +324,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.10.0 → redis_lua_py-0.12.0}/src/redis_lua_py/_compile/calls.py

@@ -7,15 +7,18 @@ import difflib
 
 from .. import _lua as lua
 from .._commands import COMMANDS, SUBCOMMANDS
+from .analysis import is_cheap
 from .expressions import ExpressionCompiler
 from .tables import (
     BUILTIN_FUNCS,
     COMMAND_ALIASES,
     COMMAND_SPELLINGS,
+    ISINSTANCE_TYPES,
     MATH_FUNCS,
     METHOD_HINT,
     REDIS_DIRECT,
     STRING_METHODS,
+    STRING_TESTS,
 )
 
 
@@ -24,7 +27,19 @@ 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"
+            and not self.is_callable("isinstance")
+        ):
+            # Its second argument names types, which have no value in Lua.
+            return self.isinstance_call(node)
         args = self.call_args(node)
 
         math_attr = self.math_attr(node.func)
@@ -45,11 +60,11 @@ class CallCompiler(ExpressionCompiler):
             case ast.Name(id="int"):
                 return self.int_call(node, args)
             case ast.Name(id=name) if name in BUILTIN_FUNCS:
-                return lua.Call(lua.Name(BUILTIN_FUNCS[name]), args)
+                return lua.Call(lua.Global(BUILTIN_FUNCS[name]), args)
             case ast.Attribute(value=receiver, attr="join") if not self.is_namespace(receiver):
                 if len(args) != 1:
                     self.fail(node, "join() takes exactly one argument")
-                return lua.Call(lua.Name("table.concat"), (args[0], self.expr(receiver)))
+                return lua.Call(lua.Global("table.concat"), (args[0], self.expr(receiver)))
             case ast.Attribute(value=ast.Name(id=recv) as receiver, attr="pop" | "insert") if (
                 recv in self.known
             ):
@@ -84,7 +99,7 @@ class CallCompiler(ExpressionCompiler):
                         hint="Lua's unpack() only expands in the last position. Append the "
                         "trailing values to the list first, then splat it.",
                     )
-                args.append(lua.Call(lua.Name("unpack"), (self.expr(arg.value),)))
+                args.append(lua.Call(lua.Global("unpack"), (self.expr(arg.value),)))
             else:
                 args.append(self.expr(arg))
         return tuple(args)
@@ -100,6 +115,42 @@ class CallCompiler(ExpressionCompiler):
         self.helpers.add("__int")
         return lua.Call(lua.Name("__int"), args)
 
+    def isinstance_call(self, node: ast.Call) -> lua.Expr:
+        """``isinstance(x, T)``: a test of Lua's ``type()``, which has fewer types."""
+        if len(node.args) != 2 or isinstance(node.args[0], ast.Starred):
+            self.fail(node, "isinstance() takes exactly two arguments")
+        match node.args[1]:
+            case ast.Tuple(elts=elts):
+                classes = elts
+            case ast.BinOp(op=ast.BitOr()) as union:
+                classes = union_members(union)
+            case single:
+                classes = [single]
+        lua_types: list[str] = []
+        for cls in classes:
+            if not isinstance(cls, ast.Name) or cls.id not in ISINSTANCE_TYPES:
+                self.fail(
+                    cls,
+                    "isinstance() only tests for a builtin type",
+                    hint=f"Available: {', '.join(ISINSTANCE_TYPES)}. Lua knows no classes.",
+                )
+            if ISINSTANCE_TYPES[cls.id] not in lua_types:
+                lua_types.append(ISINSTANCE_TYPES[cls.id])
+        subject = self.expr(node.args[0])
+        if len(lua_types) > 1 and not is_cheap(node.args[0]):
+            self.fail(
+                node.args[0],
+                "isinstance() against several types needs a name to test",
+                hint="Assign the value to a name first, so that it is evaluated once.",
+            )
+        tests = [
+            lua.BinOp("==", lua.Call(lua.Global("type"), (subject,)), lua.Str(t)) for t in lua_types
+        ]
+        test = tests[0]
+        for other in tests[1:]:
+            test = lua.BinOp("or", test, other)
+        return test
+
     def math_call(self, node: ast.Call, attr: str, args: tuple[lua.Expr, ...]) -> lua.Expr:
         if attr == "log":
             if len(args) != 1:
@@ -108,7 +159,7 @@ class CallCompiler(ExpressionCompiler):
                     "math.log() with a base is not supported",
                     hint="Lua 5.1's math.log takes no base; divide by math.log(base) instead.",
                 )
-            return lua.Call(lua.Name("math.log"), args)
+            return lua.Call(lua.Global("math.log"), args)
         target = MATH_FUNCS.get(attr)
         if target is None:
             self.fail(
@@ -116,7 +167,7 @@ class CallCompiler(ExpressionCompiler):
                 f"math.{attr}() has no Lua counterpart",
                 hint=f"Available: {listing(sorted([*MATH_FUNCS, 'log']), limit=10)}.",
             )
-        return lua.Call(lua.Name(target), args)
+        return lua.Call(lua.Global(target), args)
 
     def list_method(self, node: ast.Call, receiver: ast.Name) -> lua.Expr:
         """``xs.pop()`` and ``xs.insert(i, x)``, with the index shifted to 1-based."""
@@ -130,16 +181,16 @@ class CallCompiler(ExpressionCompiler):
         target = self.expr(receiver)
         if node.func.attr == "pop":
             if not node.args:
-                return lua.Call(lua.Name("table.remove"), (target,))
+                return lua.Call(lua.Global("table.remove"), (target,))
             if len(node.args) == 1:
                 return lua.Call(
-                    lua.Name("table.remove"), (target, self.index(node.args[0], "list"))
+                    lua.Global("table.remove"), (target, self.index(node.args[0], "list"))
                 )
             self.fail(node, "pop() takes at most one argument")
         if len(node.args) != 2:
             self.fail(node, "insert() takes exactly two arguments")
         return lua.Call(
-            lua.Name("table.insert"),
+            lua.Global("table.insert"),
             (target, self.index(node.args[0], "list"), self.expr(node.args[1])),
         )
 
@@ -160,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(
@@ -172,10 +224,13 @@ class CallCompiler(ExpressionCompiler):
             self.fail(node, f"{attr}() takes {expected} argument(s) inside a script")
 
         if attr in {"upper", "lower"}:
-            return lua.Call(lua.Name(f"string.{attr}"), (target,))
+            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.Name("string.match"), (target, lua.Str(pattern[attr])))
+            return lua.Call(lua.Global("string.match"), (target, lua.Str(pattern[attr])))
         if attr == "get":
             self.helpers.add("__get")
             default = args[1] if len(args) == 2 else lua.Nil()
@@ -191,7 +246,7 @@ class CallCompiler(ExpressionCompiler):
         if kind == "cjson":
             if attr not in {"encode", "decode"}:
                 self.fail(node, f"cjson has no {attr!r} function")
-            return lua.Call(lua.Index(lua.Name("cjson"), lua.Str(attr)), args)
+            return lua.Call(lua.Index(lua.Global("cjson"), lua.Str(attr)), args)
         if kind == "redis":
             return self.redis_call(node, attr, args)
         self.fail(
@@ -202,11 +257,11 @@ class CallCompiler(ExpressionCompiler):
 
     def redis_call(self, node: ast.Call, attr: str, args: tuple[lua.Expr, ...]) -> lua.Expr:
         if attr in REDIS_DIRECT:
-            return lua.Call(lua.Index(lua.Name("redis"), lua.Str(attr)), args)
+            return lua.Call(lua.Index(lua.Global("redis"), lua.Str(attr)), args)
         if attr.startswith("_"):
             self.fail(node, f"redis.{attr} is not a Redis command")
         tokens = tuple(lua.Str(token) for token in self.command_tokens(node, attr))
-        return lua.Call(lua.Index(lua.Name("redis"), lua.Str("call")), tokens + args)
+        return lua.Call(lua.Index(lua.Global("redis"), lua.Str("call")), tokens + args)
 
     def command_tokens(self, node: ast.Call, attr: str) -> tuple[str, ...]:
         """Turn an attribute name into the command tokens Redis expects.
@@ -296,3 +351,10 @@ def did_you_mean(attr: str, options: set[str], prefix: str = "") -> str | None:
     if not matches:
         return None
     return f"Did you mean redis.{prefix}{matches[0]}()?"
+
+
+def union_members(node: ast.expr) -> list[ast.expr]:
+    """The classes of an ``A | B | C`` union, left to right."""
+    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
+        return [*union_members(node.left), *union_members(node.right)]
+    return [node]

{redis_lua_py-0.10.0 → redis_lua_py-0.12.0}/src/redis_lua_py/_compile/control.py

@@ -75,8 +75,8 @@ class ControlFlowCompiler(CallCompiler):
         the caller, or an except block, sees exactly what was raised.
         """
         if not isinstance(message, lua.Str):
-            message = lua.Call(lua.Name("tostring"), (message,))
-        return lua.ExprStat(lua.Call(lua.Name("error"), (message, lua.Num(0))))
+            message = lua.Call(lua.Global("tostring"), (message,))
+        return lua.ExprStat(lua.Call(lua.Global("error"), (message, lua.Num(0))))
 
     def raise_stmt(self, node: ast.Raise) -> lua.Stat:
         """``raise SomeError('message')``, which reaches the caller as an error reply."""
@@ -151,6 +151,8 @@ class ControlFlowCompiler(CallCompiler):
 
         failure: list[lua.Stat] = []
         if handler.name is not None:
+            if not lua.is_identifier(handler.name):
+                self.fail(handler, f"{handler.name!r} is a reserved word in Lua")
             self.helpers.add("__errmsg")
             message = lua.Call(lua.Name("__errmsg"), (lua.Name(result),))
             failure.append(lua.Local([handler.name], [message]))
@@ -182,7 +184,7 @@ class ControlFlowCompiler(CallCompiler):
             self.flow.pop()
         returns = contains_return(body)
         names = [ok, result, value] if returns else [ok, result]
-        call = lua.Call(lua.Name("pcall"), (lua.Name(function),))
+        call = lua.Call(lua.Global("pcall"), (lua.Name(function),))
         return (
             [lua.LocalFunction(function, [], inner), lua.Local(names, [call])],
             ok,
@@ -287,7 +289,7 @@ class ControlFlowCompiler(CallCompiler):
         if method == "values":
             self._temp += 1
             names = [f"__k{self._temp}", names[0]]
-        iterator = lua.Call(lua.Name("pairs"), (iterable,))
+        iterator = lua.Call(lua.Global("pairs"), (iterable,))
         return lua.GenericFor(names, iterator, self.loop_body(node.body))
 
     def enumerate_loop(self, node: ast.For, names: list[str], call: ast.Call) -> lua.Stat:

{redis_lua_py-0.10.0 → redis_lua_py-0.12.0}/src/redis_lua_py/_compile/expressions.py

@@ -80,11 +80,11 @@ class ExpressionCompiler(ScopeCompiler):
             return self.percent_format(node)
         if isinstance(node.op, ast.Mult) and "str" in (left_kind, right_kind):
             text, count = (node.left, node.right) if left_kind == "str" else (node.right, node.left)
-            return lua.Call(lua.Name("string.rep"), (self.expr(text), self.expr(count)))
+            return lua.Call(lua.Global("string.rep"), (self.expr(text), self.expr(count)))
 
         left, right = self.expr(node.left), self.expr(node.right)
         if isinstance(node.op, ast.FloorDiv):
-            return lua.Call(lua.Name("math.floor"), (lua.BinOp("/", left, right),))
+            return lua.Call(lua.Global("math.floor"), (lua.BinOp("/", left, right),))
         op = BIN_OPS.get(type(node.op))
         if op is None:
             self.fail(node, f"the {type(node.op).__name__} operator is not supported")
@@ -104,7 +104,7 @@ class ExpressionCompiler(ScopeCompiler):
             self.fail(node.right, "%-formatting from a mapping is not supported")
         values = node.right.elts if isinstance(node.right, ast.Tuple) else [node.right]
         args = (self.expr(node.left), *(self.expr(v) for v in values))
-        return lua.Call(lua.Name("string.format"), args)
+        return lua.Call(lua.Global("string.format"), args)
 
     def compare(self, node: ast.Compare) -> lua.Expr:
         if len(node.ops) != 1:
@@ -200,7 +200,7 @@ class ExpressionCompiler(ScopeCompiler):
             helper = "__inlist"
         elif kind == "str":
             find = lua.Call(
-                lua.Name("string.find"),
+                lua.Global("string.find"),
                 (self.expr(container), self.expr(item), lua.Num(1), lua.Bool(True)),
             )
             return lua.BinOp("==" if negate else "~=", find, lua.Nil())
@@ -236,10 +236,10 @@ class ExpressionCompiler(ScopeCompiler):
                     )
                 inner = self.expr(value.value)
                 if value.format_spec is None:
-                    parts.append(lua.Call(lua.Name("tostring"), (inner,)))
+                    parts.append(lua.Call(lua.Global("tostring"), (inner,)))
                 else:
                     spec = lua.Str(self.printf_spec(value))
-                    parts.append(lua.Call(lua.Name("string.format"), (spec, inner)))
+                    parts.append(lua.Call(lua.Global("string.format"), (spec, inner)))
             else:  # pragma: no cover - JoinedStr only holds these two kinds
                 self.fail(value, "unsupported f-string component")
         if not parts:
@@ -309,7 +309,7 @@ class ExpressionCompiler(ScopeCompiler):
                 if position is not None and position < 0
                 else self.index(node.slice, container)
             )
-            return lua.Call(lua.Name("string.sub"), (self.expr(node.value), at, at))
+            return lua.Call(lua.Global("string.sub"), (self.expr(node.value), at, at))
 
         if position is not None and position < 0:
             if not isinstance(node.value, ast.Name):

{redis_lua_py-0.10.0 → redis_lua_py-0.12.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.