coiled 1.129.3.dev13__tar.gz → 1.130.1.dev14__tar.gz

{coiled-1.129.3.dev13 → coiled-1.130.1.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coiled
-Version: 1.129.3.dev13
+Version: 1.130.1.dev14
 Summary: Python client for coiled.io dask clusters
 Project-URL: Homepage, https://coiled.io
 Maintainer-email: Coiled <info@coiled.io>

{coiled-1.129.3.dev13 → coiled-1.130.1.dev14}/coiled/capture_environment.py

@@ -14,9 +14,12 @@ from typing_extensions import Literal
 from coiled.context import track_context
 from coiled.scan import scan_prefix
 from coiled.software_utils import (
+    ANY_AVAILABLE,
+    PYTHON_VERSION,
     check_pip_happy,
     create_wheels_for_local_python,
     create_wheels_for_packages,
+    get_lockfile,
     partition_ignored_packages,
     partition_local_packages,
     partition_local_python_code_packages,
@@ -34,10 +37,6 @@ from coiled.v2.core import CloudV2
 from coiled.v2.widgets.rich import CONSOLE_WIDTH, print_rich_package_table
 from coiled.v2.widgets.util import simple_progress, use_rich_widget
 
-PYTHON_VERSION = platform.python_version_tuple()
-ANY_AVAILABLE = "ANY-AVAILABLE"
-
-
 logger = getLogger("coiled.package_sync")
 
 
@@ -68,6 +67,7 @@ async def approximate_packages(
     pip_check_errors: Optional[Dict[str, List[str]]] = None,
     gpu_enabled: bool = False,
     use_uv_installer: bool = True,
+    lockfile_path: Optional[Path] = None,
 ) -> typing.List[ResolvedPackageInfo]:
     user_conda_installed_python = next((p for p in packages if p["name"] == "python"), None)
     # Only add pip if we need it
@@ -163,6 +163,8 @@ async def approximate_packages(
             architecture=architecture,
             pip_check_errors=pip_check_errors,
             gpu_enabled=gpu_enabled,
+            lockfile_name=lockfile_path.name if lockfile_path else None,
+            lockfile_content=lockfile_path.read_text() if lockfile_path else None,
         )
     finalized_packages: typing.List[ResolvedPackageInfo] = []
     finalized_packages.extend(await create_wheels_for_local_python(local_python_code, progress=progress))
@@ -240,6 +242,7 @@ async def create_environment_approximation(
         pip_check_errors=pip_check_errors,
         gpu_enabled=gpu_enabled,
         use_uv_installer=use_uv_installer,
+        lockfile_path=get_lockfile(),
     )
     return result
 
@@ -262,7 +265,7 @@ async def scan_and_create(
 ):
     use_widget = force_rich_widget or (show_widget and use_rich_widget())
 
-    local_env_name = Path(sys.prefix).name
+    local_env_name = str(get_lockfile() or Path(sys.prefix).name)
     if use_widget:
         progress = Progress(TextColumn("[progress.description]{task.description}"), BarColumn(), TimeElapsedColumn())
         live = Live(Panel(progress, title=f"[green]Package Sync for {local_env_name}", width=CONSOLE_WIDTH))
@@ -271,6 +274,9 @@ async def scan_and_create(
         progress = None
 
     with live:
+        # We do this even with lockfiles because some early checks happen
+        # on this endpoint to prevent people getting delayed quota errors
+        # TODO: Add a lighter weight endpoint that does just these checks
         with simple_progress("Fetching latest package priorities", progress):
             logger.info(f"Resolving your local {local_env_name} Python environment...")
             async with (
@@ -371,6 +377,7 @@ async def scan_and_create(
                 # default region in declarative service create_software_environment
                 region_name=region_name,
                 use_uv_installer=use_uv_installer,
+                lockfile_path=get_lockfile(),
             )
     if use_widget:
         print_rich_package_table(packages_with_notes, packages_with_errors)

{coiled-1.129.3.dev13 → coiled-1.130.1.dev14}/coiled/core.py

@@ -924,6 +924,7 @@ class Cloud(Generic[IsAsynchronous]):
         include_local_code: bool = False,
         ignore_local_packages: List[str] | None = None,
         use_uv_installer: bool = True,
+        lockfile_path: Union[str, pathlib.Path, None] = None,
     ) -> SoftwareEnvironmentAlias | None:
         if name is None and conda is not None and isinstance(conda, dict) and "name" in conda:
             name = conda["name"]
@@ -943,8 +944,20 @@ class Cloud(Generic[IsAsynchronous]):
             raise TypeError("The build backend does not support specifying both packages and a container")
         if container and include_local_code:
             raise TypeError("The build backend does not support including local code when using a container")
-        if conda or pip:
-            senv = await create_env_spec(conda=conda, pip=pip)
+        if lockfile_path:
+            if pip or conda:
+                raise TypeError("The build backend does not support specifying both a lockfile and packages")
+            lockfile_path = pathlib.Path(lockfile_path)
+            if not lockfile_path.exists():
+                raise FileNotFoundError(f"Lockfile not found: {lockfile_path}")
+            if not lockfile_path.name.endswith(("uv.lock", "pylock.toml", "conda-lock.yml")):
+                logger.warning(
+                    "The specified lockfile does not appear to be generated by a supported tool "
+                    "(uv, pip, conda-lock). Proceeding anyway."
+                )
+
+        if conda or pip or lockfile_path:
+            senv = await create_env_spec(conda=conda, pip=pip, lockfile_path=lockfile_path)
             if include_local_code:
                 prefix = await scan_prefix()
                 packages, _ = partition_ignored_packages(
@@ -1030,6 +1043,8 @@ class Cloud(Generic[IsAsynchronous]):
         architecture: ArchitectureTypesEnum,
         pip_check_errors: Dict[str, List[str]] | None = None,
         gpu_enabled: bool = False,
+        lockfile_name: str | None = None,
+        lockfile_content: str | None = None,
     ) -> List[ApproximatePackageResult]:
         response = await self._do_request(
             "POST",
@@ -1046,6 +1061,8 @@ class Cloud(Generic[IsAsynchronous]):
                 "index_urls": get_index_urls(),
                 "pip_check_errors": pip_check_errors,
                 "gpu_enabled": gpu_enabled,
+                "lockfile_name": lockfile_name,
+                "lockfile_content": lockfile_content,
             },
         )
         if response.status >= 400:
@@ -1133,6 +1150,8 @@ class Cloud(Generic[IsAsynchronous]):
             "architecture": architecture,
             "region_name": region_name,
             "enable_experimental_installer": use_uv_installer,
+            "lockfile_content": senv.get("lockfile_content") if senv else None,
+            "lockfile_name": senv.get("lockfile_name") if senv else None,
         }
         if senv:
             payload["packages"] = senv["packages"]

{coiled-1.129.3.dev13 → coiled-1.130.1.dev14}/coiled/filestore.py

@@ -422,7 +422,7 @@ class FilestoreManagerWithoutHttp:
                             for chunk in response.iter_bytes(chunk_size=8192):
                                 f.write(chunk)
                     return  # Success, exit function
-                except (httpx.RemoteProtocolError, httpx.ReadTimeout, httpx.ConnectError) as e:
+                except (httpx.RemoteProtocolError, httpx.ReadTimeout, httpx.ConnectError, httpx.HTTPStatusError) as e:
                     if attempt < max_retries - 1:
                         wait_time = 2**attempt  # Exponential backoff: 1s, 2s, 4s
                         if verbose:

{coiled-1.129.3.dev13 → coiled-1.130.1.dev14}/coiled/pypi_conda_map.py

@@ -1,58 +1,41 @@
 # This file was auto-generated by scripts/update_pypi_conda_mapping.py
 # DO NOT MANUALLY EDIT
 PYPI_TO_CONDA = {
-    "Boruta": "boruta_py",
-    "Flask-Cors": "flask_cors",
-    "Flask-JSON": "flask_json",
-    "SoundFile": "pysoundfile",
-    "aiohttp_cors": "aiohttp-cors",
     "annoy": "python-annoy",
     "arrakis": "arrakis-python",
     "art": "ascii-art",
     "asana": "python-asana",
     "backtrace": "python-backtrace",
-    "bash_completion": "py-bash-completion",
+    "bash-completion": "py-bash-completion",
     "bilby-pipe": "bilby_pipe",
     "blis": "cython-blis",
+    "boruta": "boruta_py",
     "build": "python-build",
     "captest": "pvcaptest",
     "cdo": "python-cdo",
-    "click_config_file": "click-config-file",
     "cockroachdb": "cockroachdb-python",
-    "conda_lock": "conda-lock",
-    "conda_mirror": "conda-mirror",
     "confluent-kafka": "python-confluent-kafka",
     "coreapi": "python-coreapi",
     "coreschema": "python-coreschema",
-    "cryptography_vectors": "cryptography-vectors",
     "cufflinks": "python-cufflinks",
     "dashing": "python-dashing",
     "dask": "dask-core",
-    "data-morph-ai": "data-morph-ai",
-    "dataclasses": "dataclasses",
     "datadotworld": "datadotworld-py",
-    "datalad_container": "datalad-container",
-    "delegator.py": "delegator",
+    "delegator-py": "delegator",
     "dftd3": "dftd3-python",
     "dftd4": "dftd4-python",
-    "dials_data": "dials-data",
     "docker": "docker-py",
     "duckdb": "python-duckdb",
-    "dye_score": "dye-score",
     "eccodes": "python-eccodes",
-    "empyrical_dist": "empyrical-dist",
-    "enum34": "enum34",
     "esprima": "esprima-python",
-    "et_xmlfile": "et-xmlfile",
     "evalml": "evaml-core",
-    "exceptiongroup": "exceptiongroup",
     "extract-msg": "msg-extractor",
     "fastjsonschema": "python-fastjsonschema",
     "flair": "python-flair",
-    "flake8_nb": "flake8-nb",
+    "flask-cors": "flask_cors",
+    "flask-json": "flask_json",
     "flatbuffers": "python-flatbuffers",
     "flex": "flex-swagger",
-    "flit_core": "flit-core",
     "gnupg": "gnupg-py",
     "google": "googlesearch",
     "google-cloud-bigquery": "google-cloud-bigquery-core",
@@ -63,47 +46,32 @@ PYPI_TO_CONDA = {
     "hdfs": "python-hdfs",
     "hjson": "hjson-py",
     "htcondor": "python-htcondor",
-    "iam_units": "iam-units",
-    "ib_insync": "ib-insync",
-    "import_metadata": "import_metadata",
-    "importlib_metadata": "importlib-metadata",
+    "import-metadata": "import_metadata",
     "installer": "python-installer",
     "intake-astro": "intake-accumulo",
-    "intake_geopandas": "intake-geopandas",
-    "ioos_tools": "ioos-tools",
     "jsii": "python-jsii",
     "jupyter-client": "jupyter_client",
-    "jupyter_jaeger": "jupyter-jaeger",
-    "jupyterlab_git": "jupyterlab-git",
-    "jupyterlab_latex": "jupyterlab-latex",
     "kaleido": "python-kaleido",
     "kubernetes": "python-kubernetes",
     "libaio": "python-libaio",
     "libnacl": "libnacl-python-bindings",
     "lmdb": "python-lmdb",
     "matplotlib": "matplotlib-base",
-    "md_toc": "md-toc",
-    "message_ix": "message-ix",
     "msgpack": "msgpack-python",
     "mss": "python-mss",
-    "nbconvert_utils": "nbconvert-utils",
-    "ndarray_listener": "ndarray-listener",
     "neo": "python-neo",
     "neo4j": "neo4j-python-driver",
-    "nest_asyncio": "nest-asyncio",
     "node-semver": "python-node-semver",
     "nvidia-ml-py3": "nvidia-ml",
     "opencv-python": "opencv",
     "opencv-python-headless": "opencv",
     "ortools": "ortools-python",
     "p-astro": "p_astro",
-    "pandas_flavor": "pandas-flavor",
     "paragraph": "python-paragraph",
     "prince": "prince-factor-analysis",
     "pvlib": "pvlib-python",
     "pyqt4": "pyqt",
     "pyqt5": "pyqt",
-    "pytest_check_links": "pytest-check-links",
     "python-datamatrix": "datamatrix",
     "python-fileinspector": "fileinspector",
     "python-opencv": "opencv",
@@ -113,16 +81,12 @@ PYPI_TO_CONDA = {
     "python-qnotifications": "qnotifications",
     "pywin32": "pywin32-on-windows",
     "quantum-grove": "grove",
-    "radio_beam": "radio-beam",
     "redis": "redis-py",
     "rocketpyalpha": "rocketpy",
-    "sage_flatsurf": "sage-flatsurf",
-    "sagemaker_inference": "sagemaker-inference-toolkit",
-    "sagemaker_mxnet_training": "sagemaker_mxnet_container",
-    "scikit-build": "scikit-build",
-    "scikit-learn": "scikit-learn",
-    "setuptools_scm": "setuptools-scm",
+    "sagemaker-inference": "sagemaker-inference-toolkit",
+    "sagemaker-mxnet-training": "sagemaker_mxnet_container",
     "sounddevice": "python-sounddevice",
+    "soundfile": "pysoundfile",
     "spherical-functions": "spherical_functions",
     "sphinx-rtd-theme": "sphinx_rtd_theme",
     "stjudecloud-oliver": "oliver",
@@ -133,54 +97,37 @@ PYPI_TO_CONDA = {
     "termstyle": "python-termstyle",
     "torch": "pytorch",
     "torch-cluster": "pytorch_cluster",
+    "torch-geometric": "pytorch_geometric",
     "torch-sparse": "pytorch_sparse",
-    "torch_geometric": "pytorch_geometric",
     "trino": "trino-python-client",
-    "typing": "typing",
     "typing-extensions": "typing_extensions",
-    "useDAVE": "dave",
+    "usedave": "dave",
     "vsts": "vsts-python-api",
     "xtb": "xtb-python",
     "xxhash": "python-xxhash",
 }
 
 CONDA_TO_PYPI = {
-    "aiohttp-cors": "aiohttp_cors",
     "arrakis-python": "arrakis",
     "ascii-art": "art",
     "bilby_pipe": "bilby-pipe",
-    "boruta_py": "Boruta",
-    "click-config-file": "click_config_file",
+    "boruta_py": "boruta",
     "cockroachdb-python": "cockroachdb",
-    "conda-lock": "conda_lock",
-    "conda-mirror": "conda_mirror",
-    "cryptography-vectors": "cryptography_vectors",
     "cython-blis": "blis",
     "dask-core": "dask",
-    "data-morph-ai": "data-morph-ai",
-    "dataclasses": "dataclasses",
     "datadotworld-py": "datadotworld",
-    "datalad-container": "datalad_container",
     "datamatrix": "python-datamatrix",
-    "dave": "useDAVE",
-    "delegator": "delegator.py",
+    "dave": "usedave",
+    "delegator": "delegator-py",
     "dftd3-python": "dftd3",
     "dftd4-python": "dftd4",
-    "dials-data": "dials_data",
     "docker-py": "docker",
-    "dye-score": "dye_score",
-    "empyrical-dist": "empyrical_dist",
-    "enum34": "enum34",
     "esprima-python": "esprima",
-    "et-xmlfile": "et_xmlfile",
     "evaml-core": "evalml",
-    "exceptiongroup": "exceptiongroup",
     "fileinspector": "python-fileinspector",
-    "flake8-nb": "flake8_nb",
-    "flask_cors": "Flask-Cors",
-    "flask_json": "Flask-JSON",
+    "flask_cors": "flask-cors",
+    "flask_json": "flask-json",
     "flex-swagger": "flex",
-    "flit-core": "flit_core",
     "gnupg-py": "gnupg",
     "google-cloud-bigquery-core": "google-cloud-bigquery",
     "googlesearch": "google",
@@ -188,43 +135,28 @@ CONDA_TO_PYPI = {
     "h2o-py": "h2o",
     "h3-py": "h3",
     "hjson-py": "hjson",
-    "iam-units": "iam_units",
-    "ib-insync": "ib_insync",
-    "import_metadata": "import_metadata",
-    "importlib-metadata": "importlib_metadata",
+    "import_metadata": "import-metadata",
     "intake-accumulo": "intake-astro",
-    "intake-geopandas": "intake_geopandas",
-    "ioos-tools": "ioos_tools",
-    "jupyter-jaeger": "jupyter_jaeger",
     "jupyter_client": "jupyter-client",
-    "jupyterlab-git": "jupyterlab_git",
-    "jupyterlab-latex": "jupyterlab_latex",
     "libnacl-python-bindings": "libnacl",
     "matplotlib-base": "matplotlib",
-    "md-toc": "md_toc",
-    "message-ix": "message_ix",
     "msg-extractor": "extract-msg",
     "msgpack-python": "msgpack",
-    "nbconvert-utils": "nbconvert_utils",
-    "ndarray-listener": "ndarray_listener",
     "neo4j-python-driver": "neo4j",
-    "nest-asyncio": "nest_asyncio",
     "nvidia-ml": "nvidia-ml-py3",
     "oliver": "stjudecloud-oliver",
     "opencv": "python-opencv",
     "ortools-python": "ortools",
     "p_astro": "p-astro",
-    "pandas-flavor": "pandas_flavor",
     "prince-factor-analysis": "prince",
     "pseudorandom": "python-pseudorandom",
     "pvcaptest": "captest",
     "pvlib-python": "pvlib",
-    "py-bash-completion": "bash_completion",
+    "py-bash-completion": "bash-completion",
     "pygaze": "python-pygaze",
     "pyqt": "pyqt5",
-    "pysoundfile": "SoundFile",
+    "pysoundfile": "soundfile",
     "pytables": "tables",
-    "pytest-check-links": "pytest_check_links",
     "python-annoy": "annoy",
     "python-asana": "asana",
     "python-backtrace": "backtrace",
@@ -261,25 +193,19 @@ CONDA_TO_PYPI = {
     "python-xxhash": "xxhash",
     "pytorch": "torch",
     "pytorch_cluster": "torch-cluster",
-    "pytorch_geometric": "torch_geometric",
+    "pytorch_geometric": "torch-geometric",
     "pytorch_sparse": "torch-sparse",
     "pywin32-on-windows": "pywin32",
     "qdatamatrix": "python-qdatamatrix",
     "qnotifications": "python-qnotifications",
-    "radio-beam": "radio_beam",
     "redis-py": "redis",
     "rocketpy": "rocketpyalpha",
-    "sage-flatsurf": "sage_flatsurf",
-    "sagemaker-inference-toolkit": "sagemaker_inference",
-    "sagemaker_mxnet_container": "sagemaker_mxnet_training",
-    "scikit-build": "scikit-build",
-    "scikit-learn": "scikit-learn",
-    "setuptools-scm": "setuptools_scm",
+    "sagemaker-inference-toolkit": "sagemaker-inference",
+    "sagemaker_mxnet_container": "sagemaker-mxnet-training",
     "spherical_functions": "spherical-functions",
     "sphinx_rtd_theme": "sphinx-rtd-theme",
     "tblite-python": "tblite",
     "trino-python-client": "trino",
-    "typing": "typing",
     "typing_extensions": "typing-extensions",
     "vsts-python-api": "vsts",
     "xtb-python": "xtb",

{coiled-1.129.3.dev13 → coiled-1.130.1.dev14}/coiled/software.py

@@ -118,6 +118,9 @@ def parse_pip(pip: Union[List[str], str, Path]) -> Tuple[List[PackageSchema], Li
         if req["is_editable"]:
             logger.warning(f"Editable requirement {raw_line!r} is not supported and will be ignored")
             continue
+        if req.get("is_local_path", False):
+            logger.warning(f"Local path requirement {raw_line!r} is not supported and will be ignored")
+            continue
         if req["is_vcs_url"]:
             raw_pip.append(raw_line)
             continue
@@ -139,10 +142,22 @@ def parse_pip(pip: Union[List[str], str, Path]) -> Tuple[List[PackageSchema], Li
 async def create_env_spec(
     conda: Union[CondaEnvSchema, str, Path, list, None] = None,
     pip: Union[List[str], str, Path, None] = None,
+    lockfile_path: Union[str, Path, None] = None,
 ) -> SoftwareEnvSpec:
-    if not conda and not pip:
-        raise TypeError("Either or both of conda/pip kwargs must be specified")
-    spec: SoftwareEnvSpec = {"packages": [], "raw_conda": None, "raw_pip": None}
+    if not conda and not pip and not lockfile_path:
+        raise TypeError("At least one of the conda, pip, and lockfile_path kwargs must be specified")
+    spec: SoftwareEnvSpec = {
+        "packages": [],
+        "raw_conda": None,
+        "raw_pip": None,
+        "lockfile_name": None,
+        "lockfile_content": None,
+    }
+    if lockfile_path:
+        lockfile_path = Path(lockfile_path)
+        lockfile_content = lockfile_path.read_text()
+        spec["lockfile_name"] = lockfile_path.name
+        spec["lockfile_content"] = lockfile_content
     if conda:
         packages, raw_conda, raw_pip = parse_conda(conda)
         spec["raw_conda"] = raw_conda

{coiled-1.129.3.dev13 → coiled-1.130.1.dev14}/coiled/software_utils.py

@@ -477,11 +477,10 @@ async def check_pip_happy(progress: Progress | None = None) -> Dict[str, List[st
         return faulty_packages
 
 
-def _load_toml(path: Union[Path, str]) -> Dict:
+def _find_file_in_hierarchy(path: Union[Path, str]) -> Path | None:
     path = Path(path)
     filename = path.name
     dir_path = safe_path_resolve(path.parent)
-    toml_dict = {}
     # Walk up the directory tree to find the first toml file (up to 10 levels above)
     for _ in range(10):
         path = dir_path / filename
@@ -490,13 +489,21 @@ def _load_toml(path: Union[Path, str]) -> Dict:
                 break
             dir_path = dir_path.parent
             continue
-        try:
-            with path.open() as f:
-                toml_dict = toml.load(f)
-        except (toml.TomlDecodeError, FileNotFoundError, IndexError) as e:
-            logger.debug(f"Failed to load {path}: {e}", exc_info=True)
-        break
-    return toml_dict
+        return path
+    return None
+
+
+def _load_toml(path: Union[Path, str]) -> Dict:
+    resolved_path = _find_file_in_hierarchy(path)
+    if not resolved_path:
+        logger.debug(f"Failed to find {path}")
+        return {}
+    try:
+        with resolved_path.open() as f:
+            return toml.load(f)
+    except Exception as e:
+        logger.debug(f"Failed to load {path}: {e}", exc_info=True)
+    return {}
 
 
 def _get_pip_index_urls() -> List[str]:
@@ -1041,3 +1048,12 @@ def make_coiled_local_name(dirname: str):
     if not cleaned_name:
         cleaned_name = "rootdir"
     return COILED_LOCAL_PACKAGE_PREFIX + cleaned_name
+
+
+def get_lockfile() -> Path | None:
+    """Search for a supported lockfile and return its path"""
+    # TODO: Add support for other lockfiles
+    lockfile = None
+    if dask.config.get("coiled.package_sync.use_lockfile.uv", True):
+        lockfile = _find_file_in_hierarchy("uv.lock")
+    return lockfile

{coiled-1.129.3.dev13 → coiled-1.130.1.dev14}/coiled/types.py

@@ -154,6 +154,8 @@ class SoftwareEnvSpec(TypedDict):
     packages: List[PackageSchema]
     raw_pip: Optional[List[str]]
     raw_conda: Optional[CondaEnvSchema]
+    lockfile_name: Optional[str]
+    lockfile_content: Optional[str]
 
 
 # KNOWN_SUBDIRS is copied from conda's known subdirs

{coiled-1.129.3.dev13 → coiled-1.130.1.dev14}/coiled/v2/core.py

@@ -7,6 +7,7 @@ import logging
 import time
 import weakref
 from collections import namedtuple
+from pathlib import Path
 from typing import (
     Awaitable,
     Callable,
@@ -523,6 +524,7 @@ class CloudV2(OldCloud, Generic[IsAsynchronous]):
         architecture: ArchitectureTypesEnum = ArchitectureTypesEnum.X86_64,
         region_name: str | None = None,
         use_uv_installer: bool = True,
+        lockfile_path: str | Path | None = None,
     ) -> SoftwareEnvironmentAlias:
         workspace = workspace or self.default_workspace
         prepared_packages: List[PackageSchema] = []
@@ -547,12 +549,20 @@ class CloudV2(OldCloud, Generic[IsAsynchronous]):
                 "client_version": pkg["client_version"],
                 "file": file_id,
             })
-        with simple_progress("Requesting package sync build", progress=progress):
+        lockfile_content = None
+        if lockfile_path:
+            lockfile_path = Path(lockfile_path)
+            lockfile_content = lockfile_path.read_text()
+        with simple_progress(
+            "Requesting package sync build" if not lockfile_path else "Creating software environment", progress=progress
+        ):
             result = await self._create_software_environment_v2(
                 senv={
                     "packages": prepared_packages,
                     "raw_pip": None,
                     "raw_conda": None,
+                    "lockfile_name": str(lockfile_path.name) if lockfile_path else None,
+                    "lockfile_content": lockfile_content,
                 },
                 workspace=workspace,
                 architecture=architecture,

{coiled-1.129.3.dev13 → coiled-1.130.1.dev14}/coiled/v2/widgets/rich.py

@@ -22,6 +22,7 @@ import rich.progress
 import rich.table
 from rich.console import RenderableType
 
+from coiled.software_utils import get_lockfile
 from coiled.types import PackageLevelEnum
 
 from ...capture_environment import ResolvedPackageInfo
@@ -289,7 +290,7 @@ class LightRichClusterWidget(ClusterWidget):
             env_name = self._cluster_details["senv_alias"]["name"]
             if env_name.startswith("package-sync-"):
                 env_name = ""
-                local_env_name = Path(sys.prefix).name
+                local_env_name = str(get_lockfile() or Path(sys.prefix).name)
                 env_line = f"[bold green]Synced local Python environment:[/bold green] {local_env_name}"
             else:
                 local_env_name = ""