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

{redis_lua_py-0.12.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.12.0 → redis_lua_py-0.13.0}/CHANGELOG.md

@@ -7,6 +7,13 @@ 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)
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: redis-lua-py
-Version: 0.12.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.12.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.12.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.12.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.12.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.12.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.12.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.12.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)
 

{redis_lua_py-0.12.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.12.0 → redis_lua_py-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "redis-lua-py"
-version = "0.12.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.12.0 → redis_lua_py-0.13.0}/src/redis_lua_py/__init__.py

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

{redis_lua_py-0.12.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.12.0 → redis_lua_py-0.13.0}/src/redis_lua_py/_compile/base.py

@@ -296,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:

{redis_lua_py-0.12.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):
@@ -141,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.
@@ -185,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"
 

{redis_lua_py-0.12.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.12.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
 """
 

{redis_lua_py-0.12.0 → redis_lua_py-0.13.0}/tests/generated_scripts.py

@@ -12,7 +12,7 @@ Regenerate with:
 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
 
 __all__ = [
@@ -30,10 +30,10 @@ __all__ = [
 
 
 #: 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):
@@ -74,9 +74,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. "
@@ -90,7 +90,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."
@@ -149,7 +149,7 @@ RATE_LIMIT = """\
 -- Generated by redis-lua-py from tests/codegen_scripts.py:19. 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)
@@ -188,7 +188,7 @@ def rate_limit(client: Any, /, key: _Key, limit: int, ttl: int) -> Any:
 TOUCH_ALL = """\
 -- touch_all
 -- Generated by redis-lua-py from tests/codegen_scripts.py:29. Do not edit.
-local ttl = tonumber(ARGV[1])
+local ttl = ARGV[1]
 local keys = {}
 for __i1 = 1, #KEYS do
   keys[#keys + 1] = KEYS[__i1]

{redis_lua_py-0.12.0 → redis_lua_py-0.13.0}/tests/test_binary.py

@@ -40,7 +40,8 @@ class TestArgv:
         """No tonumber, no tostring: a bytes annotation is a passthrough."""
         emitted = body(append_chunk)
         assert "local chunk = ARGV[1]" in emitted
-        assert "local ttl = tonumber(ARGV[2])" in emitted
+        # Only handed back to Redis, so the int is left as text too.
+        assert "local ttl = ARGV[2]" in emitted
 
     def test_non_utf8_argv_arrives_intact(self, client: Any) -> None:
         size, count = append_chunk(client, buffer="buf", counter="chunks", chunk=BLOB, ttl=60)

{redis_lua_py-0.12.0 → redis_lua_py-0.13.0}/tests/test_codegen.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import ast
 import importlib.util
 import inspect
+import shutil
 import subprocess
 import sys
 from pathlib import Path
@@ -199,6 +200,122 @@ class TestGeneratedFunctions:
             codegen.generate(module_of(_run=codegen_scripts.rate_limit), tmp_path / "_lua.py")
 
 
+def python39() -> str | None:
+    """A Python 3.9 interpreter, if uv knows of one. CI installs one for this."""
+    uv = shutil.which("uv")
+    if uv is None:
+        return None
+    found = subprocess.run(
+        [uv, "python", "find", "3.9"], capture_output=True, text=True, check=False
+    )
+    if found.returncode != 0:
+        return None
+    return found.stdout.strip() or None
+
+
+#: Imports a generated module on its own, with nothing else installed.
+LOAD = """
+import importlib.util, sys
+
+spec = importlib.util.spec_from_file_location("generated_lua", sys.argv[1])
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+"""
+
+#: Calls the scripts of codegen_scripts through a stand-in for redis-py that
+#: records what it is asked to run. Python 3.9, and standard library only.
+CALL = """
+class Client:
+    def __init__(self):
+        self.calls = []
+    def register_script(self, lua):
+        def run(keys, args, client):
+            self.calls.append((lua, keys, args))
+            return len(self.calls)
+        return run
+
+client = Client()
+assert module.rate_limit(client, key="k", limit=1, ttl=2) == 1
+assert module.touch_all(client, keys=iter([b"a", "b"]), ttl=2.5) == 2
+assert module.echo(client, True, suffix=memoryview(b"x")) == 3
+assert [call[1:] for call in client.calls] == [
+    (["k"], ["1", "2"]),
+    ([b"a", "b"], ["2.5"]),
+    ([], ["1", memoryview(b"x")]),
+]
+assert client.calls[0][0] == module.RATE_LIMIT
+for script, args in ((module.echo, (None, "")), (module.touch_all, ("ab", 1))):
+    try:
+        script(client, *args)
+    except TypeError:
+        pass
+    else:
+        raise AssertionError("accepted a value Redis cannot represent")
+print("ok")
+"""
+
+
+class TestPython39:
+    """A generated module imports and runs on Python 3.9.
+
+    This package needs 3.10, but a library vendoring the generated code may
+    still support 3.9, and the module is all of this package it ships.
+    """
+
+    @pytest.fixture
+    def widened(self, tmp_path):
+        out = tmp_path / "_lua.py"
+        codegen.generate(module_of(opaque=opaque, maybe=maybe), out)
+        return out
+
+    @pytest.mark.parametrize("which", ["checked_in", "widened"])
+    def test_parses_as_python_39(self, request, which):
+        path = GENERATED if which == "checked_in" else request.getfixturevalue("widened")
+        ast.parse(path.read_text(), feature_version=(3, 9))
+
+    @pytest.mark.parametrize("which", ["checked_in", "widened"])
+    def test_evaluates_no_union_operator(self, request, which):
+        # `X | Y` parses on 3.9 but fails there when evaluated. Annotations
+        # never are, under `from __future__ import annotations`.
+        path = GENERATED if which == "checked_in" else request.getfixturevalue("widened")
+        tree = ast.parse(path.read_text())
+        annotations = {
+            id(inner)
+            for node in ast.walk(tree)
+            for annotation in (getattr(node, "annotation", None), getattr(node, "returns", None))
+            if annotation is not None
+            for inner in ast.walk(annotation)
+        }
+        evaluated = [
+            ast.unparse(node)
+            for node in ast.walk(tree)
+            if isinstance(node, ast.BinOp)
+            and isinstance(node.op, ast.BitOr)
+            and id(node) not in annotations
+        ]
+
+        assert "from __future__ import annotations" in path.read_text()
+        assert evaluated == []
+
+    def test_runs_on_python_39(self, widened):
+        interpreter = python39()
+        if interpreter is None:
+            pytest.skip("no Python 3.9 available through uv")
+
+        def run(code: str, path: Path) -> subprocess.CompletedProcess[str]:
+            return subprocess.run(
+                [interpreter, "-I", "-c", code, str(path)],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+
+        imported = run(LOAD, widened)
+        assert imported.returncode == 0, imported.stderr
+        called = run(LOAD + CALL, GENERATED)
+        assert called.stdout == "ok\n", called.stderr
+
+
 class TestPythonModule:
     def test_holds_each_script_exactly(self):
         assert codegen_scripts.rate_limit.lua == generated_scripts.RATE_LIMIT

{redis_lua_py-0.12.0 → redis_lua_py-0.13.0}/tests/test_compile.py

@@ -33,6 +33,26 @@ def test_numeric_annotations_get_tonumber(body: Body) -> None:
     assert "local text = ARGV[3]" in emitted
 
 
+def test_a_number_only_handed_to_redis_stays_text(body: Body) -> None:
+    @script
+    def s(k: Key, ttl: int, score: float, n: int, limit: int, step: int) -> int:
+        redis.expire(k, ttl)
+        redis.call("ZADD", k, score, "member")
+        redis.incrby(k, n)
+        if redis.incrby(k, limit) > limit:
+            return 0
+        step = step + 1
+        return redis.incrby(k, step)
+
+    emitted = body(s)
+    assert "local ttl = ARGV[1]" in emitted
+    assert "local score = ARGV[2]" in emitted
+    assert "local n = ARGV[3]" in emitted
+    # Compared, or assigned to: a number in the body, so converted as before.
+    assert "local limit = tonumber(ARGV[4])" in emitted
+    assert "local step = tonumber(ARGV[5])" in emitted
+
+
 def test_full_script_emission(body: Body) -> None:
     @script
     def rate_limit(key: Key, limit: int, ttl: int) -> int:
@@ -46,7 +66,7 @@ def test_full_script_emission(body: Body) -> None:
     assert body(rate_limit) == (
         "local key = KEYS[1]\n"
         "local limit = tonumber(ARGV[1])\n"
-        "local ttl = tonumber(ARGV[2])\n"
+        "local ttl = ARGV[2]\n"
         "local current = redis.call('INCR', key)\n"
         "if current == 1 then\n"
         "  redis.call('EXPIRE', key, ttl)\n"

{redis_lua_py-0.12.0 → redis_lua_py-0.13.0}/tests/test_expressions.py

@@ -172,3 +172,17 @@ class TestAddition:
         client.set("n", "5")
         assert "__add" not in bump.lua
         assert bump(client, k="n") == 11
+
+    def test_the_least_or_greatest_of_numbers_is_a_number(self, client: Any) -> None:
+        @script
+        def refill(key: Key, capacity: float, rate: float, now: float) -> int:
+            tokens = float(redis.get(key))
+            delta = max(0, now)
+            tokens = min(capacity, tokens + delta * rate)
+            return tokens
+
+        client.set("bucket", "2")
+        assert "__add" not in refill.lua
+        assert "tokens + delta * rate" in refill.lua
+        assert refill(client, key="bucket", capacity=10, rate=2, now=3) == 8
+        assert refill(client, key="bucket", capacity=5, rate=2, now=3) == 5

{redis_lua_py-0.12.0 → redis_lua_py-0.13.0}/tests/test_semantics.py

@@ -383,3 +383,32 @@ class TestDefiniteAssignment:
                 if n > 0:
                     head = 1
                 return head
+
+
+class TestNumbersHandedToRedis:
+    """A Lua number is a double, which has no exact form past 2^53."""
+
+    def test_a_large_integer_arrives_exactly(self, client: Any) -> None:
+        @script
+        def store(k: Key, n: int) -> bytes:
+            redis.set(k, n)
+            return redis.get(k)
+
+        assert store(client, k="n", n=2**53 + 1) == b"9007199254740993"
+
+    def test_a_float_is_not_rewritten_with_seventeen_digits(self, client: Any) -> None:
+        @script
+        def store(k: Key, x: float) -> bytes:
+            redis.set(k, x)
+            return redis.get(k)
+
+        assert store(client, k="f", x=0.1) == b"0.1"
+
+    def test_arithmetic_still_sees_a_number(self, client: Any) -> None:
+        @script
+        def twice(k: Key, n: int) -> int:
+            redis.set(k, n)
+            return n * 2 + 1
+
+        assert twice(client, k="n", n=20) == 41
+        assert client.get("n") == b"20"

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

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