funcd-bundle 0.3.2__tar.gz → 0.3.4__tar.gz

{funcd_bundle-0.3.2 → funcd_bundle-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: funcd-bundle
-Version: 0.3.2
+Version: 0.3.4
 Summary: Bundle a Python funcd function and its locked dependencies for the funcd runtime
 Project-URL: Homepage, https://github.com/pyvvo/funcd-python
 Project-URL: Repository, https://github.com/pyvvo/funcd-python

{funcd_bundle-0.3.2 → funcd_bundle-0.3.4}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "funcd-bundle"
 # Not bumped per release: the vX.Y.Z git tag is the version, stamped into the build at publish time.
-version = "0.3.2"
+version = "0.3.4"
 description = "Bundle a Python funcd function and its locked dependencies for the funcd runtime"
 authors = [{ name = "The funcd Authors" }]
 readme = "README.md"

{funcd_bundle-0.3.2 → funcd_bundle-0.3.4}/src/funcd_bundle/bundle.py

@@ -16,7 +16,6 @@ import csv
 import io
 import os
 import platform as host
-import re
 import shlex
 import shutil
 import subprocess
@@ -38,7 +37,6 @@ DEFAULT_HANDLER = "handler.py"
 RUNTIME_PACKAGE = "funcd-shim"
 PLATFORMS = {"linux/amd64": "x86_64", "linux/arm64": "aarch64"}
 SKIPPED = {"__pycache__", "tests"}
-MAIN_LINE = re.compile(r"^main:.*$", re.MULTILINE)
 # never streamed into a container: caches, virtualenvs and build outputs
 NOT_COPIED = frozenset(
     {".venv", ".git", "node_modules", "__pycache__", "dist", ".mypy_cache", ".pytest_cache", ".ruff_cache"}
@@ -86,7 +84,10 @@ def discover(project: Path) -> dict[str, Function]:
         defaults = {project.resolve().name: DEFAULT_HANDLER}
     functions = {}
     for name, manifest in manifests.items():
-        data = yaml.safe_load(manifest.read_text()) or {}
+        try:
+            data = yaml.safe_load(manifest.read_text()) or {}
+        except yaml.YAMLError as err:
+            raise BundleError(f"{manifest}: {err}") from err
         if not isinstance(data, dict):
             raise BundleError(f"{manifest} is not a mapping")
         main = data.get("main") or defaults[name]
@@ -331,16 +332,38 @@ def _copy_handler(project: Path, fn: Function, out: Path) -> list[Path]:
         sources = [p for p in source.rglob("*.py") if not SKIPPED.intersection(p.relative_to(source).parts)]
     # inside the bundle the handler sits at the root, so `main` must name it there (funcdctl dev reads it); a
     # manifest without one gets one, else the bundle's generic manifest would default to handler.py
-    main = f"main: {fn.handler.name}"
-    text, found = MAIN_LINE.subn(main, fn.manifest.read_text())
-    if not found:
-        if text and not text.endswith("\n"):
-            text += "\n"
-        text += main + "\n"
-    (out / GENERIC_MANIFEST).write_text(text)
+    (out / GENERIC_MANIFEST).write_text(_with_main(fn.manifest.read_text(), fn.handler.name))
     return sources
 
 
+def _with_main(text: str, handler: str) -> str:
+    """The manifest with its top-level `main` set to handler. The YAML parser finds the key, however it is
+    written; the rest stays as written, since a PyYAML dump would re-resolve YAML 1.1 scalars funcd reads as
+    YAML 1.2 text."""
+    entry = f"main: {handler}"
+    root = yaml.compose(text, Loader=yaml.SafeLoader)
+    if isinstance(root, yaml.MappingNode):
+        for key, value in root.value:
+            if isinstance(key, yaml.ScalarNode) and key.value == "main":
+                start, end = key.start_mark.index, value.end_mark.index
+                # a block scalar's span ends past its line break
+                if text[start:end].endswith("\n"):
+                    entry += "\n"
+                return text[:start] + entry + text[end:]
+        if root.flow_style:
+            # a block line after a flow mapping is a second root: the key goes inside, after its brace
+            brace = next(
+                t
+                for t in yaml.scan(text, Loader=yaml.SafeLoader)
+                if isinstance(t, yaml.FlowMappingStartToken)
+            )
+            at = brace.end_mark.index
+            return text[:at] + entry + (", " if root.value else "") + text[at:]
+    if text and not text.endswith("\n"):
+        text += "\n"
+    return text + entry + "\n"
+
+
 def _top_level_modules(out: Path) -> set[str]:
     """The importable top-level names of the vendored distributions, from each RECORD."""
     names: set[str] = set()

{funcd_bundle-0.3.2 → funcd_bundle-0.3.4}/tests/test_bundle.py

@@ -16,6 +16,7 @@ from collections.abc import Iterator
 from pathlib import Path
 
 import pytest
+import yaml
 
 from funcd_bundle import BundleError, bundle, discover, host_platform
 from funcd_bundle.bundle import _check
@@ -275,7 +276,76 @@ def test_issue_154_stem_manifest_without_main_names_bundled_handler(tmp_path: Pa
     assert (out / "funcdctl.yaml").read_text() == manifest + "main: extract.py\n"
 
 
+@pytest.mark.parametrize(
+    "main",
+    [
+        '"main": src/handler.py\n',
+        "'main': src/handler.py\n",
+        "main:\n  src/handler.py\n",
+    ],
+    ids=["double-quoted-key", "single-quoted-key", "value-on-next-line"],
+)
+def test_issue_r29_main_key_is_rewritten_not_duplicated(tmp_path: Path, main: str) -> None:
+    project = tmp_path / "reader"
+    _write(
+        project,
+        {
+            "pyproject.toml": '[project]\nname = "reader"\nversion = "0.1.0"\nrequires-python = ">=3.12"\n',
+            "funcdctl.yaml": "runtime: python314\n" + main + "handler: handle\n",
+            "src/handler.py": "def handle(ctx, event): ...\n",
+        },
+    )
+    _uv("lock", "--offline", "--python", "3.14", cwd=project)
+    out = bundle(project, "reader", host_platform(), tmp_path / "out", hermetic=False, check=False)
+
+    assert (out / "funcdctl.yaml").read_text() == "runtime: python314\nmain: handler.py\nhandler: handle\n", (
+        "the manifest's one main names the bundled handler"
+    )
+
+
+@pytest.mark.parametrize(
+    ("manifest", "want"),
+    [
+        ("{runtime: python314, handler: handle}\n", {"runtime": "python314", "handler": "handle"}),
+        ("!!map &m {\n  runtime: python314,\n}\n", {"runtime": "python314"}),
+        ("{}\n", {}),
+    ],
+    ids=["one-line", "tagged-multi-line", "empty"],
+)
+def test_issue_r49_flow_mapping_manifest_gets_main(
+    tmp_path: Path, manifest: str, want: dict[str, str]
+) -> None:
+    project = tmp_path / "reader"
+    _write(
+        project,
+        {
+            "pyproject.toml": '[project]\nname = "reader"\nversion = "0.1.0"\nrequires-python = ">=3.12"\n',
+            "funcdctl.yaml": manifest,
+            "handler.py": "def handle(ctx, event): ...\n",
+        },
+    )
+    _uv("lock", "--offline", "--python", "3.14", cwd=project)
+    out = bundle(project, "reader", host_platform(), tmp_path / "out", hermetic=False, check=False)
+
+    assert yaml.safe_load((out / "funcdctl.yaml").read_text()) == want | {"main": "handler.py"}, (
+        "the bundle's manifest is valid YAML whose main names the bundled handler"
+    )
+
+
 def test_missing_handler_is_named(tmp_path: Path) -> None:
     _write(tmp_path, {"funcdctl.yaml": "runtime: python314\nmain: src/nope.py\n"})
     with pytest.raises(BundleError, match="nope.py"):
         bundle(tmp_path, tmp_path.name, host_platform(), tmp_path / "out", hermetic=False, check=False)
+
+
+def test_issue_r48_invalid_manifest_yaml_is_reported(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _write(tmp_path, {"funcdctl.yaml": "runtime: [\n", "handler.py": ""})
+    monkeypatch.chdir(tmp_path)
+
+    assert main(["--no-check", "--out", str(tmp_path / "out")]) == 1, "a manifest that does not parse fails"
+    err = capsys.readouterr().err
+    assert err.startswith(f"funcd-bundle: {tmp_path / 'funcdctl.yaml'}: "), err
+    assert "while parsing a flow node" in err, "the parser message names the problem"
+    assert "Traceback" not in err