repro-lambda 0.7.2__tar.gz → 0.8.0__tar.gz

repro_lambda-0.8.0/.release-please-manifest.json

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

{repro_lambda-0.7.2 → repro_lambda-0.8.0}/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.8.0](https://github.com/antonbabenko/repro-lambda/compare/v0.7.2...v0.8.0) (2026-09-18)
+
+
+### ⚠ BREAKING CHANGES
+
+* **lock:** `version_from` defaults to `format = "mise"`. A manifest that reads a `.tool-versions` file must now declare `format = "asdf"`.
+
+### Features
+
+* **lock:** read version_from pins from mise.toml by default ([#15](https://github.com/antonbabenko/repro-lambda/issues/15)) ([a9258af](https://github.com/antonbabenko/repro-lambda/commit/a9258af92fa29227b3c040cc8d7867e8739c3648))
+
 ## [0.7.2](https://github.com/antonbabenko/repro-lambda/compare/v0.7.1...v0.7.2) (2026-06-23)
 
 

{repro_lambda-0.7.2 → repro_lambda-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: repro-lambda
-Version: 0.7.2
+Version: 0.8.0
 Summary: Build reproducible AWS Lambda packages outside Terraform, optimized for terraform-aws-lambda by serverless.tf.
 Project-URL: Homepage, https://github.com/antonbabenko/repro-lambda
 Project-URL: Repository, https://github.com/antonbabenko/repro-lambda

{repro_lambda-0.7.2 → repro_lambda-0.8.0}/USAGE.md

@@ -119,7 +119,7 @@ member  = "vendor-{version}"   # map the versioned top dir to dest
 dest    = "vendor"
 version = "1.4.0"              # bump this one line; lock re-pins everything
 
-# A public binary whose version is derived from the vendor release's .tool-versions.
+# A public binary whose version is derived from the vendor release's mise.toml.
 [[lambda.source]]
 name    = "terraform"
 type    = "https"
@@ -131,18 +131,23 @@ dest    = "bin/terraform"
 executable = true
 version = "1.9.0"
 [lambda.source.version_from]
-source = "vendor"          # read from the vendor source's extracted tree
-file   = ".tool-versions"  # relative to its member-stripped root
-key    = "terraform"
+source = "vendor"       # read from the vendor source's extracted tree
+file   = "mise.toml"    # relative to its member-stripped root
+key    = "terraform"    # full tool key or its short name
+# format = "asdf"       # optional; default "mise"
 ```
 
 - **Pinning.** `sha256` is verified before the archive is opened. `extract` is
   `zip` / `tar.gz` / `none`. `member` extracts one file or a directory subtree to
   `dest`; omit it to extract the whole archive under `dest`. Source names are
   unique per lambda and dests may not overlap each other or the staged source.
-- **`version_from`** (single-level) derives a source's `version` from an asdf-style
-  `key value` line in another source's file, so bumping the root `version`
-  cascades to dependents. It is a lock input - it never affects the artifact hash.
+- **`version_from`** (single-level) derives a source's `version` from a pin file in
+  another source's extracted tree, so bumping the root `version` cascades to
+  dependents. It is a lock input - it never affects the artifact hash. `format`
+  picks the reader: the default `mise` parses a mise config's `[tools]` table and
+  matches `key` against the full tool key or its short name
+  (`aqua:hashicorp/terraform` resolves as `terraform`); `asdf` reads a
+  `key value` line from a `.tool-versions` file.
 - **`repro-lambda lock`** re-resolves `version_from`, re-downloads, recomputes each
   `sha256`, and rewrites this file (comment-preserving, atomic, idempotent). Run it
   after bumping a `version`. Pass `REPRO_LAMBDA_SOURCES_TOKEN` for private

{repro_lambda-0.7.2 → repro_lambda-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "repro-lambda"
-version = "0.7.2"
+version = "0.8.0"
 description = "Build reproducible AWS Lambda packages outside Terraform, optimized for terraform-aws-lambda by serverless.tf."
 readme = "README.md"
 requires-python = ">=3.11"

{repro_lambda-0.7.2 → repro_lambda-0.8.0}/src/repro_lambda/__init__.py

@@ -1,3 +1,3 @@
 """repro-lambda — reproducible AWS Lambda packaging outside Terraform."""
 
-__version__ = "0.7.2"  # x-release-please-version
+__version__ = "0.8.0"  # x-release-please-version

{repro_lambda-0.7.2 → repro_lambda-0.8.0}/src/repro_lambda/manifest.py

@@ -38,6 +38,7 @@ class ExtraFile:
 
 SUPPORTED_SOURCE_TYPES = {"github_release", "https"}
 SUPPORTED_EXTRACT = {"zip", "tar.gz", "none"}
+SUPPORTED_VERSION_FORMATS = {"mise", "asdf"}
 
 
 @dataclass(frozen=True)
@@ -45,15 +46,21 @@ class VersionFrom:
     """Lock-time version resolution rule for a source (never hashed).
 
     At `lock` time the referenced source (`source`, by name) is fetched + extracted,
-    the asdf-style `<key> <value>` line is read from `file` (relative to that source's
-    extracted tree), and the value re-pins this source's `version`. `build` never
-    resolves this - it substitutes the already-locked `version` into the url/tag/asset
-    templates. Single-level only: the referenced source may not itself use version_from.
+    `file` is read from that source's extracted tree, and the version it gives for
+    `key` re-pins this source's `version`. `build` never resolves this - it substitutes
+    the already-locked `version` into the url/tag/asset templates. Single-level only:
+    the referenced source may not itself use version_from.
+
+    `format` selects the reader. The default `mise` parses a mise config's `[tools]`
+    table, matching `key` against either the full tool key or its short name
+    ("aqua:hashicorp/terraform" -> "terraform"). `asdf` reads a `<key> <value>` line
+    from a .tool-versions file.
     """
 
     source: str
     file: str
     key: str
+    format: str = "mise"
 
 
 @dataclass(frozen=True)
@@ -323,8 +330,17 @@ def _parse_sources(path: Path, entry: dict) -> tuple[Source, ...]:
                     f"{path}: source {name!r} version_from.source cannot reference itself"
                 )
             _validate_relpath(path, "version_from.file", vf_raw["file"], where=f"source {name!r}")
+            vf_format = vf_raw.get("format", "mise")
+            if vf_format not in SUPPORTED_VERSION_FORMATS:
+                raise ValueError(
+                    f"{path}: source {name!r} version_from.format={vf_format!r} is not one of "
+                    f"{sorted(SUPPORTED_VERSION_FORMATS)}"
+                )
             version_from = VersionFrom(
-                source=vf_raw["source"], file=vf_raw["file"], key=vf_raw["key"]
+                source=vf_raw["source"],
+                file=vf_raw["file"],
+                key=vf_raw["key"],
+                format=vf_format,
             )
 
         uses_template = any("{version}" in v for v in (url, tag, asset, member or ""))

{repro_lambda-0.7.2 → repro_lambda-0.8.0}/src/repro_lambda/source_locker.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 import os
 import tempfile
+import tomllib
 from dataclasses import dataclass, replace
 from pathlib import Path
 
@@ -22,7 +23,7 @@ from repro_lambda.sources import (
     extract_to_temp,
 )
 
-_MAX_VERSION_FILE_BYTES = 1024 * 1024  # an asdf .tool-versions is tiny; cap to be safe
+_MAX_VERSION_FILE_BYTES = 1024 * 1024  # a pin file is tiny; cap to be safe
 
 
 @dataclass
@@ -35,13 +36,18 @@ class SourcePin:
     changed: bool
 
 
-def _read_asdf_version(path: Path, key: str) -> str:
-    """Read `<key> <value>` from an asdf-style file (e.g. .tool-versions)."""
+def _read_pin_file(path: Path) -> str:
+    """Read a version_from pin file, with the guards both readers share."""
     if not path.is_file():
         raise SourceFetchError(f"version_from file not found: {path}")
     if path.stat().st_size > _MAX_VERSION_FILE_BYTES:
         raise SourceFetchError(f"version_from file too large: {path}")
-    for raw in path.read_text(encoding="utf-8").splitlines():
+    return path.read_text(encoding="utf-8")
+
+
+def _read_asdf_version(path: Path, key: str) -> str:
+    """Read `<key> <value>` from an asdf-style file (e.g. .tool-versions)."""
+    for raw in _read_pin_file(path).splitlines():
         line = raw.strip()
         if not line or line.startswith("#"):
             continue
@@ -51,6 +57,44 @@ def _read_asdf_version(path: Path, key: str) -> str:
     raise SourceFetchError(f"key {key!r} not found in {path.name}")
 
 
+def _mise_version(spec: object) -> str:
+    """The pinned version of one `[tools]` entry, or "" when it pins none.
+
+    mise accepts a bare string, a table/inline table with `version`, or a list of
+    versions (first wins). An entry with only e.g. `bin_path` pins nothing.
+    """
+    if isinstance(spec, str):
+        return spec
+    if isinstance(spec, dict):
+        version = spec.get("version")
+        return version if isinstance(version, str) else ""
+    if isinstance(spec, list):
+        return next((v for v in spec if isinstance(v, str)), "")
+    return ""
+
+
+def _read_mise_version(path: Path, key: str) -> str:
+    """Read a tool version from a mise config's `[tools]` table.
+
+    `key` matches either the full tool key or its short name, so
+    "aqua:hashicorp/terraform" and "http:hcledit" both resolve as "terraform"/"hcledit".
+    """
+    try:
+        tools = tomllib.loads(_read_pin_file(path)).get("tools", {})
+    except tomllib.TOMLDecodeError as exc:
+        raise SourceFetchError(f"version_from file is not valid TOML: {path} ({exc})") from exc
+    for raw_key, spec in tools.items():
+        if key not in (raw_key, raw_key.split(":", 1)[-1].split("/")[-1]):
+            continue
+        version = _mise_version(spec)
+        if version:
+            return version
+    raise SourceFetchError(f"key {key!r} not found in {path.name}")
+
+
+_VERSION_READERS = {"mise": _read_mise_version, "asdf": _read_asdf_version}
+
+
 def _ordered(sources: tuple[Source, ...]) -> list[Source]:
     """Non-version_from sources first (the referenced roots), then dependents.
 
@@ -80,12 +124,13 @@ def _lock_lambda_sources(
                     f"(it must declare an archive extract)"
                 )
             # Read relative to the referenced source's member-stripped tree, so file= can
-            # be e.g. ".tool-versions" rather than the version-dependent "pofix-9.9/...".
+            # be e.g. "mise.toml" rather than the version-dependent "pofix-9.9/...".
             base = extracted[ref]
             ref_member = src_by_name[ref].resolved_member
             if ref_member:
                 base = base / ref_member
-            version = _read_asdf_version(base / src.version_from.file, src.version_from.key)
+            read = _VERSION_READERS[src.version_from.format]
+            version = read(base / src.version_from.file, src.version_from.key)
         resolved = replace(src, version=version)
 
         raw = tmp / f"lock-{src.name}"

{repro_lambda-0.7.2 → repro_lambda-0.8.0}/tests/test_source_locker.py

@@ -6,9 +6,12 @@ import tarfile
 import zipfile
 from pathlib import Path
 
+import pytest
+
 from repro_lambda import source_locker
 from repro_lambda.manifest import load_manifest
 from repro_lambda.source_locker import lock_sources
+from repro_lambda.sources import SourceFetchError
 
 OLD_SHA = "0" * 64
 
@@ -29,7 +32,7 @@ def _zip(path: Path, entries: list[tuple[str, bytes]]) -> bytes:
     return path.read_bytes()
 
 
-def _manifest(tmp_path: Path) -> Path:
+def _manifest(tmp_path: Path, pin_file: str = ".tool-versions", pin_format: str = "asdf") -> Path:
     p = tmp_path / "lambdas.toml"
     p.write_text(
         "# keep this comment\n"
@@ -59,10 +62,11 @@ def _manifest(tmp_path: Path) -> Path:
         'extract = "zip"\n'
         'member  = "terraform"\n'
         'dest    = "bin/terraform"\n'
-        'version = "0.0.0"\n'  # stale; lock derives it from pofix's .tool-versions
+        'version = "0.0.0"\n'  # stale; lock derives it from the pofix pin file
         "[lambda.source.version_from]\n"
         'source = "pofix"\n'
-        'file   = ".tool-versions"\n'
+        f'file   = "{pin_file}"\n'
+        f'format = "{pin_format}"\n'
         'key    = "terraform"\n'
         "\n[builder]\n"
         f'base_image_python = "public.ecr.aws/lambda/python:3.13@sha256:{"0" * 64}"\n'
@@ -70,11 +74,24 @@ def _manifest(tmp_path: Path) -> Path:
     return p
 
 
-def _fixtures(tmp_path: Path) -> dict[str, bytes]:
-    pofix = _targz(
-        tmp_path / "pofix.tgz",
-        [("pofix-9.9/.tool-versions", b"terraform 1.9.0\nhcledit 0.2.17\n")],
-    )
+ASDF_PINS = b"terraform 1.9.0\nhcledit 0.2.17\n"
+
+# A string pin, a table pin, and an entry that pins no version at all.
+MISE_PINS = b"""[tools]
+"aqua:hashicorp/terraform" = "1.9.0"
+
+[tools."http:hcledit"]
+version = "0.2.17"
+
+[tools."http:nopin"]
+bin_path = "bin"
+"""
+
+
+def _fixtures(
+    tmp_path: Path, pin_name: str = ".tool-versions", pin_body: bytes = ASDF_PINS
+) -> dict[str, bytes]:
+    pofix = _targz(tmp_path / "pofix.tgz", [(f"pofix-9.9/{pin_name}", pin_body)])
     tf = _zip(tmp_path / "tf.zip", [("terraform", b"TFBINARY")])
     return {"pofix": pofix, "terraform": tf}
 
@@ -135,3 +152,22 @@ def test_lock_no_sources_returns_false(tmp_path):
         f'base_image_python = "public.ecr.aws/lambda/python:3.13@sha256:{"0" * 64}"\n'
     )
     assert lock_sources(p, None) is False
+
+
+def test_lock_resolves_version_from_mise(tmp_path, monkeypatch):
+    manifest = _manifest(tmp_path, pin_file="mise.toml", pin_format="mise")
+    _install_fake_download(monkeypatch, _fixtures(tmp_path, "mise.toml", MISE_PINS))
+
+    assert lock_sources(manifest, None) is True
+
+    by_name = {s.name: s for s in load_manifest(manifest).lambdas[0].sources}
+    assert by_name["terraform"].version == "1.9.0"  # short name of "aqua:hashicorp/terraform"
+
+
+def test_lock_mise_missing_key_raises(tmp_path, monkeypatch):
+    manifest = _manifest(tmp_path, pin_file="mise.toml", pin_format="mise")
+    pins = MISE_PINS.replace(b'"aqua:hashicorp/terraform" = "1.9.0"', b"")
+    _install_fake_download(monkeypatch, _fixtures(tmp_path, "mise.toml", pins))
+
+    with pytest.raises(SourceFetchError, match="key 'terraform' not found"):
+        lock_sources(manifest, None)

{repro_lambda-0.7.2 → repro_lambda-0.8.0}/tests/test_sources_schema.py

@@ -92,13 +92,45 @@ def test_parse_version_from_and_substitution(tmp_path: Path):
         'url="https://releases.example.com/terraform_{version}_linux_arm64.zip"\n'
         f'sha256="{SHA2}"\nextract="zip"\nmember="terraform"\ndest="bin/terraform"\n'
         'version="1.9.0"\n'
-        '[lambda.source.version_from]\nsource="pofix"\nfile=".tool-versions"\nkey="terraform"\n',
+        '[lambda.source.version_from]\nsource="pofix"\nfile="mise.toml"\nkey="terraform"\n',
     )
     tf = sources[1]
-    assert tf.version_from == VersionFrom(source="pofix", file=".tool-versions", key="terraform")
+    # format defaults to mise.
+    assert tf.version_from == VersionFrom(source="pofix", file="mise.toml", key="terraform")
+    assert tf.version_from.format == "mise"
     assert tf.resolved_url == "https://releases.example.com/terraform_1.9.0_linux_arm64.zip"
 
 
+def test_version_from_asdf_format_opt_in(tmp_path: Path):
+    sources = _load(
+        tmp_path,
+        "[[lambda.source]]\n"
+        'name="pofix"\ntype="github_release"\nrepo="o/pofix"\ntag="pofix-v0.10.0"\n'
+        f'asset="pofix-0.10.0.tar.gz"\nsha256="{SHA}"\nextract="tar.gz"\ndest="pofix"\n'
+        "[[lambda.source]]\n"
+        'name="tf"\ntype="https"\nurl="https://releases.example.com/tf.zip"\n'
+        f'sha256="{SHA2}"\nextract="zip"\nmember="terraform"\ndest="bin/terraform"\n'
+        "[lambda.source.version_from]\n"
+        'source="pofix"\nfile=".tool-versions"\nformat="asdf"\nkey="terraform"\n',
+    )
+    assert sources[1].version_from.format == "asdf"
+
+
+def test_version_from_rejects_unknown_format(tmp_path: Path):
+    with pytest.raises(ValueError, match="version_from.format"):
+        _load(
+            tmp_path,
+            "[[lambda.source]]\n"
+            'name="pofix"\ntype="github_release"\nrepo="o/pofix"\ntag="pofix-v0.10.0"\n'
+            f'asset="pofix-0.10.0.tar.gz"\nsha256="{SHA}"\nextract="tar.gz"\ndest="pofix"\n'
+            "[[lambda.source]]\n"
+            'name="tf"\ntype="https"\nurl="https://releases.example.com/tf.zip"\n'
+            f'sha256="{SHA2}"\nextract="zip"\nmember="terraform"\ndest="bin/terraform"\n'
+            "[lambda.source.version_from]\n"
+            'source="pofix"\nfile="tool.json"\nformat="json"\nkey="terraform"\n',
+        )
+
+
 def test_sources_default_empty(tmp_path: Path):
     assert _load(tmp_path, "") == ()
 

{repro_lambda-0.7.2 → repro_lambda-0.8.0}/uv.lock

@@ -646,7 +646,7 @@ wheels = [
 
 [[package]]
 name = "repro-lambda"
-version = "0.7.2"
+version = "0.8.0"
 source = { editable = "." }
 dependencies = [
     { name = "boto3" },

repro_lambda-0.7.2/.release-please-manifest.json

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