feat(uv): implement automatic uv.lock generation from pyproject.toml if missing

Author: rivhar

examples/build-package/README.md

@@ -56,6 +56,7 @@ Note that this example may create resources which cost money. Run `terraform des
 | <a name="module_package_dir_poetry_quiet"></a> [package\_dir\_poetry\_quiet](#module\_package\_dir\_poetry\_quiet) | ../../ | n/a |
 | <a name="module_package_dir_uv"></a> [package\_dir\_uv](#module\_package\_dir\_uv) | ../../ | n/a |
 | <a name="module_package_dir_uv_no_docker"></a> [package\_dir\_uv\_no\_docker](#module\_package\_dir\_uv\_no\_docker) | ../../ | n/a |
+| <a name="module_package_dir_uv_no_lock"></a> [package\_dir\_uv\_no\_lock](#module\_package\_dir\_uv\_no\_lock) | ../../ | n/a |
 | <a name="module_package_dir_with_npm_install"></a> [package\_dir\_with\_npm\_install](#module\_package\_dir\_with\_npm\_install) | ../../ | n/a |
 | <a name="module_package_dir_with_npm_install_lock_file"></a> [package\_dir\_with\_npm\_install\_lock\_file](#module\_package\_dir\_with\_npm\_install\_lock\_file) | ../../ | n/a |
 | <a name="module_package_dir_without_npm_install"></a> [package\_dir\_without\_npm\_install](#module\_package\_dir\_without\_npm\_install) | ../../ | n/a |

examples/build-package/main.tf

@@ -137,6 +137,23 @@ module "package_dir_poetry_quiet" {
   quiet_archive_local_exec = true # Suppress Poetry/pip output during packaging
 }
 
+# Create zip-archive of a single directory where "uv export" & "pip install" will be executed
+module "package_dir_uv_no_lock" {
+  source = "../../"
+
+  create_function = false
+  runtime         = "python3.12"
+
+  source_path = [
+    {
+      path       = "${path.module}/../fixtures/python-app-uv-no-lock"
+      uv_install = true
+    }
+  ]
+
+  artifacts_dir = "${path.root}/builds/package_dir_uv_no_lock/"
+}
+
 # Create zip-archive of a single directory where "uv export" & "pip install" will be executed (using docker)
 module "package_dir_uv" {
   source = "../../"

examples/fixtures/python-app-uv-no-lock/index.py

@@ -0,0 +1,2 @@
+def lambda_handler(event, context):
+    return {"statusCode": 200, "body": "Hello from uv (no lock)!"}

examples/fixtures/python-app-uv-no-lock/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "python-app-uv-no-lock"
+version = "0.1.0"
+description = "Fixture project to test uv without uv.lock"
+requires-python = ">=3.12"
+
+dependencies = [
+    "requests>=2.31.0"
+]
+
+[tool.uv]

package.py

@@ -654,7 +654,9 @@ def get_build_system_from_pyproject_toml(pyproject_file):
                     continue
                 if bs and line.startswith("build-backend") and "poetry" in line:
                     return "poetry"
-                if line.startswith("[tool.uv]"):
+                if line.startswith("[tool.uv]") or (
+                    bs and line.startswith("build-backend") and "uv" in line
+                ):
                     return "uv"
 
 
@@ -720,17 +722,25 @@ def uv_install_step(
             if os.path.isdir(path):
                 uv_lock_file = os.path.join(path, "uv.lock")
 
-            if not os.path.isfile(uv_lock_file):
+            uv_project_path = os.path.dirname(uv_lock_file)
+            pyproject_file = os.path.join(uv_project_path, "pyproject.toml")
+
+            has_lock = os.path.isfile(uv_lock_file)
+            has_pyproject = os.path.isfile(pyproject_file)
+
+            if not has_lock and not has_pyproject:
                 if required:
-                    raise RuntimeError("uv.lock not found: {}".format(uv_lock_file))
-            else:
-                step("uv", runtime, path, uv_export_extra_args, prefix, tmp_dir)
-                hash(uv_lock_file)
+                    raise RuntimeError(
+                        "Neither uv.lock nor pyproject.toml found in: {}".format(path)
+                    )
+                return
+
+            step("uv", runtime, path, uv_export_extra_args, prefix, tmp_dir)
 
-                uv_project_path = os.path.dirname(uv_lock_file)
-                pyproject_file = os.path.join(uv_project_path, "pyproject.toml")
-                if os.path.isfile(pyproject_file):
-                    hash(pyproject_file)
+            if has_lock:
+                hash(uv_lock_file)
+            if has_pyproject:
+                hash(pyproject_file)
 
         def poetry_install_step(
             path, poetry_export_extra_args=[], prefix=None, required=False, tmp_dir=None
@@ -835,7 +845,12 @@ def commands_step(path, commands):
                     )
                 runtime = query.runtime
                 if runtime.startswith("python"):
-                    if os.path.isfile(os.path.join(path, "uv.lock")):
+                    pyproject = os.path.join(path, "pyproject.toml")
+                    build_system = get_build_system_from_pyproject_toml(pyproject)
+                    if (
+                        os.path.isfile(os.path.join(path, "uv.lock"))
+                        or build_system == "uv"
+                    ):
                         uv_install_step(path)
                     else:
                         pip_requirements_step(os.path.join(path, "requirements.txt"))
@@ -1430,139 +1445,157 @@ def copy_file_to_target(file, temp_dir):
 
 @contextmanager
 def install_uv_dependencies(query, path, uv_export_extra_args, tmp_dir):
-    # uv.lock is required for uv
+    def copy_file_to_target(file, target_dir):
+        filename = os.path.basename(file)
+        target_file = os.path.join(target_dir, filename)
+        shutil.copyfile(file, target_file)
+        return target_file
+
+    def strip_editable_self_dependency(requirements_file):
+        cleaned = []
+
+        with open(requirements_file, "r") as f:
+            for line in f:
+                stripped = line.strip()
+                if stripped == "-e .":
+                    continue
+                if stripped.startswith("-e file:") or stripped.startswith("file://"):
+                    continue
+                cleaned.append(line.rstrip())
+
+        with open(requirements_file, "w") as f:
+            f.write("\n".join(cleaned) + "\n")
+
     uv_lock_file = path
     if os.path.isdir(path):
         uv_lock_file = os.path.join(path, "uv.lock")
-    if not os.path.exists(uv_lock_file):
-        yield
-        return
-
-    # pyproject.toml is required by uv
-    project_path = os.path.dirname(uv_lock_file)
+    project_path = (
+        os.path.dirname(uv_lock_file) if os.path.isdir(path) else os.path.dirname(path)
+    )
     pyproject_file = os.path.join(project_path, "pyproject.toml")
-    if not os.path.isfile(pyproject_file):
-        yield
-        return
 
     runtime = query.runtime
-    artifacts_dir = query.artifacts_dir
     docker = query.docker
     docker_image_tag_id = None
 
+    uv_exec = "uv.exe" if WINDOWS and not docker else "uv"
+    subproc_env = None
+
+    if not os.path.exists(uv_lock_file) and os.path.exists(pyproject_file):
+        try:
+            check_call([uv_exec, "lock"], cwd=project_path)
+        except FileNotFoundError as e:
+            raise RuntimeError(
+                f"uv must be installed and available in PATH for runtime ({runtime})"
+            ) from e
+
     if docker:
         docker_file = docker.docker_file
         docker_image = docker.docker_image
         docker_build_root = docker.docker_build_root
 
         if docker_image:
-            ok = False
-            while True:
-                output = check_output(docker_image_id_command(docker_image))
-                if output:
-                    docker_image_tag_id = output.decode().strip()
-                    log.debug(
-                        "DOCKER TAG ID: %s -> %s", docker_image, docker_image_tag_id
-                    )
-                    ok = True
-                if ok:
-                    break
+            output = (
+                check_output(docker_image_id_command(docker_image)).decode().strip()
+            )
+            if not output:
                 docker_cmd = docker_build_command(
                     build_root=docker_build_root,
                     docker_file=docker_file,
                     tag=docker_image,
                 )
                 check_call(docker_cmd)
-                ok = True
+                output = (
+                    check_output(docker_image_id_command(docker_image)).decode().strip()
+                )
+            docker_image_tag_id = output
         elif docker_file or docker_build_root:
             raise ValueError(
-                "docker_image must be specified for a custom image future references"
+                "docker_image must be specified when using docker_file or docker_build_root"
             )
 
-    working_dir = os.getcwd()
+    log.info("Installing python dependencies with uv (no editable installs)")
 
-    log.info("Installing python dependencies with uv & pip: %s", uv_lock_file)
     with tempdir(tmp_dir) as temp_dir:
+        pyproject_target = copy_file_to_target(pyproject_file, temp_dir)
 
-        def copy_file_to_target(file, temp_dir):
-            filename = os.path.basename(file)
-            target_file = os.path.join(temp_dir, filename)
-            shutil.copyfile(file, target_file)
-            return target_file
-
-        pyproject_target_file = copy_file_to_target(pyproject_file, temp_dir)
-        uv_lock_target_file = copy_file_to_target(uv_lock_file, temp_dir)
-
-        uv_exec = "uv"
-        python_exec = runtime
-        subproc_env = None
-
-        if not docker:
-            if WINDOWS:
-                uv_exec = "uv.exe"
+        uv_lock_target = None
+        if os.path.exists(uv_lock_file):
+            uv_lock_target = copy_file_to_target(uv_lock_file, temp_dir)
 
         with cd(temp_dir):
             uv_export = [
                 uv_exec,
                 "export",
-                "--frozen",
+                "--python",
+                runtime,
                 "--no-dev",
                 "-o",
                 "requirements.txt",
-            ] + uv_export_extra_args
-
-            uv_commands = [
-                uv_export,
-                [
-                    python_exec,
-                    "-m",
-                    "pip",
-                    "install",
-                    "--no-compile",
-                    "--target=.",
-                    "--requirement=requirements.txt",
-                ],
             ]
 
+            if uv_lock_target:
+                uv_export.append("--frozen")
+
+            uv_export += uv_export_extra_args
+
             if docker:
-                with_ssh_agent = docker.with_ssh_agent
-                chown_mask = "{}:{}".format(os.getuid(), os.getgid())
-                uv_commands += [["chown", "-R", chown_mask, "."]]
-                shell_commands = [shlex_join(cmd) for cmd in uv_commands]
-                shell_command = [" && ".join(shell_commands)]
+                shell_command = [
+                    " && ".join(
+                        [
+                            shlex_join(uv_export),
+                            "sed -i.bak '/^-e \\.\\$/d' requirements.txt",
+                            shlex_join(
+                                [
+                                    uv_exec,
+                                    "pip",
+                                    "install",
+                                    "--python",
+                                    runtime,
+                                    "--system",
+                                    "--no-compile",
+                                    "--target=.",
+                                    "--requirement=requirements.txt",
+                                ]
+                            ),
+                            f"chown -R {os.getuid()}:{os.getgid()} .",
+                        ]
+                    )
+                ]
+
                 check_call(
                     docker_run_command(
                         ".",
                         shell_command,
                         runtime,
                         image=docker_image_tag_id,
                         shell=True,
-                        ssh_agent=with_ssh_agent,
+                        ssh_agent=docker.with_ssh_agent,
                         docker=docker,
                     )
                 )
             else:
-                cmd_log.info(uv_commands)
-                log_handler and log_handler.flush()
-                for uv_command in uv_commands:
-                    try:
-                        if query.quiet:
-                            check_call(
-                                uv_command,
-                                env=subproc_env,
-                                stdout=subprocess.DEVNULL,
-                                stderr=subprocess.DEVNULL,
-                            )
-                        else:
-                            check_call(uv_command, env=subproc_env)
-                    except FileNotFoundError as e:
-                        raise RuntimeError(
-                            "UV executable must be installed and available in PATH "
-                            "for runtime ({})".format(runtime)
-                        ) from e
-
-        os.remove(pyproject_target_file)
-        os.remove(uv_lock_target_file)
+                check_call(uv_export, env=subproc_env)
+                strip_editable_self_dependency("requirements.txt")
+                check_call(
+                    [
+                        uv_exec,
+                        "pip",
+                        "install",
+                        "--python",
+                        runtime,
+                        "--system",
+                        "--no-compile",
+                        "--target=.",
+                        "--requirement=requirements.txt",
+                    ],
+                    env=subproc_env,
+                )
+
+        # Cleanup copied metadata
+        os.remove(pyproject_target)
+        if uv_lock_target:
+            os.remove(uv_lock_target)
 
         yield temp_dir