metaflow 2.15.7__py2.py3-none-any.whl → 2.15.8__py2.py3-none-any.whl

metaflow/cli.py

@@ -17,6 +17,7 @@ from .flowspec import _FlowState
 from .graph import FlowGraph
 from .metaflow_config import (
     DEFAULT_DATASTORE,
+    DEFAULT_DECOSPECS,
     DEFAULT_ENVIRONMENT,
     DEFAULT_EVENT_LOGGER,
     DEFAULT_METADATA,
@@ -509,9 +510,16 @@ def start(
     ):
         # run/resume are special cases because they can add more decorators with --with,
         # so they have to take care of themselves.
+
         all_decospecs = ctx.obj.tl_decospecs + list(
             ctx.obj.environment.decospecs() or []
         )
+
+        # We add the default decospecs for everything except init and step since in those
+        # cases, the decospecs will already have been handled by either a run/resume
+        # or a scheduler setting them up in their own way.
+        if ctx.saved_args[0] not in ("step", "init"):
+            all_decospecs += DEFAULT_DECOSPECS.split()
         if all_decospecs:
             decorators._attach_decorators(ctx.obj.flow, all_decospecs)
             decorators._init(ctx.obj.flow)

metaflow/cli_components/run_cmds.py

@@ -71,7 +71,7 @@ def write_file(file_path, content):
             f.write(str(content))
 
 
-def config_merge_cb(ctx, param, value):
+def config_callback(ctx, param, value):
     # Callback to:
     #  - read  the Click auto_envvar variable from both the
     #    environment AND the configuration
@@ -127,7 +127,7 @@ def common_run_options(func):
         help="Add a decorator to all steps. You can specify this "
         "option multiple times to attach multiple decorators "
         "in steps.",
-        callback=config_merge_cb,
+        callback=config_callback,
     )
     @click.option(
         "--run-id-file",

metaflow/cmd/main_cli.py

@@ -94,7 +94,7 @@ def start(ctx):
         echo("(%s)\n" % version, fg="magenta", bold=False)
 
     if ctx.invoked_subcommand is None:
-        echo("More data science, less engineering\n", fg="magenta")
+        echo("More AI, less engineering\n", fg="magenta")
 
         lnk_sz = max(len(lnk) for lnk in CONTACT_INFO.values()) + 1
         for what, lnk in CONTACT_INFO.items():

metaflow/metadata_provider/metadata.py

@@ -630,6 +630,20 @@ class MetadataProvider(object):
             sys_info["r_version"] = env["r_version_code"]
         return sys_info
 
+    def _get_git_info_as_dict(self):
+        git_info = {}
+        env = self._environment.get_environment_info()
+        for key in [
+            "repo_url",
+            "branch_name",
+            "commit_sha",
+            "has_uncommitted_changes",
+        ]:
+            if key in env and env[key]:
+                git_info[key] = env[key]
+
+        return git_info
+
     def _get_system_tags(self):
         """Convert system info dictionary into a list of system tags"""
         return [
@@ -670,6 +684,27 @@ class MetadataProvider(object):
                     tags=["attempt_id:{0}".format(attempt)],
                 )
             )
+        # Add script name as metadata
+        script_name = self._environment.get_environment_info()["script"]
+        metadata.append(
+            MetaDatum(
+                field="script-name",
+                value=script_name,
+                type="script-name",
+                tags=["attempt_id:{0}".format(attempt)],
+            )
+        )
+        # And add git metadata
+        git_info = self._get_git_info_as_dict()
+        if git_info:
+            metadata.append(
+                MetaDatum(
+                    field="git-info",
+                    value=json.dumps(git_info),
+                    type="git-info",
+                    tags=["attempt_id:{0}".format(attempt)],
+                )
+            )
         if metadata:
             self.register_metadata(run_id, step_name, task_id, metadata)
 

metaflow/metaflow_config.py

@@ -109,6 +109,12 @@ S3_WORKER_COUNT = from_conf("S3_WORKER_COUNT", 64)
 # top-level retries)
 S3_TRANSIENT_RETRY_COUNT = from_conf("S3_TRANSIENT_RETRY_COUNT", 20)
 
+# S3 retry configuration used in the aws client
+# Use the adaptive retry strategy by default
+S3_CLIENT_RETRY_CONFIG = from_conf(
+    "S3_CLIENT_RETRY_CONFIG", {"max_attempts": 10, "mode": "adaptive"}
+)
+
 # Threshold to start printing warnings for an AWS retry
 RETRY_WARNING_THRESHOLD = 3
 

metaflow/metaflow_environment.py

@@ -4,6 +4,7 @@ import sys
 
 from .util import get_username
 from . import metaflow_version
+from . import metaflow_git
 from metaflow.exception import MetaflowException
 from metaflow.extension_support import dump_module_info
 from metaflow.mflog import BASH_MFLOG, BASH_FLUSH_LOGS
@@ -197,6 +198,10 @@ class MetaflowEnvironment(object):
             "python_version_code": "%d.%d.%d" % sys.version_info[:3],
             "metaflow_version": metaflow_version.get_version(),
             "script": os.path.basename(os.path.abspath(sys.argv[0])),
+            # Add git info
+            **metaflow_git.get_repository_info(
+                path=os.path.dirname(os.path.abspath(sys.argv[0]))
+            ),
         }
         if R.use_r():
             env["metaflow_r_version"] = R.metaflow_r_version()
@@ -206,7 +211,7 @@ class MetaflowEnvironment(object):
             # Information about extension modules (to load them in the proper order)
             ext_key, ext_val = dump_module_info()
             env[ext_key] = ext_val
-        return env
+        return {k: v for k, v in env.items() if v is not None and v != ""}
 
     def executable(self, step_name, default=None):
         if default is not None:

metaflow/metaflow_git.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python
+"""Get git repository information for the package
+
+Functions to retrieve git repository details like URL, branch name, 
+and commit SHA for Metaflow code provenance tracking.
+"""
+
+import os
+import subprocess
+from typing import Dict, List, Optional, Tuple, Union
+
+# Cache for git information to avoid repeated subprocess calls
+_git_info_cache = None
+
+__all__ = ("get_repository_info",)
+
+
+def _call_git(
+    args: List[str], path=Union[str, os.PathLike]
+) -> Tuple[Optional[str], Optional[int], bool]:
+    """
+    Call git with provided args.
+
+    Returns
+    -------
+        tuple : Tuple containing
+            (stdout, exitcode, failure) of the call
+    """
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return result.stdout.strip(), result.returncode, False
+    except (OSError, subprocess.SubprocessError):
+        # Covers subprocess timeouts and other errors which would not lead to an exit code
+        return None, None, True
+
+
+def _get_repo_url(path: Union[str, os.PathLike]) -> Optional[str]:
+    """Get the repository URL from git config"""
+    stdout, returncode, _failed = _call_git(
+        ["config", "--get", "remote.origin.url"], path
+    )
+    if returncode == 0:
+        url = stdout
+        # Convert SSH URLs to HTTPS for clickable links
+        if url.startswith("git@"):
+            parts = url.split(":", 1)
+            if len(parts) == 2:
+                domain = parts[0].replace("git@", "")
+                repo_path = parts[1]
+                url = f"https://{domain}/{repo_path}"
+        return url
+    return None
+
+
+def _get_branch_name(path: Union[str, os.PathLike]) -> Optional[str]:
+    """Get the current git branch name"""
+    stdout, returncode, _failed = _call_git(["rev-parse", "--abbrev-ref", "HEAD"], path)
+    return stdout if returncode == 0 else None
+
+
+def _get_commit_sha(path: Union[str, os.PathLike]) -> Optional[str]:
+    """Get the current git commit SHA"""
+    stdout, returncode, _failed = _call_git(["rev-parse", "HEAD"], path)
+    return stdout if returncode == 0 else None
+
+
+def _is_in_git_repo(path: Union[str, os.PathLike]) -> bool:
+    """Check if we're currently in a git repository"""
+    stdout, returncode, _failed = _call_git(
+        ["rev-parse", "--is-inside-work-tree"], path
+    )
+    return returncode == 0 and stdout == "true"
+
+
+def _has_uncommitted_changes(path: Union[str, os.PathLike]) -> Optional[bool]:
+    """Check if the git repository has uncommitted changes"""
+    _stdout, returncode, failed = _call_git(
+        ["diff-index", "--quiet", "HEAD", "--"], path
+    )
+    if failed:
+        return None
+    return returncode != 0
+
+
+def get_repository_info(path: Union[str, os.PathLike]) -> Dict[str, Union[str, bool]]:
+    """Get git repository information for a path
+
+    Returns:
+        dict: Dictionary containing:
+            repo_url: Repository URL (converted to HTTPS if from SSH)
+            branch_name: Current branch name
+            commit_sha: Current commit SHA
+            has_uncommitted_changes: Boolean indicating if there are uncommitted changes
+    """
+    global _git_info_cache
+
+    if _git_info_cache is not None:
+        return _git_info_cache
+
+    _git_info_cache = {}
+    if _is_in_git_repo(path):
+        _git_info_cache = {
+            "repo_url": _get_repo_url(path),
+            "branch_name": _get_branch_name(path),
+            "commit_sha": _get_commit_sha(path),
+            "has_uncommitted_changes": _has_uncommitted_changes(path),
+        }
+
+    return _git_info_cache

metaflow/metaflow_version.py

@@ -27,11 +27,11 @@ if name == "nt":
         """find the path to the git executable on Windows"""
         # first see if git is in the path
         try:
-            check_output(["where", "/Q", "git"])
+            subprocess.check_output(["where", "/Q", "git"])
             # if this command succeeded, git is in the path
             return "git"
         # catch the exception thrown if git was not found
-        except CalledProcessError:
+        except subprocess.CalledProcessError:
             pass
         # There are several locations where git.exe may be hiding
         possible_locations = []

metaflow/plugins/__init__.py

@@ -75,6 +75,7 @@ FLOW_DECORATORS_DESC = [
 ENVIRONMENTS_DESC = [
     ("conda", ".pypi.conda_environment.CondaEnvironment"),
     ("pypi", ".pypi.pypi_environment.PyPIEnvironment"),
+    ("uv", ".uv.uv_environment.UVEnvironment"),
 ]
 
 # Add metadata providers here

metaflow/plugins/argo/argo_workflows.py

@@ -7,6 +7,7 @@ import sys
 from collections import defaultdict
 from hashlib import sha1
 from math import inf
+from typing import List
 
 from metaflow import JSONType, current
 from metaflow.decorators import flow_decorators
@@ -110,6 +111,7 @@ class ArgoWorkflows(object):
         notify_pager_duty_integration_key=None,
         notify_incident_io_api_key=None,
         incident_io_alert_source_config_id=None,
+        incident_io_metadata: List[str] = None,
         enable_heartbeat_daemon=True,
         enable_error_msg_capture=False,
     ):
@@ -161,6 +163,9 @@ class ArgoWorkflows(object):
         self.notify_pager_duty_integration_key = notify_pager_duty_integration_key
         self.notify_incident_io_api_key = notify_incident_io_api_key
         self.incident_io_alert_source_config_id = incident_io_alert_source_config_id
+        self.incident_io_metadata = self.parse_incident_io_metadata(
+            incident_io_metadata
+        )
         self.enable_heartbeat_daemon = enable_heartbeat_daemon
         self.enable_error_msg_capture = enable_error_msg_capture
         self.parameters = self._process_parameters()
@@ -287,6 +292,21 @@ class ArgoWorkflows(object):
 
         return True
 
+    @staticmethod
+    def parse_incident_io_metadata(metadata: List[str] = None):
+        "parse key value pairs into a dict for incident.io metadata if given"
+        parsed_metadata = None
+        if metadata is not None:
+            parsed_metadata = {}
+            for kv in metadata:
+                key, value = kv.split("=", 1)
+                if key in parsed_metadata:
+                    raise MetaflowException(
+                        "Incident.io Metadata *%s* provided multiple times" % key
+                    )
+                parsed_metadata[key] = value
+        return parsed_metadata
+
     @classmethod
     def trigger(cls, name, parameters=None):
         if parameters is None:
@@ -2552,9 +2572,12 @@ class ArgoWorkflows(object):
                             else None
                         ),
                         "metadata": {
-                            "run_status": "failed",
-                            "flow_name": self.flow.name,
-                            "run_id": "argo-{{workflow.name}}",
+                            **(self.incident_io_metadata or {}),
+                            **{
+                                "run_status": "failed",
+                                "flow_name": self.flow.name,
+                                "run_id": "argo-{{workflow.name}}",
+                            },
                         },
                     }
                 )
@@ -2603,9 +2626,12 @@ class ArgoWorkflows(object):
                             else None
                         ),
                         "metadata": {
-                            "run_status": "succeeded",
-                            "flow_name": self.flow.name,
-                            "run_id": "argo-{{workflow.name}}",
+                            **(self.incident_io_metadata or {}),
+                            **{
+                                "run_status": "succeeded",
+                                "flow_name": self.flow.name,
+                                "run_id": "argo-{{workflow.name}}",
+                            },
                         },
                     }
                 )

metaflow/plugins/argo/argo_workflows_cli.py

@@ -187,6 +187,13 @@ def argo_workflows(obj, name=None):
     default=None,
     help="Incident.io Alert source config ID. Example '01GW2G3V0S59R238FAHPDS1R66'",
 )
+@click.option(
+    "--incident-io-metadata",
+    default=None,
+    type=str,
+    multiple=True,
+    help="Incident.io Alert Custom Metadata field in the form of Key=Value",
+)
 @click.option(
     "--enable-heartbeat-daemon/--no-enable-heartbeat-daemon",
     default=False,
@@ -226,6 +233,7 @@ def create(
     notify_pager_duty_integration_key=None,
     notify_incident_io_api_key=None,
     incident_io_alert_source_config_id=None,
+    incident_io_metadata=None,
     enable_heartbeat_daemon=True,
     deployer_attribute_file=None,
     enable_error_msg_capture=False,
@@ -283,6 +291,7 @@ def create(
         notify_pager_duty_integration_key,
         notify_incident_io_api_key,
         incident_io_alert_source_config_id,
+        incident_io_metadata,
         enable_heartbeat_daemon,
         enable_error_msg_capture,
     )
@@ -459,6 +468,7 @@ def make_flow(
     notify_pager_duty_integration_key,
     notify_incident_io_api_key,
     incident_io_alert_source_config_id,
+    incident_io_metadata,
     enable_heartbeat_daemon,
     enable_error_msg_capture,
 ):
@@ -538,6 +548,7 @@ def make_flow(
         notify_pager_duty_integration_key=notify_pager_duty_integration_key,
         notify_incident_io_api_key=notify_incident_io_api_key,
         incident_io_alert_source_config_id=incident_io_alert_source_config_id,
+        incident_io_metadata=incident_io_metadata,
         enable_heartbeat_daemon=enable_heartbeat_daemon,
         enable_error_msg_capture=enable_error_msg_capture,
     )

metaflow/plugins/aws/aws_client.py

@@ -14,6 +14,7 @@ class Boto3ClientProvider(object):
             AWS_SANDBOX_ENABLED,
             AWS_SANDBOX_STS_ENDPOINT_URL,
             AWS_SANDBOX_API_KEY,
+            S3_CLIENT_RETRY_CONFIG,
         )
 
         if session_vars is None:
@@ -37,10 +38,10 @@ class Boto3ClientProvider(object):
         if module == "s3" and (
             "config" not in client_params or client_params["config"].retries is None
         ):
-            # Use the adaptive retry strategy by default -- do not set anything if
-            # the user has already set something
+            # do not set anything if the user has already set something
             config = client_params.get("config", Config())
-            config.retries = {"max_attempts": 10, "mode": "adaptive"}
+            config.retries = S3_CLIENT_RETRY_CONFIG
+            client_params["config"] = config
 
         if AWS_SANDBOX_ENABLED:
             # role is ignored in the sandbox

metaflow/plugins/datatools/s3/s3.py

@@ -18,6 +18,7 @@ from metaflow.metaflow_config import (
     S3_RETRY_COUNT,
     S3_TRANSIENT_RETRY_COUNT,
     S3_SERVER_SIDE_ENCRYPTION,
+    S3_WORKER_COUNT,
     TEMPDIR,
 )
 from metaflow.util import (
@@ -1390,9 +1391,31 @@ class S3(object):
         )
 
     # add some jitter to make sure retries are not synchronized
-    def _jitter_sleep(self, trynum, multiplier=2):
-        interval = multiplier**trynum + random.randint(0, 10)
-        time.sleep(interval)
+    def _jitter_sleep(
+        self, trynum: int, base: int = 2, cap: int = 360, jitter: float = 0.1
+    ) -> None:
+        """
+        Sleep for an exponentially increasing interval with added jitter.
+
+        Parameters
+        ----------
+        trynum: The current retry attempt number.
+        base: The base multiplier for the exponential backoff.
+        cap: The maximum interval to sleep.
+        jitter: The maximum jitter percentage to add to the interval.
+        """
+        # Calculate the exponential backoff interval
+        interval = min(cap, base**trynum)
+
+        # Add random jitter
+        jitter_value = interval * jitter * random.uniform(-1, 1)
+        interval_with_jitter = interval + jitter_value
+
+        # Ensure the interval is not negative
+        interval_with_jitter = max(0, interval_with_jitter)
+
+        # Sleep for the calculated interval
+        time.sleep(interval_with_jitter)
 
     # NOTE: re: _read_many_files and _put_many_files
     # All file IO is through binary files - we write bytes, we read
@@ -1480,20 +1503,17 @@ class S3(object):
         #    - a known transient failure (SlowDown for example) in which case we will
         #      retry *only* the inputs that have this transient failure.
         #    - an unknown failure (something went wrong but we cannot say if it was
-        #      a known permanent failure or something else). In this case, we retry
-        #      the operation completely.
-        #
-        # There are therefore two retry counts:
-        #  - the transient failure retry count: how many times do we try on known
-        #    transient errors
-        #  - the top-level retry count: how many times do we try on unknown failures
+        #      a known permanent failure or something else). In this case, we assume
+        #      it's a transient failure and retry only those inputs (same as above).
         #
-        # Note that, if the operation runs out of transient failure retries, it will
-        # count as an "unknown" failure (ie: it will be retried according to the
-        # outer top-level retry count). In other words, you can potentially have
-        # transient_retry_count * retry_count tries).
-        # Finally, if on transient failures, we make NO progress (ie: no input is
-        # successfully processed), that counts as an "unknown" failure.
+        # NOTES(npow): 2025-05-13
+        # Previously, this code would also retry the fatal failures, including no_progress
+        # and unknown failures, from the beginning. This is not ideal because:
+        # 1. Fatal errors are not supposed to be retried.
+        # 2. Retrying from the beginning does not improve the situation, and is
+        #    wasteful since we have already uploaded some files.
+        # 3. The number of transient errors is far more than fatal errors, so we
+        #    can be optimistic and assume the unknown errors are transient.
         cmdline = [sys.executable, os.path.abspath(s3op.__file__), mode]
         recursive_get = False
         for key, value in options.items():
@@ -1528,7 +1548,6 @@ class S3(object):
             # Otherwise, we cap the failure rate at 90%
             return min(90, self._s3_inject_failures)
 
-        retry_count = 0  # Number of retries (excluding transient failures)
         transient_retry_count = 0  # Number of transient retries (per top-level retry)
         inject_failures = _inject_failure_rate()
         out_lines = []  # List to contain the lines returned by _s3op_with_retries
@@ -1595,7 +1614,12 @@ class S3(object):
                         # things, this will shrink more and more until we are doing a
                         # single operation at a time. If things start going better, it
                         # will increase by 20% every round.
-                        max_count = min(int(last_ok_count * 1.2), len(pending_retries))
+                        #
+                        # If we made no progress (last_ok_count == 0) we retry at most
+                        # 2*S3_WORKER_COUNT from whatever is left in `pending_retries`
+                        max_count = min(
+                            int(last_ok_count * 1.2), len(pending_retries)
+                        ) or min(2 * S3_WORKER_COUNT, len(pending_retries))
                         tmp_input.writelines(pending_retries[:max_count])
                         tmp_input.flush()
                         debug.s3client_exec(
@@ -1712,38 +1736,16 @@ class S3(object):
                         _update_out_lines(out_lines, ok_lines, resize=loop_count == 0)
                         return 0, 0, inject_failures, err_out
 
-        while retry_count <= S3_RETRY_COUNT:
+        while transient_retry_count <= S3_TRANSIENT_RETRY_COUNT:
             (
                 last_ok_count,
                 last_retry_count,
                 inject_failures,
                 err_out,
             ) = try_s3_op(last_ok_count, pending_retries, out_lines, inject_failures)
-            if err_out or (
-                last_retry_count != 0
-                and (
-                    last_ok_count == 0
-                    or transient_retry_count > S3_TRANSIENT_RETRY_COUNT
-                )
-            ):
-                # We had a fatal failure (err_out is not None)
-                # or we made no progress (last_ok_count is 0)
-                # or we are out of transient retries
-                # so we will restart from scratch (being very conservative)
-                retry_count += 1
-                err_msg = err_out
-                if err_msg is None and last_ok_count == 0:
-                    err_msg = "No progress"
-                if err_msg is None:
-                    err_msg = "Too many transient errors"
-                print(
-                    "S3 non-transient error (attempt #%d): %s" % (retry_count, err_msg)
-                )
-                _reset()
-                if retry_count <= S3_RETRY_COUNT:
-                    self._jitter_sleep(retry_count)
-                continue
-            elif last_retry_count != 0:
+            if err_out:
+                break
+            if last_retry_count != 0:
                 # During our last try, we did not manage to process everything we wanted
                 # due to a transient failure so we try again.
                 transient_retry_count += 1

metaflow/plugins/datatools/s3/s3op.py

@@ -15,7 +15,10 @@ from tempfile import NamedTemporaryFile
 from multiprocessing import Process, Queue
 from itertools import starmap, chain, islice
 
+from boto3.exceptions import RetriesExceededError, S3UploadFailedError
 from boto3.s3.transfer import TransferConfig
+from botocore.config import Config
+from botocore.exceptions import ClientError, SSLError
 
 try:
     # python2
@@ -46,13 +49,21 @@ from metaflow.plugins.datatools.s3.s3util import (
 import metaflow.tracing as tracing
 from metaflow.metaflow_config import (
     S3_WORKER_COUNT,
+    S3_CLIENT_RETRY_CONFIG,
 )
 
 DOWNLOAD_FILE_THRESHOLD = 2 * TransferConfig().multipart_threshold
 DOWNLOAD_MAX_CHUNK = 2 * 1024 * 1024 * 1024 - 1
 
+DEFAULT_S3_CLIENT_PARAMS = {"config": Config(retries=S3_CLIENT_RETRY_CONFIG)}
 RANGE_MATCH = re.compile(r"bytes (?P<start>[0-9]+)-(?P<end>[0-9]+)/(?P<total>[0-9]+)")
 
+# from botocore ClientError MSG_TEMPLATE:
+# https://github.com/boto/botocore/blob/68ca78f3097906c9231840a49931ef4382c41eea/botocore/exceptions.py#L521
+BOTOCORE_MSG_TEMPLATE_MATCH = re.compile(
+    r"An error occurred \((\w+)\) when calling the (\w+) operation.*: (.+)"
+)
+
 S3Config = namedtuple("S3Config", "role session_vars client_params")
 
 
@@ -147,6 +158,7 @@ def normalize_client_error(err):
             "LimitExceededException",
             "RequestThrottled",
             "EC2ThrottledException",
+            "InternalError",
         ):
             return 503
     return error_code
@@ -221,54 +233,57 @@ def worker(result_file_name, queue, mode, s3config):
                 elif mode == "download":
                     tmp = NamedTemporaryFile(dir=".", mode="wb", delete=False)
                     try:
-                        if url.range:
-                            resp = s3.get_object(
-                                Bucket=url.bucket, Key=url.path, Range=url.range
-                            )
-                            range_result = resp["ContentRange"]
-                            range_result_match = RANGE_MATCH.match(range_result)
-                            if range_result_match is None:
-                                raise RuntimeError(
-                                    "Wrong format for ContentRange: %s"
-                                    % str(range_result)
+                        try:
+                            if url.range:
+                                resp = s3.get_object(
+                                    Bucket=url.bucket, Key=url.path, Range=url.range
                                 )
-                            range_result = {
-                                x: int(range_result_match.group(x))
-                                for x in ["total", "start", "end"]
-                            }
-                        else:
-                            resp = s3.get_object(Bucket=url.bucket, Key=url.path)
-                            range_result = None
-                        sz = resp["ContentLength"]
-                        if range_result is None:
-                            range_result = {"total": sz, "start": 0, "end": sz - 1}
-                        if not url.range and sz > DOWNLOAD_FILE_THRESHOLD:
-                            # In this case, it is more efficient to use download_file as it
-                            # will download multiple parts in parallel (it does it after
-                            # multipart_threshold)
-                            s3.download_file(url.bucket, url.path, tmp.name)
-                        else:
-                            read_in_chunks(tmp, resp["Body"], sz, DOWNLOAD_MAX_CHUNK)
-                        tmp.close()
-                        os.rename(tmp.name, url.local)
-                    except client_error as err:
-                        tmp.close()
-                        os.unlink(tmp.name)
-                        error_code = normalize_client_error(err)
-                        if error_code == 404:
-                            result_file.write("%d %d\n" % (idx, -ERROR_URL_NOT_FOUND))
-                            continue
-                        elif error_code == 403:
-                            result_file.write(
-                                "%d %d\n" % (idx, -ERROR_URL_ACCESS_DENIED)
-                            )
+                                range_result = resp["ContentRange"]
+                                range_result_match = RANGE_MATCH.match(range_result)
+                                if range_result_match is None:
+                                    raise RuntimeError(
+                                        "Wrong format for ContentRange: %s"
+                                        % str(range_result)
+                                    )
+                                range_result = {
+                                    x: int(range_result_match.group(x))
+                                    for x in ["total", "start", "end"]
+                                }
+                            else:
+                                resp = s3.get_object(Bucket=url.bucket, Key=url.path)
+                                range_result = None
+                            sz = resp["ContentLength"]
+                            if range_result is None:
+                                range_result = {"total": sz, "start": 0, "end": sz - 1}
+                            if not url.range and sz > DOWNLOAD_FILE_THRESHOLD:
+                                # In this case, it is more efficient to use download_file as it
+                                # will download multiple parts in parallel (it does it after
+                                # multipart_threshold)
+                                s3.download_file(url.bucket, url.path, tmp.name)
+                            else:
+                                read_in_chunks(
+                                    tmp, resp["Body"], sz, DOWNLOAD_MAX_CHUNK
+                                )
+                            tmp.close()
+                            os.rename(tmp.name, url.local)
+                        except client_error as err:
+                            tmp.close()
+                            os.unlink(tmp.name)
+                            handle_client_error(err, idx, result_file)
                             continue
-                        elif error_code == 503:
-                            result_file.write("%d %d\n" % (idx, -ERROR_TRANSIENT))
+                        except RetriesExceededError as e:
+                            tmp.close()
+                            os.unlink(tmp.name)
+                            err = convert_to_client_error(e)
+                            handle_client_error(err, idx, result_file)
                             continue
-                        else:
-                            raise
-                        # TODO specific error message for out of disk space
+                    except (SSLError, Exception) as e:
+                        tmp.close()
+                        os.unlink(tmp.name)
+                        # assume anything else is transient
+                        result_file.write("%d %d\n" % (idx, -ERROR_TRANSIENT))
+                        result_file.flush()
+                        continue
                     # If we need the metadata, get it and write it out
                     if pre_op_info:
                         with open("%s_meta" % url.local, mode="w") as f:
@@ -316,28 +331,67 @@ def worker(result_file_name, queue, mode, s3config):
                             if url.encryption is not None:
                                 extra["ServerSideEncryption"] = url.encryption
                         try:
-                            s3.upload_file(
-                                url.local, url.bucket, url.path, ExtraArgs=extra
-                            )
-                            # We indicate that the file was uploaded
-                            result_file.write("%d %d\n" % (idx, 0))
-                        except client_error as err:
-                            error_code = normalize_client_error(err)
-                            if error_code == 403:
-                                result_file.write(
-                                    "%d %d\n" % (idx, -ERROR_URL_ACCESS_DENIED)
+                            try:
+                                s3.upload_file(
+                                    url.local, url.bucket, url.path, ExtraArgs=extra
                                 )
+                                # We indicate that the file was uploaded
+                                result_file.write("%d %d\n" % (idx, 0))
+                            except client_error as err:
+                                # Shouldn't get here, but just in case.
+                                # Internally, botocore catches ClientError and returns a S3UploadFailedError.
+                                # See https://github.com/boto/boto3/blob/develop/boto3/s3/transfer.py#L377
+                                handle_client_error(err, idx, result_file)
                                 continue
-                            elif error_code == 503:
-                                result_file.write("%d %d\n" % (idx, -ERROR_TRANSIENT))
+                            except S3UploadFailedError as e:
+                                err = convert_to_client_error(e)
+                                handle_client_error(err, idx, result_file)
                                 continue
-                            else:
-                                raise
+                        except (SSLError, Exception) as e:
+                            # assume anything else is transient
+                            result_file.write("%d %d\n" % (idx, -ERROR_TRANSIENT))
+                            result_file.flush()
+                            continue
         except:
             traceback.print_exc()
+            result_file.flush()
             sys.exit(ERROR_WORKER_EXCEPTION)
 
 
+def convert_to_client_error(e):
+    match = BOTOCORE_MSG_TEMPLATE_MATCH.search(str(e))
+    if not match:
+        raise e
+    error_code = match.group(1)
+    operation_name = match.group(2)
+    error_message = match.group(3)
+    response = {
+        "Error": {
+            "Code": error_code,
+            "Message": error_message,
+        }
+    }
+    return ClientError(response, operation_name)
+
+
+def handle_client_error(err, idx, result_file):
+    error_code = normalize_client_error(err)
+    if error_code == 404:
+        result_file.write("%d %d\n" % (idx, -ERROR_URL_NOT_FOUND))
+        result_file.flush()
+    elif error_code == 403:
+        result_file.write("%d %d\n" % (idx, -ERROR_URL_ACCESS_DENIED))
+        result_file.flush()
+    elif error_code == 503:
+        result_file.write("%d %d\n" % (idx, -ERROR_TRANSIENT))
+        result_file.flush()
+    else:
+        # optimistically assume it is a transient error
+        result_file.write("%d %d\n" % (idx, -ERROR_TRANSIENT))
+        result_file.flush()
+    # TODO specific error message for out of disk space
+
+
 def start_workers(mode, urls, num_workers, inject_failure, s3config):
     # We start the minimum of len(urls) or num_workers to avoid starting
     # workers that will definitely do nothing
@@ -381,6 +435,22 @@ def start_workers(mode, urls, num_workers, inject_failure, s3config):
                 if proc.exitcode is not None:
                     if proc.exitcode != 0:
                         msg = "Worker process failed (exit code %d)" % proc.exitcode
+
+                        # IMPORTANT: if this process has put items on a queue, then it will not terminate
+                        # until all buffered items have been flushed to the pipe, causing a deadlock.
+                        # `cancel_join_thread()` allows it to exit without flushing the queue.
+                        # Without this line, the parent process would hang indefinitely when a subprocess
+                        # did not exit cleanly in the case of unhandled exceptions.
+                        #
+                        # The error situation is:
+                        # 1. this process puts stuff in queue
+                        # 2. subprocess dies so doesn't consume its end-of-queue marker (the None)
+                        # 3. other subprocesses consume all useful bits AND their end-of-queue marker
+                        # 4. one marker is left and not consumed
+                        # 5. this process cannot shut down until the queue is empty.
+                        # 6. it will never be empty because all subprocesses (workers) have died.
+                        queue.cancel_join_thread()
+
                         exit(msg, proc.exitcode)
                     # Read the output file if all went well
                     with open(out_path, "r") as out_file:
@@ -745,7 +815,7 @@ def lst(
     s3config = S3Config(
         s3role,
         json.loads(s3sessionvars) if s3sessionvars else None,
-        json.loads(s3clientparams) if s3clientparams else None,
+        json.loads(s3clientparams) if s3clientparams else DEFAULT_S3_CLIENT_PARAMS,
     )
 
     urllist = []
@@ -878,7 +948,7 @@ def put(
     s3config = S3Config(
         s3role,
         json.loads(s3sessionvars) if s3sessionvars else None,
-        json.loads(s3clientparams) if s3clientparams else None,
+        json.loads(s3clientparams) if s3clientparams else DEFAULT_S3_CLIENT_PARAMS,
     )
 
     urls = list(starmap(_make_url, _files()))
@@ -1025,7 +1095,7 @@ def get(
     s3config = S3Config(
         s3role,
         json.loads(s3sessionvars) if s3sessionvars else None,
-        json.loads(s3clientparams) if s3clientparams else None,
+        json.loads(s3clientparams) if s3clientparams else DEFAULT_S3_CLIENT_PARAMS,
     )
 
     # Construct a list of URL (prefix) objects
@@ -1172,7 +1242,7 @@ def info(
     s3config = S3Config(
         s3role,
         json.loads(s3sessionvars) if s3sessionvars else None,
-        json.loads(s3clientparams) if s3clientparams else None,
+        json.loads(s3clientparams) if s3clientparams else DEFAULT_S3_CLIENT_PARAMS,
     )
 
     # Construct a list of URL (prefix) objects

metaflow/plugins/uv/bootstrap.py

@@ -0,0 +1,100 @@
+import os
+import subprocess
+import sys
+import time
+
+from metaflow.util import which
+from metaflow.metaflow_config import get_pinned_conda_libs
+from urllib.request import Request, urlopen
+from urllib.error import URLError
+
+# TODO: support version/platform/architecture selection.
+UV_URL = "https://github.com/astral-sh/uv/releases/download/0.6.11/uv-x86_64-unknown-linux-gnu.tar.gz"
+
+if __name__ == "__main__":
+
+    def run_cmd(cmd, stdin_str=None):
+        result = subprocess.run(
+            cmd,
+            shell=True,
+            input=stdin_str,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        if result.returncode != 0:
+            print(f"Bootstrap failed while executing: {cmd}")
+            print("Stdout:", result.stdout)
+            print("Stderr:", result.stderr)
+            sys.exit(1)
+
+    def install_uv():
+        import tarfile
+
+        uv_install_path = os.path.join(os.getcwd(), "uv_install")
+        if which("uv"):
+            return
+
+        print("Installing uv...")
+
+        # Prepare directory once
+        os.makedirs(uv_install_path, exist_ok=True)
+
+        # Download and decompress in one go
+        headers = {
+            "Accept-Encoding": "gzip, deflate, br",
+            "Connection": "keep-alive",
+            "User-Agent": "python-urllib",
+        }
+
+        def _tar_filter(member: tarfile.TarInfo, path):
+            if os.path.basename(member.name) != "uv":
+                return None  # skip
+            member.path = os.path.basename(member.path)
+            return member
+
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                req = Request(UV_URL, headers=headers)
+                with urlopen(req) as response:
+                    with tarfile.open(fileobj=response, mode="r:gz") as tar:
+                        tar.extractall(uv_install_path, filter=_tar_filter)
+                break
+            except (URLError, IOError) as e:
+                if attempt == max_retries - 1:
+                    raise Exception(
+                        f"Failed to download UV after {max_retries} attempts: {e}"
+                    )
+                time.sleep(2**attempt)
+
+        # Update PATH only once at the end
+        os.environ["PATH"] += os.pathsep + uv_install_path
+
+    def get_dependencies(datastore_type):
+        # return required dependencies for Metaflow that must be added to the UV environment.
+        pinned = get_pinned_conda_libs(None, datastore_type)
+
+        # return only dependency names instead of pinned versions
+        return pinned.keys()
+
+    def sync_uv_project(datastore_type):
+        print("Syncing uv project...")
+        dependencies = " ".join(get_dependencies(datastore_type))
+        cmd = f"""set -e;
+            uv sync --frozen --no-install-package metaflow;
+            uv pip install {dependencies} --strict
+            """
+        run_cmd(cmd)
+
+    if len(sys.argv) != 2:
+        print("Usage: bootstrap.py <datastore_type>")
+        sys.exit(1)
+
+    try:
+        datastore_type = sys.argv[1]
+        install_uv()
+        sync_uv_project(datastore_type)
+    except Exception as e:
+        print(f"Error: {str(e)}", file=sys.stderr)
+        sys.exit(1)

metaflow/plugins/uv/uv_environment.py

@@ -0,0 +1,70 @@
+import os
+
+from metaflow.exception import MetaflowException
+from metaflow.metaflow_environment import MetaflowEnvironment
+
+
+class UVException(MetaflowException):
+    headline = "uv error"
+
+
+class UVEnvironment(MetaflowEnvironment):
+    TYPE = "uv"
+
+    def __init__(self, flow):
+        self.flow = flow
+
+    def validate_environment(self, logger, datastore_type):
+        self.datastore_type = datastore_type
+        self.logger = logger
+
+    def init_environment(self, echo, only_steps=None):
+        self.logger("Bootstrapping uv...")
+
+    def executable(self, step_name, default=None):
+        return "uv run python"
+
+    def add_to_package(self):
+        # NOTE: We treat uv.lock and pyproject.toml as regular project assets and ship these along user code as part of the code package
+        # These are the minimal required files to reproduce the UV environment on the remote platform.
+        def _find(filename):
+            current_dir = os.getcwd()
+            while True:
+                file_path = os.path.join(current_dir, filename)
+                if os.path.isfile(file_path):
+                    return file_path
+                parent_dir = os.path.dirname(current_dir)
+                if parent_dir == current_dir:  # Reached root
+                    raise UVException(
+                        f"Could not find {filename} in current directory or any parent directory"
+                    )
+                current_dir = parent_dir
+
+        pyproject_path = _find("pyproject.toml")
+        uv_lock_path = _find("uv.lock")
+        files = [
+            (uv_lock_path, "uv.lock"),
+            (pyproject_path, "pyproject.toml"),
+        ]
+        return files
+
+    def pylint_config(self):
+        config = super().pylint_config()
+        # Disable (import-error) in pylint
+        config.append("--disable=F0401")
+        return config
+
+    def bootstrap_commands(self, step_name, datastore_type):
+        return [
+            "echo 'Bootstrapping uv project...'",
+            "flush_mflogs",
+            # We have to prevent the tracing module from loading, as the bootstrapping process
+            # uses the internal S3 client which would fail to import tracing due to the required
+            # dependencies being bundled into the conda environment, which is yet to be
+            # initialized at this point.
+            'DISABLE_TRACING=True python -m metaflow.plugins.uv.bootstrap "%s"'
+            % datastore_type,
+            "echo 'uv project bootstrapped.'",
+            "flush_mflogs",
+            "export PATH=$PATH:$(pwd)/uv_install",
+        ]

metaflow/version.py

@@ -1 +1 @@
-metaflow_version = "2.15.7"
+metaflow_version = "2.15.8"

{metaflow-2.15.7.data → metaflow-2.15.8.data}/data/share/metaflow/devtools/Makefile

@@ -260,6 +260,7 @@ shell: setup-tilt
 			env METAFLOW_HOME="$(DEVTOOLS_DIR)" \
 				METAFLOW_PROFILE=local \
 				AWS_CONFIG_FILE="$(DEVTOOLS_DIR)/aws_config" \
+				AWS_SHARED_CREDENTIALS_FILE= \
 				"$$user_shell" -i; \
 		else \
 			env METAFLOW_HOME="$(DEVTOOLS_DIR)" \
@@ -301,6 +302,7 @@ create-dev-shell: setup-tilt
 		echo "    env METAFLOW_HOME=\"$(DEVTOOLS_DIR)\" \\" >> $$SHELL_PATH && \
 		echo "        METAFLOW_PROFILE=local \\" >> $$SHELL_PATH && \
 		echo "        AWS_CONFIG_FILE=\"$(DEVTOOLS_DIR)/aws_config\" \\" >> $$SHELL_PATH && \
+		echo "        AWS_SHARED_CREDENTIALS_FILE= \\" >> $$SHELL_PATH && \
 		echo "        \"\$$user_shell\" -i" >> $$SHELL_PATH && \
 		echo "else" >> $$SHELL_PATH && \
 		echo "    env METAFLOW_HOME=\"$(DEVTOOLS_DIR)\" \\" >> $$SHELL_PATH && \

{metaflow-2.15.7.dist-info → metaflow-2.15.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaflow
-Version: 2.15.7
+Version: 2.15.8
 Summary: Metaflow: More AI and ML, Less Engineering
 Author: Metaflow Developers
 Author-email: help@metaflow.org
@@ -26,7 +26,7 @@ License-File: LICENSE
 Requires-Dist: requests
 Requires-Dist: boto3
 Provides-Extra: stubs
-Requires-Dist: metaflow-stubs==2.15.7; extra == "stubs"
+Requires-Dist: metaflow-stubs==2.15.8; extra == "stubs"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{metaflow-2.15.7.dist-info → metaflow-2.15.8.dist-info}/RECORD

@@ -1,7 +1,7 @@
 metaflow/R.py,sha256=CqVfIatvmjciuICNnoyyNGrwE7Va9iXfLdFbQa52hwA,3958
 metaflow/__init__.py,sha256=Cg9wItncyCn8jqALP5rIJ1RcpTEPp--allUctGKMTtI,5937
 metaflow/cards.py,sha256=IbRmredvmFEU0V6JL7DR8wCESwVmmZJubr6x24bo7U4,442
-metaflow/cli.py,sha256=RU-yXpT-Lfl3xGyFNtL742e9KEqcRxEnQ-4mwXrXhvo,20928
+metaflow/cli.py,sha256=XqGP8mNObMO0lOJmWtQvFFWUEKWMN_3-cGkvci2n6e4,21296
 metaflow/cli_args.py,sha256=hDsdWdRmfXYifVGq6b6FDfgoWxtIG2nr_lU6EBV0Pnk,3584
 metaflow/clone_util.py,sha256=LSuVbFpPUh92UW32DBcnZbL0FFw-4w3CLa0tpEbCkzk,2066
 metaflow/cmd_with_io.py,sha256=kl53HkAIyv0ecpItv08wZYczv7u3msD1VCcciqigqf0,588
@@ -16,12 +16,13 @@ metaflow/includefile.py,sha256=kWKDSlzVcRVNGG9PV5eB3o2ynrzqhVsfaLtkqjshn7Q,20948
 metaflow/info_file.py,sha256=wtf2_F0M6dgiUu74AFImM8lfy5RrUw5Yj7Rgs2swKRY,686
 metaflow/integrations.py,sha256=LlsaoePRg03DjENnmLxZDYto3NwWc9z_PtU6nJxLldg,1480
 metaflow/lint.py,sha256=x4p6tnRzYqNNniCGXyrUW0WuYfTUgnaOMRivxvnxask,11661
-metaflow/metaflow_config.py,sha256=oLbF4ZOfdejRBbemL_9NmFo2G2iAdTuUgbd7vNxV2lg,23567
+metaflow/metaflow_config.py,sha256=IXTmqV2Ny1SuW18v7t6_DYzL8eWqLG3dkm1ohf8rPCM,23770
 metaflow/metaflow_config_funcs.py,sha256=5GlvoafV6SxykwfL8D12WXSfwjBN_NsyuKE_Q3gjGVE,6738
 metaflow/metaflow_current.py,sha256=pfkXmkyHeMJhxIs6HBJNBEaBDpcl5kz9Wx5mW6F_3qo,7164
-metaflow/metaflow_environment.py,sha256=e5BOkA7VdpjseI4HUkm_pR74NVJRNADL20LIQL4W1vU,8139
+metaflow/metaflow_environment.py,sha256=CWG90qpfz9iJ6hHhFlAmMVNALn2v_5eTVk3mFbQR4Pw,8379
+metaflow/metaflow_git.py,sha256=Pb_VtvQzcjpuuM7UfC2u5kz85EbPMUfspl2UrPWBQMM,3647
 metaflow/metaflow_profile.py,sha256=jKPEW-hmAQO-htSxb9hXaeloLacAh41A35rMZH6G8pA,418
-metaflow/metaflow_version.py,sha256=duhIzfKZtcxMVMs2uiBqBvUarSHJqyWDwMhaBOQd_g0,7491
+metaflow/metaflow_version.py,sha256=QNN-8z1JX-Gby0dtXqjogQmsvbE8KDRMNHzQEdjI6qw,7513
 metaflow/monitor.py,sha256=T0NMaBPvXynlJAO_avKtk8OIIRMyEuMAyF8bIp79aZU,5323
 metaflow/multicore_utils.py,sha256=yEo5T6Gemn4_vl8b6IOz7fsTUYtEyqa3AaKZgJY96Wc,4974
 metaflow/package.py,sha256=yfwVMVB1mD-Sw94KwXNK3N-26YHoKMn6btrcgd67Izs,7845
@@ -36,7 +37,7 @@ metaflow/tuple_util.py,sha256=_G5YIEhuugwJ_f6rrZoelMFak3DqAR2tt_5CapS1XTY,830
 metaflow/unbounded_foreach.py,sha256=p184WMbrMJ3xKYHwewj27ZhRUsSj_kw1jlye5gA9xJk,387
 metaflow/util.py,sha256=mJBkV5tShIyCsLDeM1zygQGeciQVMrVPm_qI8Oi33G0,14656
 metaflow/vendor.py,sha256=LZgXrh7ZSDmD32D1T5jj3OKKpXIqqxKzdMAOc5V0SD4,5162
-metaflow/version.py,sha256=mmpM7KoxX80ooct0ho2OKpy5xnA-HgJXYdJElu0ET2M,28
+metaflow/version.py,sha256=8XQw9A4nDWkRa2GDc805yvkVhCHDDAZj-jh2ZCyveec,28
 metaflow/_vendor/__init__.py,sha256=y_CiwUD3l4eAKvTVDZeqgVujMy31cAM1qjAB-HfI-9s,353
 metaflow/_vendor/typing_extensions.py,sha256=q9zxWa6p6CzF1zZvSkygSlklduHf_b3K7MCxGz7MJRc,134519
 metaflow/_vendor/zipp.py,sha256=ajztOH-9I7KA_4wqDYygtHa6xUBVZgFpmZ8FE74HHHI,8425
@@ -139,7 +140,7 @@ metaflow/_vendor/v3_7/typeguard/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 metaflow/cli_components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 metaflow/cli_components/dump_cmd.py,sha256=SZEX51BWNd1o3H2uHDkYA8KRvou5X8g5rTwpdu5vnNQ,2704
 metaflow/cli_components/init_cmd.py,sha256=Er-BO59UEUV1HIsg81bRtZWT2D2IZNMp93l-AoZLCls,1519
-metaflow/cli_components/run_cmds.py,sha256=gAJeiuFt5y1IcVclwH6TV9p-JCy6-rDtEKUj2ioMO0s,11304
+metaflow/cli_components/run_cmds.py,sha256=F12_xYqVdkL2doP2ADI3cA41Izce5_zr1khJCLl77YA,11304
 metaflow/cli_components/step_cmd.py,sha256=zGJgTv7wxrv34nWDi__CHaC2eS6kItR95EdVGJX803w,4766
 metaflow/cli_components/utils.py,sha256=gpoDociadjnJD7MuiJup_MDR02ZJjjleejr0jPBu29c,6057
 metaflow/client/__init__.py,sha256=1GtQB4Y_CBkzaxg32L1syNQSlfj762wmLrfrDxGi1b8,226
@@ -147,7 +148,7 @@ metaflow/client/core.py,sha256=Cca6HbK-UBO72aELfFJxsl85ylYHHlCAd-uJP-lEepQ,83689
 metaflow/client/filecache.py,sha256=Wy0yhhCqC1JZgebqi7z52GCwXYnkAqMZHTtxThvwBgM,15229
 metaflow/cmd/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 metaflow/cmd/configure_cmd.py,sha256=o-DKnUf2FBo_HiMVyoyzQaGBSMtpbEPEdFTQZ0hkU-k,33396
-metaflow/cmd/main_cli.py,sha256=LSehmMjkWojAN1XTtqW6S51ZpGNAdW4_VK5S7qH8-Ts,2982
+metaflow/cmd/main_cli.py,sha256=iKptsPcys0OKileZdE8Pp0_y8t7pm94SL3b870Qhk30,2972
 metaflow/cmd/make_wrapper.py,sha256=N8L4u8QZAryH0sAjRsdEqG-gTj2S4LUsfDizOemrTR0,1604
 metaflow/cmd/tutorials_cmd.py,sha256=8FdlKkicTOhCIDKcBR5b0Oz6giDvS-EMY3o9skIrRqw,5156
 metaflow/cmd/util.py,sha256=jS_0rUjOnGGzPT65fzRLdGjrYAOOLA4jU2S0HJLV0oc,406
@@ -170,14 +171,14 @@ metaflow/extension_support/integrations.py,sha256=AWAh-AZ-vo9IxuAVEjGw3s8p_NMm2D
 metaflow/extension_support/plugins.py,sha256=gl7NbIJLJyLTb5LELsj1D9paQip6t6Lqz6Rhmvqvyrw,11286
 metaflow/metadata_provider/__init__.py,sha256=FZNSnz26VB_m18DQG8mup6-Gfl7r1U6lRMljJBp3VAM,64
 metaflow/metadata_provider/heartbeat.py,sha256=42mQo6wOHdFuaCh426uV6Kn8swe7e5I3gqA_G7cI_LA,3127
-metaflow/metadata_provider/metadata.py,sha256=meO4Fhxu7tbMUGwasYb9_AtL06fwrrXKKjIK7KRWZDs,27093
+metaflow/metadata_provider/metadata.py,sha256=SZIOUKqMilar-Mrj_vMvLgLeEH7kOUChsK_z51iis44,28182
 metaflow/metadata_provider/util.py,sha256=lYoQKbqoTM1iZChgyVWN-gX-HyM9tt9bXEMJexY9XmM,1723
 metaflow/mflog/__init__.py,sha256=TkR9ny_JYvNCWJTdLiHsbLSLc9cUvzAzpDuHLdG8nkA,6020
 metaflow/mflog/mflog.py,sha256=VebXxqitOtNAs7VJixnNfziO_i_urG7bsJ5JiB5IXgY,4370
 metaflow/mflog/save_logs.py,sha256=4p1OwozsHJBslOzAf0wUq2XPMNpEOZWM68MgWzh_jJY,2330
 metaflow/mflog/save_logs_periodically.py,sha256=2Uvk9hi-zlCqXxOQoXmmjH1SCugfw6eG6w70WgfI-ho,1256
 metaflow/mflog/tee.py,sha256=wTER15qeHuiRpCkOqo-bd-r3Gj-EVlf3IvWRCA4beW4,887
-metaflow/plugins/__init__.py,sha256=siqE9Zj_b9zKgMhll3f5L2m1gcAKxp_e4qMRTGJ65xY,8460
+metaflow/plugins/__init__.py,sha256=td6LLqHTvumEJMAZc8VxE2McBtiRokryphoG4WtvAzU,8508
 metaflow/plugins/catch_decorator.py,sha256=UOM2taN_OL2RPpuJhwEOA9ZALm0-hHD0XS2Hn2GUev0,4061
 metaflow/plugins/debug_logger.py,sha256=mcF5HYzJ0NQmqCMjyVUk3iAP-heroHRIiVWQC6Ha2-I,879
 metaflow/plugins/debug_monitor.py,sha256=Md5X_sDOSssN9pt2D8YcaIjTK5JaQD55UAYTcF6xYF0,1099
@@ -209,8 +210,8 @@ metaflow/plugins/airflow/sensors/s3_sensor.py,sha256=iDReG-7FKnumrtQg-HY6cCUAAqN
 metaflow/plugins/argo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 metaflow/plugins/argo/argo_client.py,sha256=A1kI9rjVjCadDsBscZ2Wk8xRBI6GNgWV6SU7TyrdfrI,16530
 metaflow/plugins/argo/argo_events.py,sha256=_C1KWztVqgi3zuH57pInaE9OzABc2NnncC-zdwOMZ-w,5909
-metaflow/plugins/argo/argo_workflows.py,sha256=JEgXzfL_4MMTZsxtO6ydMgza_DI-LirDaprS_LTASOY,185013
-metaflow/plugins/argo/argo_workflows_cli.py,sha256=27eLtcp5N5plapP-uIJqR41B0zDfXOV39AGM0nchymo,37952
+metaflow/plugins/argo/argo_workflows.py,sha256=nF42vquNFcWBv4_XdCC8l5a1agFxGgVFZYkatOYzOQA,186081
+metaflow/plugins/argo/argo_workflows_cli.py,sha256=Ka-ea4x19E6DrYgGm5ZwormxEbTGdun8fyHl-mh0tfc,38265
 metaflow/plugins/argo/argo_workflows_decorator.py,sha256=ogCSBmwsC2C3eusydrgjuAJd4qK18f1sI4jJwA4Fd-o,7800
 metaflow/plugins/argo/argo_workflows_deployer.py,sha256=6kHxEnYXJwzNCM9swI8-0AckxtPWqwhZLerYkX8fxUM,4444
 metaflow/plugins/argo/argo_workflows_deployer_objects.py,sha256=lRRHUcpiyJZFltthxZoIp7aJWwy7pcdhaRm0etKN9es,14182
@@ -218,7 +219,7 @@ metaflow/plugins/argo/capture_error.py,sha256=Ys9dscGrTpW-ZCirLBU0gD9qBM0BjxyxGl
 metaflow/plugins/argo/generate_input_paths.py,sha256=loYsI6RFX9LlFsHb7Fe-mzlTTtRdySoOu7sYDy-uXK0,881
 metaflow/plugins/argo/jobset_input_paths.py,sha256=-h0E_e0w6FMiBUod9Rf_XOSCtZv_C0exacw4q1SfIfg,501
 metaflow/plugins/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-metaflow/plugins/aws/aws_client.py,sha256=mO8UD6pxFaOnxDb3hTP3HB7Gqb_ZxoR-76LT683WHvI,4036
+metaflow/plugins/aws/aws_client.py,sha256=lMIGE06LNeOfqbEXVhXKU8kx3gTFwu14Si5n4y1W9KM,4039
 metaflow/plugins/aws/aws_utils.py,sha256=kNd61C54Y3WxrL7KSjoKydRjBQ1p3exc9QXux-jZyDE,7510
 metaflow/plugins/aws/batch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 metaflow/plugins/aws/batch/batch.py,sha256=e9ssahWM18GnipPK2sqYB-ztx9w7Eoo7YtWyEtufYxs,17787
@@ -281,8 +282,8 @@ metaflow/plugins/datastores/s3_storage.py,sha256=CZdNqaKtxDXQbEg2YHyphph3hWcLIE5
 metaflow/plugins/datatools/__init__.py,sha256=ge4L16OBQLy2J_MMvoHg3lMfdm-MluQgRWoyZ5GCRnk,1267
 metaflow/plugins/datatools/local.py,sha256=FJvMOBcjdyhSPHmdLocBSiIT0rmKkKBmsaclxH75x08,4233
 metaflow/plugins/datatools/s3/__init__.py,sha256=14tr9fPjN3ULW5IOfKHeG7Uhjmgm7LMtQHfz1SFv-h8,248
-metaflow/plugins/datatools/s3/s3.py,sha256=dSUEf3v_BVyvYXlehWy04xcBtNDhKKR5Gnn7oXwagaw,67037
-metaflow/plugins/datatools/s3/s3op.py,sha256=XR5E2likcFx7OLk33Kh4FCJVl_eSWrPdO_2hD9F9uoc,43410
+metaflow/plugins/datatools/s3/s3.py,sha256=ThISU4XjXhDqAtfgH_PgtNp0OxF_bhzCgNozYIeMa7g,66993
+metaflow/plugins/datatools/s3/s3op.py,sha256=I7XkDJvVvvLt8SmXNSZjSNONIa2m3QlT5-ZL8g6erno,46936
 metaflow/plugins/datatools/s3/s3tail.py,sha256=boQjQGQMI-bvTqcMP2y7uSlSYLcvWOy7J3ZUaF78NAA,2597
 metaflow/plugins/datatools/s3/s3util.py,sha256=FgRgaVmEq7-i2dV7q8XK5w5PfFt-xJjZa8WrK8IJfdI,3769
 metaflow/plugins/env_escape/__init__.py,sha256=tGNUZnmPvk52eNs__VK443b3CZ7ogEFTT-s9_n_HF8Q,8837
@@ -340,6 +341,9 @@ metaflow/plugins/pypi/utils.py,sha256=W8OhDrhz7YIE-2MSSN5Rj7AmESwsN5YDmdnro152J4
 metaflow/plugins/secrets/__init__.py,sha256=mhJaN2eMS_ZZVewAMR2E-JdP5i0t3v9e6Dcwd-WpruE,310
 metaflow/plugins/secrets/inline_secrets_provider.py,sha256=EChmoBGA1i7qM3jtYwPpLZDBybXLergiDlN63E0u3x8,294
 metaflow/plugins/secrets/secrets_decorator.py,sha256=s-sFzPWOjahhpr5fMj-ZEaHkDYAPTO0isYXGvaUwlG8,11273
+metaflow/plugins/uv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+metaflow/plugins/uv/bootstrap.py,sha256=Yp_G3dHhXX5GwmpAASdZr28fDu69pucakST954Vmvp4,3243
+metaflow/plugins/uv/uv_environment.py,sha256=yKoC4t_TrVoN2tH6pV_XOpH3QvObmkRurM_I85Fa-x8,2577
 metaflow/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 metaflow/runner/click_api.py,sha256=nAT1mSV40YKiHTyTr4RDZBCGgGFV6K0TXCTL4xtUOAc,23492
 metaflow/runner/deployer.py,sha256=6ixXonNyLB1dfTNl1HVGVT5M8CybXDUa3oFTabn9Sp8,9099
@@ -389,12 +393,12 @@ metaflow/user_configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 metaflow/user_configs/config_decorators.py,sha256=qCKVAvd0NKgaCxQ2OThes5-DYHXq6A1HqURubYNeFdw,20481
 metaflow/user_configs/config_options.py,sha256=m6jccSpzI4qUJ7vyYkYBIf8G3V0Caunxg_k7zg4Zlqg,21067
 metaflow/user_configs/config_parameters.py,sha256=oeJGVKu1ao_YQX6Lg6P2FEv5k5-_F4sARLlVpTW9ezM,15502
-metaflow-2.15.7.data/data/share/metaflow/devtools/Makefile,sha256=kZJDrvY2qRfqkue3mBecZutaGs35zsZR_vNu8WOBcto,13632
-metaflow-2.15.7.data/data/share/metaflow/devtools/Tiltfile,sha256=P5_rn_F3xYLN1_cEAQ9mNeS22HG2rb8beKIz2RIK6fU,20634
-metaflow-2.15.7.data/data/share/metaflow/devtools/pick_services.sh,sha256=DCnrMXwtApfx3B4S-YiZESMyAFHbXa3VuNL0MxPLyiE,2196
-metaflow-2.15.7.dist-info/licenses/LICENSE,sha256=nl_Lt5v9VvJ-5lWJDT4ddKAG-VZ-2IaLmbzpgYDz2hU,11343
-metaflow-2.15.7.dist-info/METADATA,sha256=4s0oOBFv9UjhBzCjGFY3m1XOmzEi_14ELD7rYRHN8_4,6740
-metaflow-2.15.7.dist-info/WHEEL,sha256=MAQBAzGbXNI3bUmkDsiV_duv8i-gcdnLzw7cfUFwqhU,109
-metaflow-2.15.7.dist-info/entry_points.txt,sha256=RvEq8VFlgGe_FfqGOZi0D7ze1hLD0pAtXeNyGfzc_Yc,103
-metaflow-2.15.7.dist-info/top_level.txt,sha256=v1pDHoWaSaKeuc5fKTRSfsXCKSdW1zvNVmvA-i0if3o,9
-metaflow-2.15.7.dist-info/RECORD,,
+metaflow-2.15.8.data/data/share/metaflow/devtools/Makefile,sha256=5n89OGIC_kE4wxtEI66VCucN-b-1w5bqvGeZYmeRGz8,13737
+metaflow-2.15.8.data/data/share/metaflow/devtools/Tiltfile,sha256=P5_rn_F3xYLN1_cEAQ9mNeS22HG2rb8beKIz2RIK6fU,20634
+metaflow-2.15.8.data/data/share/metaflow/devtools/pick_services.sh,sha256=DCnrMXwtApfx3B4S-YiZESMyAFHbXa3VuNL0MxPLyiE,2196
+metaflow-2.15.8.dist-info/licenses/LICENSE,sha256=nl_Lt5v9VvJ-5lWJDT4ddKAG-VZ-2IaLmbzpgYDz2hU,11343
+metaflow-2.15.8.dist-info/METADATA,sha256=ySz1B2qdeOjZ2eLXO35Za8JOhmgsxBP747BNFBLbBn8,6740
+metaflow-2.15.8.dist-info/WHEEL,sha256=MAQBAzGbXNI3bUmkDsiV_duv8i-gcdnLzw7cfUFwqhU,109
+metaflow-2.15.8.dist-info/entry_points.txt,sha256=RvEq8VFlgGe_FfqGOZi0D7ze1hLD0pAtXeNyGfzc_Yc,103
+metaflow-2.15.8.dist-info/top_level.txt,sha256=v1pDHoWaSaKeuc5fKTRSfsXCKSdW1zvNVmvA-i0if3o,9
+metaflow-2.15.8.dist-info/RECORD,,