coiled 1.120.1.dev8__tar.gz → 1.130.2.dev11__tar.gz

{coiled-1.120.1.dev8 → coiled-1.130.2.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coiled
-Version: 1.120.1.dev8
+Version: 1.130.2.dev11
 Summary: Python client for coiled.io dask clusters
 Project-URL: Homepage, https://coiled.io
 Maintainer-email: Coiled <info@coiled.io>

{coiled-1.120.1.dev8 → coiled-1.130.2.dev11}/coiled/batch.py

@@ -17,6 +17,8 @@ def run(
     workspace: str | None = None,
     software: str | None = None,
     container: str | None = None,
+    run_on_host: bool | None = None,
+    cluster_kwargs: dict | None = None,
     env: list | dict | None = None,
     secret_env: list | dict | None = None,
     tag: list | dict | None = None,
@@ -46,7 +48,11 @@ def run(
     package_sync_strict: bool = False,
     package_sync_conda_extras: list | None = None,
     package_sync_ignore: list[str] | None = None,
+    local_upload_path: str | None = None,
+    buffers_to_upload: list[dict] | None = None,
     host_setup_script: str | None = None,
+    host_setup_script_content: str | None = None,
+    command_as_script: bool | None = None,
     ignore_container_entrypoint: bool | None = None,
     job_timeout: str | None = None,
     logger=None,
@@ -61,8 +67,12 @@ def run(
         takes a list of dictionaries, so you can specify multiple environment variables for each task.
         For example, ``[{"FOO": 1, "BAR": 2}, {"FOO": 3, "BAR": 4}]`` will pass ``FOO=1 BAR=2`` to one task and
         ``FOO=3 BAR=4`` to another.
+    buffers_to_upload
+        takes a list of dictionaries, each should have path where file should be written on VM(s)
+        relative to working directory, and ``io.BytesIO`` which provides content of file,
+        for example ``[{"relative_path": "hello.txt", "buffer": io.BytesIO(b"hello")}]``.
     """
-    if isinstance(command, str):
+    if isinstance(command, str) and not command.startswith("#!") and not command_as_script:
         command = shlex.split(command)
 
     env = dict_to_key_val_list(env)
@@ -76,6 +86,8 @@ def run(
         workspace=workspace,
         software=software,
         container=container,
+        run_on_host=run_on_host,
+        cluster_kwargs=cluster_kwargs,
         env=env,
         secret_env=secret_env,
         tag=tag,
@@ -106,7 +118,11 @@ def run(
         package_sync_strict=package_sync_strict,
         package_sync_conda_extras=package_sync_conda_extras,
         package_sync_ignore=package_sync_ignore,
+        local_upload_path=local_upload_path,
+        buffers_to_upload=buffers_to_upload,
         host_setup_script=host_setup_script,
+        host_setup_script_content=host_setup_script_content,
+        command_as_script=command_as_script,
         ignore_container_entrypoint=ignore_container_entrypoint,
         job_timeout=job_timeout,
         logger=logger,

{coiled-1.120.1.dev8 → coiled-1.130.2.dev11}/coiled/capture_environment.py

@@ -1,6 +1,4 @@
-import asyncio
 import contextlib
-import logging
 import platform
 import sys
 import typing
@@ -16,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,
@@ -36,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")
 
 
@@ -69,49 +66,53 @@ async def approximate_packages(
     architecture: ArchitectureTypesEnum = ArchitectureTypesEnum.X86_64,
     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)
-    user_conda_installed_pip = next(
-        (i for i, p in enumerate(packages) if p["name"] == "pip" and p["source"] == "conda"),
-        None,
-    )
-    if not user_conda_installed_pip:
-        # This means pip was installed by pip, or the system
-        # package manager
-        # Insert a conda version of pip to be installed first, it will
-        # then be used to install the users version of pip
-        pip = next(
-            (p for p in packages if p["name"] == "pip" and p["source"] == "pip"),
+    # Only add pip if we need it
+    if not use_uv_installer:
+        user_conda_installed_pip = next(
+            (i for i, p in enumerate(packages) if p["name"] == "pip" and p["source"] == "conda"),
             None,
         )
-        if not pip:
-            # insert a modern version and hope it does not introduce conflicts
-            packages.append({
-                "name": "pip",
-                "path": None,
-                "source": "conda",
-                "channel_url": "https://conda.anaconda.org/conda-forge/",
-                "channel": "conda-forge",
-                "subdir": "noarch",
-                "conda_name": "pip",
-                "version": "22.3.1",
-                "wheel_target": None,
-                "requested": False,
-            })
-        else:
-            # insert the users pip version and hope it exists on conda-forge
-            packages.append({
-                "name": "pip",
-                "path": None,
-                "source": "conda",
-                "channel_url": "https://conda.anaconda.org/conda-forge/",
-                "channel": "conda-forge",
-                "subdir": "noarch",
-                "conda_name": "pip",
-                "version": pip["version"],
-                "wheel_target": None,
-                "requested": True,
-            })
+        if not user_conda_installed_pip:
+            # This means pip was installed by pip, or the system
+            # package manager
+            # Insert a conda version of pip to be installed first, it will
+            # then be used to install the users version of pip
+            pip = next(
+                (p for p in packages if p["name"] == "pip" and p["source"] == "pip"),
+                None,
+            )
+            if not pip:
+                # insert a modern version and hope it does not introduce conflicts
+                packages.append({
+                    "name": "pip",
+                    "path": None,
+                    "source": "conda",
+                    "channel_url": "https://conda.anaconda.org/conda-forge/",
+                    "channel": "conda-forge",
+                    "subdir": "noarch",
+                    "conda_name": "pip",
+                    "version": "22.3.1",
+                    "wheel_target": None,
+                    "requested": False,
+                })
+            else:
+                # insert the users pip version and hope it exists on conda-forge
+                packages.append({
+                    "name": "pip",
+                    "path": None,
+                    "source": "conda",
+                    "channel_url": "https://conda.anaconda.org/conda-forge/",
+                    "channel": "conda-forge",
+                    "subdir": "noarch",
+                    "conda_name": "pip",
+                    "version": pip["version"],
+                    "wheel_target": None,
+                    "requested": True,
+                })
     coiled_selected_python = None
     if not user_conda_installed_python:
         # insert a special python package
@@ -162,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))
@@ -208,6 +211,7 @@ async def create_environment_approximation(
     progress: Optional[Progress] = None,
     architecture: ArchitectureTypesEnum = ArchitectureTypesEnum.X86_64,
     gpu_enabled: bool = False,
+    use_uv_installer: bool = True,
 ) -> typing.List[ResolvedPackageInfo]:
     packages = await scan_prefix(progress=progress)
     pip_check_errors = await check_pip_happy(progress)
@@ -237,6 +241,8 @@ async def create_environment_approximation(
         architecture=architecture,
         pip_check_errors=pip_check_errors,
         gpu_enabled=gpu_enabled,
+        use_uv_installer=use_uv_installer,
+        lockfile_path=get_lockfile(),
     )
     return result
 
@@ -259,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))
@@ -268,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 (
@@ -306,6 +315,7 @@ async def scan_and_create(
                 architecture=architecture,
                 gpu_enabled=gpu_enabled,
                 conda_extras=package_sync_conda_extras,
+                use_uv_installer=use_uv_installer,
             )
 
         if not package_sync_only:
@@ -367,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)
@@ -427,39 +438,3 @@ If you use pip, venv, uv, pixi, etc. create a new environment and then:
 
 See https://docs.coiled.io/user_guide/software/package_sync_best_practices.html
 for more best practices. If that doesn't solve your issue, please contact support@coiled.io.""")
-
-
-if __name__ == "__main__":
-    from logging import basicConfig
-
-    basicConfig(level=logging.INFO)
-
-    from rich.console import Console
-    from rich.table import Table
-
-    async def run():
-        async with CloudV2(asynchronous=True) as cloud:
-            return await create_environment_approximation(
-                cloud=cloud,
-                priorities={
-                    ("dask", "conda"): PackageLevelEnum.CRITICAL,
-                    ("twisted", "conda"): PackageLevelEnum.IGNORE,
-                    ("graphviz", "conda"): PackageLevelEnum.LOOSE,
-                    ("icu", "conda"): PackageLevelEnum.LOOSE,
-                },
-            )
-
-    result = asyncio.run(run())
-
-    table = Table(title="Packages")
-    keys = ("name", "source", "include", "client_version", "specifier", "error", "note")
-
-    for key in keys:
-        table.add_column(key)
-
-    for pkg in result:
-        row_values = [str(pkg.get(key, "")) for key in keys]
-        table.add_row(*row_values)
-    console = Console()
-    console.print(table)
-    console.print(table)

{coiled-1.120.1.dev8 → coiled-1.130.2.dev11}/coiled/cli/batch/run.py

@@ -10,12 +10,12 @@ import shlex
 
 import click
 import dask.config
-import yaml
 from dask.utils import format_bytes, format_time, parse_timedelta
 from rich.console import Console
 from rich.panel import Panel
 
 import coiled
+from coiled.cli.batch.util import load_sidecar_spec
 from coiled.cli.batch.wait import batch_job_wait
 from coiled.cli.curl import sync_request
 from coiled.cli.run import dict_from_key_val_list
@@ -196,6 +196,7 @@ def get_kwargs_from_header(f: dict, click_params: list):
         "default is to use the entrypoint (if any) set on the image."
     ),
 )
+@click.option("--run-on-host", default=None, help="Run code directly on host, not inside docker container.")
 @click.option(
     "--env",
     "-e",
@@ -472,6 +473,7 @@ def get_kwargs_from_header(f: dict, click_params: list):
         "For example, you can specify '30 minutes' or '1 hour'. Default is no timeout."
     ),
 )
+@click.option("--dask-container", default=None, type=str)
 @click.argument("command", nargs=-1, required=True)
 def batch_run_cli(ctx, **kwargs):
     """
@@ -501,6 +503,14 @@ def batch_run_cli(ctx, **kwargs):
 
 def _batch_run(default_kwargs, logger=None, from_cli=False, **kwargs) -> dict:
     command = kwargs["command"]
+    user_files = []
+
+    if isinstance(command, str) and (command.startswith("#!") or kwargs.get("command_as_script")):
+        user_files.append({
+            "path": "script",
+            "content": command,
+        })
+        command = ["script"]
 
     # Handle command as string case (e.g. `coiled batch run "python myscript.py"`)
     if len(command) == 1:
@@ -522,7 +532,6 @@ def _batch_run(default_kwargs, logger=None, from_cli=False, **kwargs) -> dict:
     # unescape escaped COILED env vars in command
     command = [part.replace("\\$COILED", "$COILED") for part in command]
 
-    user_files = []
     kwargs_from_header = None
 
     # identify implicit files referenced in commands like "python foo.py" or "foo.sh"
@@ -713,8 +722,8 @@ def _batch_run(default_kwargs, logger=None, from_cli=False, **kwargs) -> dict:
     if user_files_from_content:
         user_files.extend(user_files_from_content)
 
-    host_setup_content = None
-    if kwargs["host_setup_script"]:
+    host_setup_content = kwargs.get("host_setup_script_content")
+    if not host_setup_content and kwargs["host_setup_script"]:
         with open(kwargs["host_setup_script"]) as f:
             host_setup_content = f.read()
 
@@ -754,25 +763,11 @@ def _batch_run(default_kwargs, logger=None, from_cli=False, **kwargs) -> dict:
 
     batch_job_container = f"{kwargs['container']}!" if kwargs["ignore_container_entrypoint"] else kwargs["container"]
 
-    scheduler_sidecars = []
-    if kwargs.get("scheduler_sidecar_spec"):
-        with open(kwargs["scheduler_sidecar_spec"]) as f:
-            if kwargs["scheduler_sidecar_spec"].endswith((".yaml", ".yml")):
-                sidecar_spec = yaml.safe_load(f)
-            elif kwargs["scheduler_sidecar_spec"].endswith(".json"):
-                sidecar_spec = json.load(f)
-            else:
-                raise ValueError(f"Unknown format for {kwargs['scheduler_sidecar_spec']}, json or yaml expected.")
-
-            # support either list-like or dict-like
-            if isinstance(sidecar_spec, list):
-                scheduler_sidecars = sidecar_spec
-            if isinstance(sidecar_spec, dict):
-                scheduler_sidecars = [{"name": key, **val} for key, val in sidecar_spec.items()]
+    scheduler_sidecars = load_sidecar_spec(kwargs.get("scheduler_sidecar_spec"))
 
-            for sidecar in scheduler_sidecars:
-                # allow `image` as the key, to match docker compose spec
-                sidecar["container"] = sidecar.get("container") or sidecar.get("image")
+    dask_container = (
+        kwargs.get("dask_container") or dask.config.get("coiled.batch.dask-container", None) or "ghcr.io/dask/dask"
+    )
 
     cluster_kwargs = {
         "name": kwargs["name"],
@@ -786,7 +781,9 @@ def _batch_run(default_kwargs, logger=None, from_cli=False, **kwargs) -> dict:
         # if batch job is running in extra container, then we just need a pretty minimal dask container
         # so for now switch the default in that case to basic dask container
         # TODO would it be better to use a pre-built senv with our `cloud-env-run` container instead?
-        "container": "daskdev/dask:latest" if kwargs["container"] and not kwargs["software"] else None,
+        "container": dask_container
+        if (kwargs["container"] or kwargs.get("run_on_host")) and not kwargs["software"]
+        else None,
         "region": kwargs["region"],
         "scheduler_options": {
             "idle_timeout": "520 weeks",  # TODO allow job timeout?
@@ -807,6 +804,7 @@ def _batch_run(default_kwargs, logger=None, from_cli=False, **kwargs) -> dict:
         "package_sync_ignore": kwargs.get("package_sync_ignore"),
         "allow_cross_zone": True if kwargs["allow_cross_zone"] is None else kwargs["allow_cross_zone"],
         "scheduler_sidecars": scheduler_sidecars,
+        **(kwargs.get("cluster_kwargs") or {}),
     }
 
     # when task will run on scheduler, give it the same VM specs as worker node
@@ -842,6 +840,7 @@ def _batch_run(default_kwargs, logger=None, from_cli=False, **kwargs) -> dict:
         "pipe_to_files": bool(kwargs.get("pipe_to_files")),
         "host_setup": host_setup_content,
         "job_timeout_seconds": parse_timedelta(kwargs["job_timeout"]) if kwargs["job_timeout"] else None,
+        "run_in_container": not kwargs.get("run_on_host"),
     }
 
     with coiled.Cloud(workspace=kwargs["workspace"]) as cloud:
@@ -879,6 +878,7 @@ def _batch_run(default_kwargs, logger=None, from_cli=False, **kwargs) -> dict:
             or kwargs.get("pipe_to_files")
             or kwargs.get("input_filestore")
             or kwargs.get("output_filestore")
+            or kwargs.get("buffers_to_upload")
         ):
             fs_base_name = kwargs["name"] or f"batch-job-{job_id}"
 
@@ -899,9 +899,11 @@ def _batch_run(default_kwargs, logger=None, from_cli=False, **kwargs) -> dict:
                 {"id": out_fs["id"], "output": True, "path": "/scratch/batch/", "primary": True},
             ])
 
-            if kwargs.get("local_upload_path") or kwargs.get("local_sync_path"):
+            if kwargs.get("local_upload_path") or kwargs.get("local_sync_path") or kwargs.get("buffers_to_upload"):
                 upload_to_filestore_with_ui(
-                    fs=in_fs, local_dir=kwargs.get("local_upload_path") or kwargs.get("local_sync_path")
+                    fs=in_fs,
+                    local_dir=kwargs.get("local_upload_path") or kwargs.get("local_sync_path"),
+                    file_buffers=kwargs.get("buffers_to_upload"),
                 )
 
         # Run the job on a cluster

coiled-1.130.2.dev11/coiled/cli/batch/util.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import json
+
+import yaml
+
+
+def load_sidecar_spec(spec_path: str | None):
+    scheduler_sidecars = []
+    if spec_path:
+        with open(spec_path) as f:
+            if spec_path.endswith((".yaml", ".yml")):
+                sidecar_spec = yaml.safe_load(f)
+            elif spec_path.endswith(".json"):
+                sidecar_spec = json.load(f)
+            else:
+                raise ValueError(f"Unknown format for {spec_path}, json or yaml expected.")
+
+            # support either list-like or dict-like
+            if isinstance(sidecar_spec, list):
+                scheduler_sidecars = sidecar_spec
+            if isinstance(sidecar_spec, dict):
+                scheduler_sidecars = [{"name": key, **val} for key, val in sidecar_spec.items()]
+
+            for sidecar in scheduler_sidecars:
+                # allow `image` as the key, to match docker compose spec
+                sidecar["container"] = sidecar.get("container") or sidecar.get("image")
+    return scheduler_sidecars

{coiled-1.120.1.dev8 → coiled-1.130.2.dev11}/coiled/cli/core.py

@@ -10,6 +10,7 @@ from .env import env
 from .file import file_group
 from .hello import hello
 from .login import login
+from .mpi import mpi_group
 from .notebook import notebook_group
 from .package_sync import package_sync
 from .prefect import prefect
@@ -42,3 +43,4 @@ cli.add_command(better_logs, "logs")
 cli.add_command(hello)
 cli.add_command(hello, "quickstart")
 cli.add_command(file_group)
+cli.add_command(mpi_group, "mpi")

{coiled-1.120.1.dev8 → coiled-1.130.2.dev11}/coiled/cli/curl.py

@@ -1,3 +1,4 @@
+from json import dumps as json_dumps
 from json import loads as json_loads
 
 import click
@@ -24,7 +25,10 @@ def curl(url: str, request, data, json, json_output):
             url = f"{cloud.server}{url}"
         response = sync_request(cloud, url, method=request, data=all_data, json=json, json_output=json_output)
 
-    print(response)
+    if json_output:
+        print(json_dumps(response, indent=4))
+    else:
+        print(response)
 
 
 def sync_request(cloud, url, method, data=None, json: bool = False, json_output: bool = False):

coiled-1.130.2.dev11/coiled/cli/file.py

@@ -0,0 +1,116 @@
+import click
+
+import coiled
+from coiled.filestore import FilestoreManager
+
+from .cluster.utils import find_cluster
+from .utils import CONTEXT_SETTINGS
+
+
+@click.command(
+    context_settings=CONTEXT_SETTINGS,
+)
+@click.argument("cluster", default="", required=False)
+@click.option(
+    "--workspace",
+    default=None,
+    help="Coiled workspace (uses default workspace if not specified).",
+)
+@click.option(
+    "--filestore",
+    default=None,
+    help="Name of filestore (optional).",
+)
+@click.option(
+    "--filter",
+    "name_includes",
+    default=None,
+    help="Filter on file paths and/or names to download (optional).",
+)
+@click.option("--into", default=".")
+def download(cluster, workspace, filestore, name_includes, into):
+    if filestore:
+        filestores = FilestoreManager.get_filestore(name=filestore) or []
+        if not filestores:
+            print(f"{filestore} filestore not found")
+
+        for fs in filestores:
+            coiled.filestore.download_from_filestore_with_ui(
+                fs=fs,
+                into=into,
+                name_includes=name_includes,
+            )
+
+    else:
+        with coiled.Cloud(workspace=workspace) as cloud:
+            cluster_info = find_cluster(cloud, cluster)
+            cluster_id = cluster_info["id"]
+            attachments = FilestoreManager.get_cluster_attachments(cluster_id)
+        if not attachments:
+            print(f"No filestore found for {cluster_info['name']} ({cluster_info['id']})")
+
+        # TODO (possible enhancement) if there are multiple output filestores, let user pick which to download
+        for attachment in attachments:
+            if attachment["output"]:
+                coiled.filestore.download_from_filestore_with_ui(
+                    fs=attachment["filestore"],
+                    into=into,
+                    name_includes=name_includes,
+                )
+
+
+@click.command(
+    context_settings=CONTEXT_SETTINGS,
+)
+@click.argument("cluster", default="", required=False)
+@click.option(
+    "--workspace",
+    default=None,
+    help="Coiled workspace (uses default workspace if not specified).",
+)
+@click.option(
+    "--filestore",
+    default=None,
+    help="Name of filestore (optional).",
+)
+@click.option(
+    "--filter",
+    "name_includes",
+    default=None,
+    help="Filter on file paths and/or names to download (optional).",
+)
+def list_files(cluster, workspace, filestore, name_includes):
+    if filestore:
+        filestores = FilestoreManager.get_filestore(name=filestore) or []
+        if not filestores:
+            print(f"{filestore} filestore not found")
+
+        for fs in filestores:
+            coiled.filestore.list_files_ui(
+                fs=fs,
+                name_includes=name_includes,
+            )
+
+    else:
+        with coiled.Cloud(workspace=workspace) as cloud:
+            cluster_info = find_cluster(cloud, cluster)
+            cluster_id = cluster_info["id"]
+            attachments = FilestoreManager.get_cluster_attachments(cluster_id)
+        if not attachments:
+            print(f"No filestore found for {cluster_info['name']} ({cluster_info['id']})")
+
+        # TODO (possible enhancement) if there are multiple output filestores, let user pick which to download
+        for attachment in attachments:
+            if attachment["output"]:
+                coiled.filestore.list_files_ui(
+                    fs=attachment["filestore"],
+                    name_includes=name_includes,
+                )
+
+
+@click.group(name="file", context_settings=CONTEXT_SETTINGS)
+def file_group(): ...
+
+
+file_group.add_command(download)
+file_group.add_command(list_files, "list")

{coiled-1.120.1.dev8 → coiled-1.130.2.dev11}/coiled/cli/hello/hello.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import json
-import subprocess
 import sys
 import time
 
@@ -18,6 +16,7 @@ import coiled
 from coiled.scan import scan_prefix
 from coiled.utils import login_if_required
 
+from ..curl import sync_request
 from .examples import examples
 from .utils import PRIMARY_COLOR, Panel, console, has_macos_system_python, log_interactions
 
@@ -41,8 +40,10 @@ def needs_login():
 
 
 def get_interactions():
-    response = subprocess.check_output(["coiled", "curl", "/api/v2/interactions/user-interactions/hello"])
-    return json.loads(response, strict=False)
+    with coiled.Cloud() as cloud:
+        return sync_request(
+            cloud, url=f"{cloud.server}/api/v2/interactions/user-interactions/hello", method="get", json_output=True
+        )
 
 
 def get_already_run_examples():
@@ -294,7 +295,7 @@ Choose any computation you'd like to run:
 Yee-haw you've done all my examples 🎉  
 Now you can:
 - Try Coiled in your own use case
-- [Talk to us](https://calendly.com/d/cmph-386-cjt/coiled-help-getting-started)
+- [Ask us questions](mailto:support@coiled.io)
 - Explore the [docs](https://docs.coiled.io?utm_source=coiled-hello&utm_medium=finished) to see all the other things Coiled can do
 """),  # noqa
                     border_style="green",