metaflow 2.15.0__tar.gz → 2.15.2__tar.gz

{metaflow-2.15.0/metaflow.egg-info → metaflow-2.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: metaflow
-Version: 2.15.0
+Version: 2.15.2
 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.0; extra == "stubs"
+Requires-Dist: metaflow-stubs==2.15.2; extra == "stubs"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{metaflow-2.15.0 → metaflow-2.15.2}/devtools/Makefile

@@ -8,6 +8,7 @@ help:
 	@echo "  ui            - Open Metaflow UI"
 	@echo "  dashboard     - Open Minikube dashboard"
 	@echo "  down          - Stop and clean up the environment"
+	@echo "  all-up        - Start the development environment with all services"
 	@echo "  help          - Show this help message"
 
 HELM_VERSION := v3.14.0
@@ -24,10 +25,10 @@ MINIKUBE := $(MINIKUBE_DIR)/minikube
 TILT_DIR := $(DEVTOOLS_DIR)/tilt
 TILT := $(TILT_DIR)/tilt
 TILTFILE := $(MKFILE_DIR)/Tiltfile
-MAKE_CMD := $(MAKE) -C "$(MKFILE_DIR)"
+MAKE_CMD := $(MAKE) -f "$(MKFILE_PATH)"
 
 MINIKUBE_CPUS ?= 4
-MINIKUBE_MEMORY ?= 6000
+MINIKUBE_MEMORY ?= 6144
 MINIKUBE_DISK_SIZE ?= 20g
 
 ifeq ($(shell uname), Darwin)
@@ -129,7 +130,8 @@ setup-minikube:
 			--cpus $(MINIKUBE_CPUS) \
 			--memory $(MINIKUBE_MEMORY) \
 			--disk-size $(MINIKUBE_DISK_SIZE) \
-			--driver docker; \
+			--driver docker \
+		|| { echo "❌ Failed to start Minikube (check if Docker is running)"; exit 1; }; \
 		echo "🔌 Enabling metrics-server and dashboard (quietly)..."; \
 		$(MINIKUBE) addons enable metrics-server >/dev/null 2>&1; \
 		$(MINIKUBE) addons enable dashboard >/dev/null 2>&1; \
@@ -170,7 +172,6 @@ up: install-brew check-docker install-curl install-gum setup-minikube install-he
 	@echo 'trap "exit" INT TERM' >> $(DEVTOOLS_DIR)/start.sh
 	@echo 'trap "kill 0" EXIT' >> $(DEVTOOLS_DIR)/start.sh
 	@echo 'eval $$($(MINIKUBE) docker-env)' >> $(DEVTOOLS_DIR)/start.sh
-	
 	@echo 'if [ -n "$$SERVICES_OVERRIDE" ]; then' >> "$(DEVTOOLS_DIR)/start.sh"
 	@echo '    echo "🌐 Using user-provided list of services: $$SERVICES_OVERRIDE"' >> "$(DEVTOOLS_DIR)/start.sh"
 	@echo '    SERVICES="$$SERVICES_OVERRIDE"' >> "$(DEVTOOLS_DIR)/start.sh"
@@ -186,11 +187,14 @@ up: install-brew check-docker install-curl install-gum setup-minikube install-he
 	@chmod +x $(DEVTOOLS_DIR)/start.sh
 	@$(DEVTOOLS_DIR)/start.sh
 
+all-up:
+	@echo "🚀 Starting up all services..."
+	SERVICES_OVERRIDE=all $(MAKE_CMD) up
+
 down:
 	@echo "🛑 Stopping all services..."
 	@-pkill -f "$(MINIKUBE) tunnel" 2>/dev/null || true
 	@echo "⏹️  Stopping Tilt..."
-	-PATH="$(MINIKUBE_DIR):$(TILT_DIR):$$PATH" tilt down -f $(TILTFILE)
 	@echo "🧹 Cleaning up Minikube..."
 	$(MAKE_CMD) teardown-minikube
 	@echo "🗑️  Removing Tilt binary and directory..."
@@ -201,7 +205,7 @@ down:
 
 shell: setup-tilt
 	@echo "⏳ Checking if development environment is up..."
-	@set -e; \
+	@set -eu; \
 	for i in $$(seq 1 90); do \
 		if "$(TILT)" get session >/dev/null 2>&1; then \
 			found_session=1; \
@@ -210,7 +214,7 @@ shell: setup-tilt
 			sleep 2; \
 		fi; \
 	done; \
-	if [ -z "$${found_session}" ]; then \
+	if [ -z "$${found_session:-}" ]; then \
 		echo "❌ Development environment is not up."; \
 		echo "   Please run 'metaflow-dev up' in another terminal, then re-run 'metaflow-dev shell'."; \
 		exit 1; \
@@ -220,7 +224,10 @@ shell: setup-tilt
 		"$(TILT)" get uiresource generate-configs >/dev/null 2>&1; \
 		status=$$?; \
 		if [ $$status -eq 0 ]; then \
-			"$(TILT)" wait --for=condition=Ready uiresource/generate-configs; \
+			if ! "$(TILT)" wait --for=condition=Ready uiresource/generate-configs --timeout=300s; then \
+				echo "❌ Timed out waiting for development environment to be ready."; \
+				exit 1; \
+			fi; \
 			break; \
 		elif [ $$status -eq 127 ]; then \
 			echo "❌ Development environment is not up."; \
@@ -250,8 +257,7 @@ shell: setup-tilt
 				"$$user_shell" -i; \
 		fi'
 
-# TODO: This can be done away with in a while since we now have metaflow-dev command.
-#
+
 # @echo '$(MAKE_CMD) create-dev-shell' >> $(DEVTOOLS_DIR)/start.sh
 # @echo 'rm -f /tmp/metaflow-devshell-*' >> $(DEVTOOLS_DIR)/start.sh
 create-dev-shell: setup-tilt
@@ -268,7 +274,10 @@ create-dev-shell: setup-tilt
 		echo "fi" >> $$SHELL_PATH && \
 		echo "" >> $$SHELL_PATH && \
 		echo "echo \"⏳ Waiting for development environment to be ready...\"" >> $$SHELL_PATH && \
-		echo "$(TILT) wait --for=condition=Ready uiresource/generate-configs" >> $$SHELL_PATH && \
+		echo "if ! $(TILT) wait --for=condition=Ready uiresource/generate-configs --timeout=300s; then" >> $$SHELL_PATH && \
+		echo "  echo \"❌ Timed out waiting for development environment to be ready.\"" >> $$SHELL_PATH && \
+		echo "  exit 1" >> $$SHELL_PATH && \
+		echo "fi" >> $$SHELL_PATH && \
 		echo "" >> $$SHELL_PATH && \
 		echo "echo \"🔧 Starting a new shell for development environment...\"" >> $$SHELL_PATH && \
 		echo "if [ -n \"\$$SHELL\" ]; then" >> $$SHELL_PATH && \
@@ -318,6 +327,6 @@ ui: setup-tilt
 	@echo "🔗 Opening Metaflow UI at http://localhost:3000"
 	@open http://localhost:3000
 
-.PHONY: install-helm setup-minikube setup-tilt teardown-minikube tunnel up down check-docker install-curl install-gum install-brew up down dashboard shell ui help
+.PHONY: install-helm setup-minikube setup-tilt teardown-minikube tunnel up down check-docker install-curl install-gum install-brew up down dashboard shell ui all-up help
 
 .DEFAULT_GOAL := up

{metaflow-2.15.0 → metaflow-2.15.2}/devtools/Tiltfile

@@ -23,8 +23,13 @@ components = {
     "argo-events": ["argo-workflows"],
 }
 
-if os.getenv("SERVICES", "").strip():
-    requested_components = os.getenv("SERVICES", "").split(",")
+services_env = os.getenv("SERVICES", "").strip().lower()
+
+if services_env:
+    if services_env == "all":
+        requested_components = list(components.keys())
+    else:
+        requested_components = services_env.split(",")
 else:
     requested_components = list(components.keys())
 
@@ -78,7 +83,7 @@ for component in requested_components:
         if result not in enabled_components:
             enabled_components.append(result)
 
-# Print a friendly summary when running `tilt up`.            
+# Print a friendly summary when running `tilt up`.
 if config.tilt_subcommand == 'up':
     print("\n📦 Components to install:")
     for component in enabled_components:
@@ -99,6 +104,7 @@ if "minio" in enabled_components:
         set=[
             'rootUser=rootuser',
             'rootPassword=rootpass123',
+            # TODO: perturb the bucket name to avoid conflicts
             'buckets[0].name=metaflow-test',
             'buckets[0].policy=none',
             'buckets[0].purge=false',
@@ -498,7 +504,7 @@ if "argo-events" in enabled_components:
         'argo-events-controller-manager',
         labels=['argo-events'],
     )
-    
+
     metaflow_config["METAFLOW_ARGO_EVENTS_EVENT"] = "metaflow-event"
     metaflow_config["METAFLOW_ARGO_EVENTS_EVENT_BUS"] = "default"
     metaflow_config["METAFLOW_ARGO_EVENTS_EVENT_SOURCE"] = "argo-events-webhook"
@@ -600,8 +606,20 @@ if "ui" in enabled_components:
     config_resources.append('metaflow-ui')
     config_resources.append('metaflow-ui-static')
 
+cmd = '''
+ARCH=$(kubectl get nodes -o jsonpath='{.items[0].status.nodeInfo.architecture}')
+case "$ARCH" in
+  arm64)   echo linux-aarch64 ;;
+  amd64)   echo linux-64 ;;
+  *)       echo linux-64 ;;
+esac
+'''
+
+# For @conda/@pypi emulation
+metaflow_config["METAFLOW_KUBERNETES_CONDA_ARCH"] = str(local(cmd)).strip()
+
 local_resource(
     name="generate-configs",
     cmd=write_config_files(),
     resource_deps=config_resources,
-)
+)

{metaflow-2.15.0 → metaflow-2.15.2}/metaflow/__init__.py

@@ -119,6 +119,13 @@ from .includefile import IncludeFile
 # Decorators
 from .decorators import step, _import_plugin_decorators
 
+# Config parsers
+from .plugins.pypi.parsers import (
+    requirements_txt_parser,
+    pyproject_toml_parser,
+    conda_environment_yml_parser,
+)
+
 # this auto-generates decorator functions from Decorator objects
 # in the top-level metaflow namespace
 _import_plugin_decorators(globals())

metaflow-2.15.2/metaflow/cmd/code/__init__.py

@@ -0,0 +1,230 @@
+import os
+import shutil
+import sys
+from subprocess import PIPE, CompletedProcess, run
+from tempfile import TemporaryDirectory
+from typing import Any, Callable, List, Mapping, Optional, cast
+
+from metaflow import Run
+from metaflow._vendor import click
+from metaflow.cli import echo_always
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.group(help="Access, compare, and manage code associated with Metaflow runs.")
+def code():
+    pass
+
+
+def echo(line: str) -> None:
+    echo_always(line, err=True, fg="magenta")
+
+
+def extract_code_package(runspec: str) -> TemporaryDirectory:
+    try:
+        mf_run = Run(runspec, _namespace_check=False)
+        echo(f"✅  Run *{runspec}* found, downloading code..")
+    except Exception as e:
+        echo(f"❌  Run **{runspec}** not found")
+        raise e
+
+    if mf_run.code is None:
+        echo(
+            f"❌  Run **{runspec}** doesn't have a code package. Maybe it's a local run?"
+        )
+        raise RuntimeError("no code package found")
+
+    return mf_run.code.extract()
+
+
+def perform_diff(
+    source_dir: str,
+    target_dir: Optional[str] = None,
+    output: bool = False,
+    **kwargs: Mapping[str, Any],
+) -> Optional[List[str]]:
+    if target_dir is None:
+        target_dir = os.getcwd()
+
+    diffs = []
+    for dirpath, dirnames, filenames in os.walk(source_dir, followlinks=True):
+        for fname in filenames:
+            # NOTE: the paths below need to be set up carefully
+            # for the `patch` command to work. Better not to touch
+            # the directories below. If you must, test that patches
+            # work after your changes.
+            #
+            # target_file is the git repo in the current working directory
+            rel = os.path.relpath(dirpath, source_dir)
+            target_file = os.path.join(rel, fname)
+            # source_file is the run file loaded in a tmp directory
+            source_file = os.path.join(dirpath, fname)
+
+            if sys.stdout.isatty() and not output:
+                color = ["--color"]
+            else:
+                color = ["--no-color"]
+
+            if os.path.exists(os.path.join(target_dir, target_file)):
+                cmd = (
+                    ["git", "diff", "--no-index", "--exit-code"]
+                    + color
+                    + [
+                        target_file,
+                        source_file,
+                    ]
+                )
+                result: CompletedProcess = run(
+                    cmd, text=True, stdout=PIPE, cwd=target_dir
+                )
+                if result.returncode == 0:
+                    if not output:
+                        echo(f"✅  {target_file} is identical, skipping")
+                    continue
+
+                if output:
+                    diffs.append(result.stdout)
+                else:
+                    run(["less", "-R"], input=result.stdout, text=True)
+            else:
+                if not output:
+                    echo(f"❗  {target_file} not in the target directory, skipping")
+    return diffs if output else None
+
+
+def run_op(
+    runspec: str, op: Callable[..., Optional[List[str]]], **op_args: Mapping[str, Any]
+) -> Optional[List[str]]:
+    tmp = None
+    try:
+        tmp = extract_code_package(runspec)
+        return op(tmp.name, **op_args)
+    finally:
+        if tmp and os.path.exists(tmp.name):
+            shutil.rmtree(tmp.name)
+
+
+def run_op_diff_runs(
+    source_run_pathspec: str, target_run_pathspec: str, **op_args: Mapping[str, Any]
+) -> Optional[List[str]]:
+    source_tmp = None
+    target_tmp = None
+    try:
+        source_tmp = extract_code_package(source_run_pathspec)
+        target_tmp = extract_code_package(target_run_pathspec)
+        return perform_diff(source_tmp.name, target_tmp.name, **op_args)
+    finally:
+        for d in [source_tmp, target_tmp]:
+            if d and os.path.exists(d.name):
+                shutil.rmtree(d.name)
+
+
+def op_diff(tmpdir: str, **kwargs: Mapping[str, Any]) -> Optional[List[str]]:
+    kwargs_dict = dict(kwargs)
+    target_dir = cast(Optional[str], kwargs_dict.pop("target_dir", None))
+    output: bool = bool(kwargs_dict.pop("output", False))
+    op_args: Mapping[str, Any] = {**kwargs_dict}
+    return perform_diff(tmpdir, target_dir=target_dir, output=output, **op_args)
+
+
+def op_pull(tmpdir: str, dst: str, **op_args: Mapping[str, Any]) -> None:
+    if os.path.exists(dst):
+        echo(f"❌  Directory *{dst}* already exists")
+    else:
+        shutil.move(tmpdir, dst)
+        echo(f"Code downloaded to *{dst}*")
+
+
+def op_patch(tmpdir: str, dst: str, **kwargs: Mapping[str, Any]) -> None:
+    diffs = perform_diff(tmpdir, output=True) or []
+    with open(dst, "w", encoding="utf-8") as f:
+        for out in diffs:
+            out = out.replace(tmpdir, "/.")
+            out = out.replace("+++ b/./", "+++ b/")
+            out = out.replace("--- b/./", "--- b/")
+            out = out.replace("--- a/./", "--- a/")
+            out = out.replace("+++ a/./", "+++ a/")
+            f.write(out)
+    echo(f"Patch saved in *{dst}*")
+    path = run(
+        ["git", "rev-parse", "--show-prefix"], text=True, stdout=PIPE
+    ).stdout.strip()
+    if path:
+        diropt = f" --directory={path.rstrip('/')}"
+    else:
+        diropt = ""
+    echo("Apply the patch by running:")
+    echo_always(
+        f"git apply --verbose{diropt} {dst}", highlight=True, bold=True, err=True
+    )
+
+
+@code.command()
+@click.argument("run_pathspec")
+def diff(run_pathspec: str, **kwargs: Mapping[str, Any]) -> None:
+    """
+    Do a 'git diff' of the current directory and a Metaflow run.
+    """
+    _ = run_op(run_pathspec, op_diff, **kwargs)
+
+
+@code.command()
+@click.argument("source_run_pathspec")
+@click.argument("target_run_pathspec")
+def diff_runs(
+    source_run_pathspec: str, target_run_pathspec: str, **kwargs: Mapping[str, Any]
+) -> None:
+    """
+    Do a 'git diff' between two Metaflow runs.
+    """
+    _ = run_op_diff_runs(source_run_pathspec, target_run_pathspec, **kwargs)
+
+
+@code.command()
+@click.argument("run_pathspec")
+@click.option(
+    "--dir", help="Destination directory (default: {run_pathspec}_code)", default=None
+)
+def pull(
+    run_pathspec: str, dir: Optional[str] = None, **kwargs: Mapping[str, Any]
+) -> None:
+    """
+    Pull the code of a Metaflow run.
+    """
+    if dir is None:
+        dir = run_pathspec.lower().replace("/", "_") + "_code"
+    op_args: Mapping[str, Any] = {**kwargs, "dst": dir}
+    run_op(run_pathspec, op_pull, **op_args)
+
+
+@code.command()
+@click.argument("run_pathspec")
+@click.option(
+    "--file_path",
+    help="Patch file name. If not provided, defaults to a sanitized version of RUN_PATHSPEC "
+    "with slashes replaced by underscores, plus '.patch'.",
+    show_default=False,
+)
+@click.option(
+    "--overwrite", is_flag=True, help="Overwrite the patch file if it exists."
+)
+def patch(
+    run_pathspec: str,
+    file_path: Optional[str] = None,
+    overwrite: bool = False,
+    **kwargs: Mapping[str, Any],
+) -> None:
+    """
+    Create a patch by comparing current dir with a Metaflow run.
+    """
+    if file_path is None:
+        file_path = run_pathspec.lower().replace("/", "_") + ".patch"
+    if os.path.exists(file_path) and not overwrite:
+        echo(f"File *{file_path}* already exists. To overwrite, specify --overwrite.")
+        return
+    op_args: Mapping[str, Any] = {**kwargs, "dst": file_path}
+    run_op(run_pathspec, op_patch, **op_args)

{metaflow-2.15.0 → metaflow-2.15.2}/metaflow/cmd/develop/stub_generator.py

@@ -1133,13 +1133,16 @@ class StubGenerator:
             result = result[1:]
         # Add doc to first and last overloads. Jedi uses the last one and pycharm
         # the first one. Go figure.
+        result_docstring = docs["func_doc"]
+        if docs["param_doc"]:
+            result_docstring += "\nParameters\n----------\n" + docs["param_doc"]
         result[0] = (
             result[0][0],
-            docs["func_doc"] + "\nParameters\n----------\n" + docs["param_doc"],
+            result_docstring,
         )
         result[-1] = (
             result[-1][0],
-            docs["func_doc"] + "\nParameters\n----------\n" + docs["param_doc"],
+            result_docstring,
         )
         return result
 

{metaflow-2.15.0 → metaflow-2.15.2}/metaflow/cmd/main_cli.py

@@ -67,6 +67,7 @@ CMDS_DESC = [
     ("configure", ".configure_cmd.cli"),
     ("tutorials", ".tutorials_cmd.cli"),
     ("develop", ".develop.cli"),
+    ("code", ".code.cli"),
 ]
 
 process_cmds(globals())

metaflow-2.15.2/metaflow/cmd/make_wrapper.py

@@ -0,0 +1,48 @@
+import sys
+import subprocess
+from pathlib import Path
+import sysconfig
+import site
+
+
+def find_makefile():
+    possible_dirs = []
+
+    # 1) The standard sysconfig-based location
+    data_dir = sysconfig.get_paths()["data"]
+    possible_dirs.append(Path(data_dir) / "share" / "metaflow" / "devtools")
+
+    # 2) The user base (e.g. ~/.local on many systems)
+    user_base = site.getuserbase()  # e.g. /home/runner/.local
+    possible_dirs.append(Path(user_base) / "share" / "metaflow" / "devtools")
+
+    # 3) site-packages can vary, we can guess share/.. near each site-packages
+    # (Works if pip actually placed devtools near site-packages.)
+    for p in site.getsitepackages():
+        possible_dirs.append(Path(p).parent / "share" / "metaflow" / "devtools")
+    user_site = site.getusersitepackages()
+    possible_dirs.append(Path(user_site).parent / "share" / "metaflow" / "devtools")
+
+    for candidate_dir in possible_dirs:
+        makefile_candidate = candidate_dir / "Makefile"
+        if makefile_candidate.is_file():
+            return makefile_candidate
+
+    return None
+
+
+def main():
+    makefile_path = find_makefile()
+    if not makefile_path:
+        print("ERROR: Could not find executable in any known location.")
+        sys.exit(1)
+    cmd = ["make", "-f", str(makefile_path)] + sys.argv[1:]
+
+    try:
+        completed = subprocess.run(cmd, check=True)
+        sys.exit(completed.returncode)
+    except subprocess.CalledProcessError as ex:
+        sys.exit(ex.returncode)
+    except KeyboardInterrupt:
+        print("Process interrupted by user. Exiting cleanly.")
+        sys.exit(1)

{metaflow-2.15.0 → metaflow-2.15.2}/metaflow/metaflow_config.py

@@ -381,6 +381,8 @@ KUBERNETES_DISK = from_conf("KUBERNETES_DISK", None)
 # Default kubernetes QoS class
 KUBERNETES_QOS = from_conf("KUBERNETES_QOS", "burstable")
 
+# Architecture of kubernetes nodes - used for @conda/@pypi in metaflow-dev
+KUBERNETES_CONDA_ARCH = from_conf("KUBERNETES_CONDA_ARCH")
 ARGO_WORKFLOWS_KUBERNETES_SECRETS = from_conf("ARGO_WORKFLOWS_KUBERNETES_SECRETS", "")
 ARGO_WORKFLOWS_ENV_VARS_TO_SKIP = from_conf("ARGO_WORKFLOWS_ENV_VARS_TO_SKIP", "")
 

{metaflow-2.15.0 → metaflow-2.15.2}/metaflow/metaflow_environment.py

@@ -6,7 +6,7 @@ from .util import get_username
 from . import metaflow_version
 from metaflow.exception import MetaflowException
 from metaflow.extension_support import dump_module_info
-from metaflow.mflog import BASH_MFLOG
+from metaflow.mflog import BASH_MFLOG, BASH_FLUSH_LOGS
 from . import R
 
 
@@ -159,6 +159,7 @@ class MetaflowEnvironment(object):
     def get_package_commands(self, code_package_url, datastore_type):
         cmds = [
             BASH_MFLOG,
+            BASH_FLUSH_LOGS,
             "mflog 'Setting up task environment.'",
             self._get_install_dependencies_cmd(datastore_type),
             "mkdir metaflow",
@@ -176,6 +177,7 @@ class MetaflowEnvironment(object):
             "fi" % code_package_url,
             "TAR_OPTIONS='--warning=no-timestamp' tar xf job.tar",
             "mflog 'Task is starting.'",
+            "flush_mflogs",
         ]
         return cmds
 

{metaflow-2.15.0 → metaflow-2.15.2}/metaflow/mflog/__init__.py

@@ -44,6 +44,8 @@ BASH_MFLOG = (
 BASH_SAVE_LOGS_ARGS = ["python", "-m", "metaflow.mflog.save_logs"]
 BASH_SAVE_LOGS = " ".join(BASH_SAVE_LOGS_ARGS)
 
+BASH_FLUSH_LOGS = "flush_mflogs(){ " f"{BASH_SAVE_LOGS}; " "}"
+
 
 # this function returns a bash expression that redirects stdout
 # and stderr of the given bash expression to mflog.tee
@@ -63,7 +65,7 @@ def bash_capture_logs(bash_expr, var_transform=None):
 # update_delay determines how often logs should be uploaded to S3
 # as a function of the task execution time
 
-MIN_UPDATE_DELAY = 1.0  # the most frequent update interval
+MIN_UPDATE_DELAY = 0.25  # the most frequent update interval
 MAX_UPDATE_DELAY = 30.0  # the least frequent update interval
 
 
@@ -110,7 +112,6 @@ def export_mflog_env_vars(
 
 def tail_logs(prefix, stdout_tail, stderr_tail, echo, has_log_updates):
     def _available_logs(tail, stream, echo, should_persist=False):
-        # print the latest batch of lines
         try:
             for line in tail:
                 if should_persist:
@@ -128,7 +129,7 @@ def tail_logs(prefix, stdout_tail, stderr_tail, echo, has_log_updates):
 
     start_time = time.time()
     next_log_update = start_time
-    log_update_delay = 1
+    log_update_delay = update_delay(0)
     while has_log_updates():
         if time.time() > next_log_update:
             _available_logs(stdout_tail, "stdout", echo)

{metaflow-2.15.0 → metaflow-2.15.2}/metaflow/plugins/kubernetes/kubernetes_decorator.py

@@ -29,6 +29,7 @@ from metaflow.metaflow_config import (
     KUBERNETES_SHARED_MEMORY,
     KUBERNETES_TOLERATIONS,
     KUBERNETES_QOS,
+    KUBERNETES_CONDA_ARCH,
 )
 from metaflow.plugins.resources_decorator import ResourcesDecorator
 from metaflow.plugins.timeout_decorator import get_run_time_limit_for_task
@@ -158,7 +159,7 @@ class KubernetesDecorator(StepDecorator):
 
     # Conda environment support
     supports_conda_environment = True
-    target_platform = "linux-64"
+    target_platform = KUBERNETES_CONDA_ARCH or "linux-64"
 
     def init(self):
         super(KubernetesDecorator, self).init()

{metaflow-2.15.0 → metaflow-2.15.2}/metaflow/plugins/kubernetes/kubernetes_jobsets.py

@@ -319,6 +319,8 @@ class RunningJobSet(object):
     def kill(self):
         plural = "jobsets"
         client = self._client.get()
+        if not (self.is_running or self.is_waiting):
+            return
         try:
             # Killing the control pod will trigger the jobset to mark everything as failed.
             # Since jobsets have a successPolicy set to `All` which ensures that everything has

{metaflow-2.15.0 → metaflow-2.15.2}/metaflow/plugins/pypi/bootstrap.py

@@ -8,6 +8,7 @@ import subprocess
 import sys
 import tarfile
 import time
+import platform
 from urllib.error import URLError
 from urllib.request import urlopen
 from metaflow.metaflow_config import DATASTORE_LOCAL_DIR, CONDA_USE_FAST_INIT
@@ -36,29 +37,6 @@ def timer(func):
 
 
 if __name__ == "__main__":
-    # TODO: Detect architecture on the fly when dealing with arm architectures.
-    # ARCH=$(uname -m)
-    # OS=$(uname)
-
-    # if [[ "$OS" == "Linux" ]]; then
-    #     PLATFORM="linux"
-    #     if [[ "$ARCH" == "aarch64" ]]; then
-    #         ARCH="aarch64";
-    #     elif [[ $ARCH == "ppc64le" ]]; then
-    #         ARCH="ppc64le";
-    #     else
-    #         ARCH="64";
-    #     fi
-    # fi
-
-    # if [[ "$OS" == "Darwin" ]]; then
-    #     PLATFORM="osx";
-    #     if [[ "$ARCH" == "arm64" ]]; then
-    #         ARCH="arm64";
-    #     else
-    #         ARCH="64"
-    #     fi
-    # fi
 
     def run_cmd(cmd, stdin_str=None):
         result = subprocess.run(
@@ -350,12 +328,25 @@ if __name__ == "__main__":
         cmd = f"fast-initializer --prefix {prefix} --packages-dir {pkgs_dir}"
         run_cmd(cmd, all_package_urls)
 
-    if len(sys.argv) != 5:
-        print("Usage: bootstrap.py <flow_name> <id> <datastore_type> <architecture>")
+    if len(sys.argv) != 4:
+        print("Usage: bootstrap.py <flow_name> <id> <datastore_type>")
         sys.exit(1)
 
     try:
-        _, flow_name, id_, datastore_type, architecture = sys.argv
+        _, flow_name, id_, datastore_type = sys.argv
+
+        system = platform.system().lower()
+        arch_machine = platform.machine().lower()
+
+        if system == "darwin" and arch_machine == "arm64":
+            architecture = "osx-arm64"
+        elif system == "darwin":
+            architecture = "osx-64"
+        elif system == "linux" and arch_machine == "aarch64":
+            architecture = "linux-aarch64"
+        else:
+            # default fallback
+            architecture = "linux-64"
 
         prefix = os.path.join(os.getcwd(), architecture, id_)
         pkgs_dir = os.path.join(os.getcwd(), ".pkgs")