ob-metaflow 2.12.36.2__tar.gz → 2.12.39.1__tar.gz

{ob_metaflow-2.12.36.2/ob_metaflow.egg-info → ob_metaflow-2.12.39.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ob-metaflow
-Version: 2.12.36.2
+Version: 2.12.39.1
 Summary: Metaflow: More Data Science, Less Engineering
 Author: Netflix, Outerbounds & the Metaflow Community
 Author-email: help@outerbounds.co
@@ -12,7 +12,7 @@ Requires-Dist: boto3
 Requires-Dist: pylint
 Requires-Dist: kubernetes
 Provides-Extra: stubs
-Requires-Dist: metaflow-stubs==2.12.36.2; extra == "stubs"
+Requires-Dist: metaflow-stubs==2.12.39.1; extra == "stubs"
 
 ![Metaflow_Logo_Horizontal_FullColor_Ribbon_Dark_RGB](https://user-images.githubusercontent.com/763451/89453116-96a57e00-d713-11ea-9fa6-82b29d4d6eff.png)
 

{ob_metaflow-2.12.36.2 → ob_metaflow-2.12.39.1}/metaflow/plugins/argo/argo_workflows_deployer_objects.py

@@ -1,5 +1,6 @@
 import sys
 import json
+import time
 import tempfile
 from typing import ClassVar, Optional
 
@@ -170,6 +171,47 @@ class ArgoWorkflowsTriggeredRun(TriggeredRun):
         command_obj.sync_wait()
         return command_obj.process.returncode == 0
 
+    def wait_for_completion(self, timeout: Optional[int] = None):
+        """
+        Wait for the workflow to complete or timeout.
+
+        Parameters
+        ----------
+        timeout : int, optional, default None
+            Maximum time in seconds to wait for workflow completion.
+            If None, waits indefinitely.
+
+        Raises
+        ------
+        TimeoutError
+            If the workflow does not complete within the specified timeout period.
+        """
+        start_time = time.time()
+        check_interval = 5
+        while self.is_running:
+            if timeout is not None and (time.time() - start_time) > timeout:
+                raise TimeoutError(
+                    "Workflow did not complete within specified timeout."
+                )
+            time.sleep(check_interval)
+
+    @property
+    def is_running(self):
+        """
+        Check if the workflow is currently running.
+
+        Returns
+        -------
+        bool
+            True if the workflow status is either 'Pending' or 'Running',
+            False otherwise.
+        """
+        workflow_status = self.status
+        # full list of all states present here:
+        # https://github.com/argoproj/argo-workflows/blob/main/pkg/apis/workflow/v1alpha1/workflow_types.go#L54
+        # we only consider non-terminal states to determine if the workflow has not finished
+        return workflow_status is not None and workflow_status in ["Pending", "Running"]
+
     @property
     def status(self) -> Optional[str]:
         """

ob_metaflow-2.12.39.1/metaflow/plugins/pypi/bootstrap.py

@@ -0,0 +1,275 @@
+import bz2
+import concurrent.futures
+import io
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tarfile
+import time
+
+import requests
+
+from metaflow.metaflow_config import DATASTORE_LOCAL_DIR
+from metaflow.plugins import DATASTORES
+from metaflow.util import which
+
+from . import MAGIC_FILE, _datastore_packageroot
+
+# Bootstraps a valid conda virtual environment composed of conda and pypi packages
+
+
+def timer(func):
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        duration = time.time() - start_time
+        # print(f"Time taken for {func.__name__}: {duration:.2f} seconds")
+        return result
+
+    return wrapper
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 5:
+        print("Usage: bootstrap.py <flow_name> <id> <datastore_type> <architecture>")
+        sys.exit(1)
+    _, flow_name, id_, datastore_type, architecture = sys.argv
+
+    # 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
+
+    prefix = os.path.join(os.getcwd(), architecture, id_)
+    pkgs_dir = os.path.join(os.getcwd(), ".pkgs")
+    conda_pkgs_dir = os.path.join(pkgs_dir, "conda")
+    pypi_pkgs_dir = os.path.join(pkgs_dir, "pypi")
+    manifest_dir = os.path.join(os.getcwd(), DATASTORE_LOCAL_DIR, flow_name)
+
+    datastores = [d for d in DATASTORES if d.TYPE == datastore_type]
+    if not datastores:
+        print(f"No datastore found for type: {datastore_type}")
+        sys.exit(1)
+
+    storage = datastores[0](
+        _datastore_packageroot(datastores[0], lambda *args, **kwargs: None)
+    )
+
+    # Move MAGIC_FILE inside local datastore.
+    os.makedirs(manifest_dir, exist_ok=True)
+    shutil.move(
+        os.path.join(os.getcwd(), MAGIC_FILE),
+        os.path.join(manifest_dir, MAGIC_FILE),
+    )
+    with open(os.path.join(manifest_dir, MAGIC_FILE)) as f:
+        env = json.load(f)[id_][architecture]
+
+    def run_cmd(cmd):
+        result = subprocess.run(
+            cmd, shell=True, 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)
+
+    @timer
+    def install_micromamba(architecture):
+        micromamba_dir = os.path.join(os.getcwd(), "micromamba")
+        micromamba_path = os.path.join(micromamba_dir, "bin", "micromamba")
+
+        if which("micromamba"):
+            return which("micromamba")
+        if os.path.exists(micromamba_path):
+            os.environ["PATH"] += os.pathsep + os.path.dirname(micromamba_path)
+            return micromamba_path
+
+        # Download and extract in one go
+        # TODO: Serve from cloudflare
+        url = f"https://micro.mamba.pm/api/micromamba/{architecture}/2.0.4"
+
+        # Prepare directory once
+        os.makedirs(os.path.dirname(micromamba_path), exist_ok=True)
+
+        # Stream and process directly to file
+        with requests.get(url, stream=True, timeout=30) as response:
+            if response.status_code != 200:
+                raise Exception(
+                    f"Failed to download micromamba: HTTP {response.status_code}"
+                )
+
+            decompressor = bz2.BZ2Decompressor()
+
+            # Process in memory without temporary files
+            tar_content = decompressor.decompress(response.raw.read())
+
+            with tarfile.open(fileobj=io.BytesIO(tar_content), mode="r:") as tar:
+                member = tar.getmember("bin/micromamba")
+                # Extract directly to final location
+                with open(micromamba_path, "wb") as f:
+                    f.write(tar.extractfile(member).read())
+
+        # Set executable permission
+        os.chmod(micromamba_path, 0o755)
+
+        # Update PATH only once at the end
+        os.environ["PATH"] += os.pathsep + os.path.dirname(micromamba_path)
+        return micromamba_path
+
+    @timer
+    def download_conda_packages(storage, packages, dest_dir):
+
+        def process_conda_package(args):
+            # Ensure that conda packages go into architecture specific folders.
+            # The path looks like REPO/CHANNEL/CONDA_SUBDIR/PACKAGE. We trick
+            # Micromamba into believing that all packages are coming from a local
+            # channel - the only hurdle is ensuring that packages are organised
+            # properly.
+            key, tmpfile, dest_dir = args
+            dest = os.path.join(dest_dir, "/".join(key.split("/")[-2:]))
+            os.makedirs(os.path.dirname(dest), exist_ok=True)
+            shutil.move(tmpfile, dest)
+
+        os.makedirs(dest_dir, exist_ok=True)
+        with storage.load_bytes([package["path"] for package in packages]) as results:
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                executor.map(
+                    process_conda_package,
+                    [(key, tmpfile, dest_dir) for key, tmpfile, _ in results],
+                )
+            # for key, tmpfile, _ in results:
+
+            #     # TODO: consider RAM disk
+            #     dest = os.path.join(dest_dir, "/".join(key.split("/")[-2:]))
+            #     os.makedirs(os.path.dirname(dest), exist_ok=True)
+            #     shutil.move(tmpfile, dest)
+        return dest_dir
+
+    @timer
+    def download_pypi_packages(storage, packages, dest_dir):
+
+        def process_pypi_package(args):
+            key, tmpfile, dest_dir = args
+            dest = os.path.join(dest_dir, os.path.basename(key))
+            shutil.move(tmpfile, dest)
+
+        os.makedirs(dest_dir, exist_ok=True)
+        with storage.load_bytes([package["path"] for package in packages]) as results:
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                executor.map(
+                    process_pypi_package,
+                    [(key, tmpfile, dest_dir) for key, tmpfile, _ in results],
+                )
+            # for key, tmpfile, _ in results:
+            #     dest = os.path.join(dest_dir, os.path.basename(key))
+            #     shutil.move(tmpfile, dest)
+        return dest_dir
+
+    @timer
+    def create_conda_environment(prefix, conda_pkgs_dir):
+        cmd = f'''set -e;
+            tmpfile=$(mktemp);
+            echo "@EXPLICIT" > "$tmpfile";
+            ls -d {conda_pkgs_dir}/*/* >> "$tmpfile";
+            export PATH=$PATH:$(pwd)/micromamba;
+            export CONDA_PKGS_DIRS=$(pwd)/micromamba/pkgs;
+            export MAMBA_NO_LOW_SPEED_LIMIT=1;
+            export MAMBA_USE_INDEX_CACHE=1;
+            export MAMBA_NO_PROGRESS_BARS=1;
+            export CONDA_FETCH_THREADS=1;
+            micromamba create --yes --offline --no-deps \
+                --safety-checks=disabled --no-extra-safety-checks \
+                --prefix {prefix} --file "$tmpfile" \
+                --no-pyc --no-rc --always-copy;
+            rm "$tmpfile"'''
+        run_cmd(cmd)
+
+    @timer
+    def install_pypi_packages(prefix, pypi_pkgs_dir):
+
+        cmd = f"""set -e;
+            export PATH=$PATH:$(pwd)/micromamba;
+            export CONDA_PKGS_DIRS=$(pwd)/micromamba/pkgs;
+            micromamba run --prefix {prefix} python -m pip --disable-pip-version-check \
+                install --root-user-action=ignore --no-compile --no-index \
+                --no-cache-dir --no-deps --prefer-binary \
+                --find-links={pypi_pkgs_dir}  --no-user \
+                --no-warn-script-location --no-input \
+                {pypi_pkgs_dir}/*.whl
+            """
+        run_cmd(cmd)
+
+    @timer
+    def setup_environment(
+        architecture, storage, env, prefix, conda_pkgs_dir, pypi_pkgs_dir
+    ):
+        with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
+            # install micromamba, download conda and pypi packages in parallel
+            futures = {
+                "micromamba": executor.submit(install_micromamba, architecture),
+                "conda_pkgs": executor.submit(
+                    download_conda_packages, storage, env["conda"], conda_pkgs_dir
+                ),
+            }
+            if "pypi" in env:
+                futures["pypi_pkgs"] = executor.submit(
+                    download_pypi_packages, storage, env["pypi"], pypi_pkgs_dir
+                )
+
+            # create conda environment after micromamba is installed and conda packages are downloaded
+            done, _ = concurrent.futures.wait(
+                [futures["micromamba"], futures["conda_pkgs"]],
+                return_when=concurrent.futures.ALL_COMPLETED,
+            )
+
+            for future in done:
+                future.result()
+
+            # start conda environment creation
+            futures["conda_env"] = executor.submit(
+                create_conda_environment, prefix, conda_pkgs_dir
+            )
+
+            if "pypi" in env:
+                # install pypi packages after conda environment is created and pypi packages are downloaded
+                done, _ = concurrent.futures.wait(
+                    [futures["conda_env"], futures["pypi_pkgs"]],
+                    return_when=concurrent.futures.ALL_COMPLETED,
+                )
+
+                for future in done:
+                    future.result()
+
+                # install pypi packages
+                futures["pypi_install"] = executor.submit(
+                    install_pypi_packages, prefix, pypi_pkgs_dir
+                )
+                # wait for pypi packages to be installed
+                futures["pypi_install"].result()
+            else:
+                # wait for conda environment to be created
+                futures["conda_env"].result()
+
+    setup_environment(architecture, storage, env, prefix, conda_pkgs_dir, pypi_pkgs_dir)

{ob_metaflow-2.12.36.2 → ob_metaflow-2.12.39.1}/metaflow/plugins/pypi/conda_environment.py

@@ -5,10 +5,11 @@ import functools
 import io
 import json
 import os
-import sys
 import tarfile
+import threading
 import time
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from functools import wraps
 from hashlib import sha256
 from io import BufferedIOBase, BytesIO
 from itertools import chain
@@ -50,7 +51,6 @@ class CondaEnvironment(MetaflowEnvironment):
 
     def validate_environment(self, logger, datastore_type):
         self.datastore_type = datastore_type
-        self.logger = logger
 
         # Avoiding circular imports.
         from metaflow.plugins import DATASTORES
@@ -62,8 +62,21 @@ class CondaEnvironment(MetaflowEnvironment):
         from .micromamba import Micromamba
         from .pip import Pip
 
-        micromamba = Micromamba()
-        self.solvers = {"conda": micromamba, "pypi": Pip(micromamba)}
+        print_lock = threading.Lock()
+
+        def make_thread_safe(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                with print_lock:
+                    return func(*args, **kwargs)
+
+            return wrapper
+
+        self.logger = make_thread_safe(logger)
+
+        # TODO: Wire up logging
+        micromamba = Micromamba(self.logger)
+        self.solvers = {"conda": micromamba, "pypi": Pip(micromamba, self.logger)}
 
     def init_environment(self, echo, only_steps=None):
         # The implementation optimizes for latency to ensure as many operations can
@@ -150,6 +163,9 @@ class CondaEnvironment(MetaflowEnvironment):
                 (
                     package["path"],
                     # Lazily fetch package from the interweb if needed.
+                    # TODO: Depending on the len_hint, the package might be downloaded from
+                    #       the interweb prematurely. save_bytes needs to be adjusted to handle
+                    #       this scenario.
                     LazyOpen(
                         package["local_path"],
                         "rb",
@@ -166,22 +182,60 @@ class CondaEnvironment(MetaflowEnvironment):
                 if id_ in dirty:
                     self.write_to_environment_manifest([id_, platform, type_], packages)
 
-        # First resolve environments through Conda, before PyPI.
+        storage = None
+        if self.datastore_type not in ["local"]:
+            # Initialize storage for caching if using a remote datastore
+            storage = self.datastore(_datastore_packageroot(self.datastore, echo))
+
         self.logger("Bootstrapping virtual environment(s) ...")
-        for solver in ["conda", "pypi"]:
-            with ThreadPoolExecutor() as executor:
-                results = list(
-                    executor.map(lambda x: solve(*x, solver), environments(solver))
-                )
-            _ = list(map(lambda x: self.solvers[solver].download(*x), results))
-            with ThreadPoolExecutor() as executor:
-                _ = list(
-                    executor.map(lambda x: self.solvers[solver].create(*x), results)
-                )
-            if self.datastore_type not in ["local"]:
-                # Cache packages only when a remote datastore is in play.
-                storage = self.datastore(_datastore_packageroot(self.datastore, echo))
-                cache(storage, results, solver)
+        # Sequence of operations:
+        #  1. Start all conda solves in parallel
+        #  2. Download conda packages sequentially
+        #  3. Create and cache conda environments in parallel
+        #  4. Start PyPI solves in parallel after each conda environment is created
+        #  5. Download PyPI packages sequentially
+        #  6. Create and cache PyPI environments in parallel
+
+        with ThreadPoolExecutor() as executor:
+            # Start all conda solves in parallel
+            conda_futures = [
+                executor.submit(lambda x: solve(*x, "conda"), env)
+                for env in environments("conda")
+            ]
+
+            pypi_envs = {env[0]: env for env in environments("pypi")}
+            pypi_futures = []
+
+            # Process conda results sequentially for downloads
+            for future in as_completed(conda_futures):
+                result = future.result()
+                # Sequential conda download
+                self.solvers["conda"].download(*result)
+                # Parallel conda create and cache
+                create_future = executor.submit(self.solvers["conda"].create, *result)
+                if storage:
+                    executor.submit(cache, storage, [result], "conda")
+
+                # Queue PyPI solve to start after conda create
+                if result[0] in pypi_envs:
+
+                    def pypi_solve(env):
+                        create_future.result()  # Wait for conda create
+                        return solve(*env, "pypi")
+
+                    pypi_futures.append(
+                        executor.submit(pypi_solve, pypi_envs[result[0]])
+                    )
+
+            # Process PyPI results sequentially for downloads
+            for solve_future in pypi_futures:
+                result = solve_future.result()
+                # Sequential PyPI download
+                self.solvers["pypi"].download(*result)
+                # Parallel PyPI create and cache
+                executor.submit(self.solvers["pypi"].create, *result)
+                if storage:
+                    executor.submit(cache, storage, [result], "pypi")
         self.logger("Virtual environment(s) bootstrapped!")
 
     def executable(self, step_name, default=None):
@@ -385,7 +439,8 @@ class CondaEnvironment(MetaflowEnvironment):
                 'DISABLE_TRACING=True python -m metaflow.plugins.pypi.bootstrap "%s" %s "%s" linux-64'
                 % (self.flow.name, id_, self.datastore_type),
                 "echo 'Environment bootstrapped.'",
-                "export PATH=$PATH:$(pwd)/micromamba",
+                # To avoid having to install micromamba in the PATH in micromamba.py, we add it to the PATH here.
+                "export PATH=$PATH:$(pwd)/micromamba/bin",
             ]
         else:
             # for @conda/@pypi(disabled=True).

{ob_metaflow-2.12.36.2 → ob_metaflow-2.12.39.1}/metaflow/plugins/pypi/micromamba.py

@@ -1,7 +1,9 @@
+import functools
 import json
 import os
 import subprocess
 import tempfile
+import time
 
 from metaflow.exception import MetaflowException
 from metaflow.util import which
@@ -19,8 +21,11 @@ class MicromambaException(MetaflowException):
         super(MicromambaException, self).__init__(msg)
 
 
+GLIBC_VERSION = os.environ.get("CONDA_OVERRIDE_GLIBC", "2.38")
+
+
 class Micromamba(object):
-    def __init__(self):
+    def __init__(self, logger=None):
         # micromamba is a tiny version of the mamba package manager and comes with
         # metaflow specific performance enhancements.
 
@@ -33,6 +38,12 @@ class Micromamba(object):
             os.path.expanduser(_home),
             "micromamba",
         )
+
+        if logger:
+            self.logger = logger
+        else:
+            self.logger = lambda *args, **kwargs: None  # No-op logger if not provided
+
         self.bin = (
             which(os.environ.get("METAFLOW_PATH_TO_MICROMAMBA") or "micromamba")
             or which("./micromamba")  # to support remote execution
@@ -70,6 +81,9 @@ class Micromamba(object):
                 "MAMBA_ADD_PIP_AS_PYTHON_DEPENDENCY": "true",
                 "CONDA_SUBDIR": platform,
                 # "CONDA_UNSATISFIABLE_HINTS_CHECK_DEPTH": "0" # https://github.com/conda/conda/issues/9862
+                # Add a default glibc version for linux-64 environments (ignored for other platforms)
+                # TODO: Make the version configurable
+                "CONDA_OVERRIDE_GLIBC": GLIBC_VERSION,
             }
             cmd = [
                 "create",
@@ -78,6 +92,7 @@ class Micromamba(object):
                 "--dry-run",
                 "--no-extra-safety-checks",
                 "--repodata-ttl=86400",
+                "--safety-checks=disabled",
                 "--retry-clean-cache",
                 "--prefix=%s/prefix" % tmp_dir,
             ]
@@ -91,10 +106,11 @@ class Micromamba(object):
                 cmd.append("python==%s" % python)
             # TODO: Ensure a human readable message is returned when the environment
             #       can't be resolved for any and all reasons.
-            return [
+            solved_packages = [
                 {k: v for k, v in item.items() if k in ["url"]}
                 for item in self._call(cmd, env)["actions"]["LINK"]
             ]
+            return solved_packages
 
     def download(self, id_, packages, python, platform):
         # Unfortunately all the packages need to be catalogued in package cache
@@ -103,8 +119,6 @@ class Micromamba(object):
         # Micromamba is painfully slow in determining if many packages are infact
         # already cached. As a perf heuristic, we check if the environment already
         # exists to short circuit package downloads.
-        if self.path_to_environment(id_, platform):
-            return
 
         prefix = "{env_dirs}/{keyword}/{platform}/{id}".format(
             env_dirs=self.info()["envs_dirs"][0],
@@ -113,13 +127,18 @@ class Micromamba(object):
             id=id_,
         )
 
-        # Another forced perf heuristic to skip cross-platform downloads.
+        # cheap check
         if os.path.exists(f"{prefix}/fake.done"):
             return
 
+        # somewhat expensive check
+        if self.path_to_environment(id_, platform):
+            return
+
         with tempfile.TemporaryDirectory() as tmp_dir:
             env = {
                 "CONDA_SUBDIR": platform,
+                "CONDA_OVERRIDE_GLIBC": GLIBC_VERSION,
             }
             cmd = [
                 "create",
@@ -159,6 +178,7 @@ class Micromamba(object):
             # use hardlinks when possible, otherwise copy files
             # disabled for now since it adds to environment creation latencies
             "CONDA_ALLOW_SOFTLINKS": "0",
+            "CONDA_OVERRIDE_GLIBC": GLIBC_VERSION,
         }
         cmd = [
             "create",
@@ -174,6 +194,7 @@ class Micromamba(object):
             cmd.append("{url}".format(**package))
         self._call(cmd, env)
 
+    @functools.lru_cache(maxsize=None)
     def info(self):
         return self._call(["config", "list", "-a"])
 
@@ -198,18 +219,24 @@ class Micromamba(object):
         }
         directories = self.info()["pkgs_dirs"]
         # search all package caches for packages
-        metadata = {
-            url: os.path.join(d, file)
+
+        file_to_path = {}
+        for d in directories:
+            if os.path.isdir(d):
+                try:
+                    with os.scandir(d) as entries:
+                        for entry in entries:
+                            if entry.is_file():
+                                # Prefer the first occurrence if the file exists in multiple directories
+                                file_to_path.setdefault(entry.name, entry.path)
+                except OSError:
+                    continue
+        ret = {
+            # set package tarball local paths to None if package tarballs are missing
+            url: file_to_path.get(file)
             for url, file in packages_to_filenames.items()
-            for d in directories
-            if os.path.isdir(d)
-            and file in os.listdir(d)
-            and os.path.isfile(os.path.join(d, file))
         }
-        # set package tarball local paths to None if package tarballs are missing
-        for url in packages_to_filenames:
-            metadata.setdefault(url, None)
-        return metadata
+        return ret
 
     def interpreter(self, id_):
         return os.path.join(self.path_to_environment(id_), "bin/python")

{ob_metaflow-2.12.36.2 → ob_metaflow-2.12.39.1}/metaflow/plugins/pypi/pip.py

@@ -4,6 +4,7 @@ import re
 import shutil
 import subprocess
 import tempfile
+import time
 from concurrent.futures import ThreadPoolExecutor
 from itertools import chain, product
 from urllib.parse import unquote
@@ -50,10 +51,14 @@ INSTALLATION_MARKER = "{prefix}/.pip/id"
 
 
 class Pip(object):
-    def __init__(self, micromamba=None):
+    def __init__(self, micromamba=None, logger=None):
         # pip is assumed to be installed inside a conda environment managed by
         # micromamba. pip commands are executed using `micromamba run --prefix`
-        self.micromamba = micromamba or Micromamba()
+        self.micromamba = micromamba or Micromamba(logger)
+        if logger:
+            self.logger = logger
+        else:
+            self.logger = lambda *args, **kwargs: None  # No-op logger if not provided
 
     def solve(self, id_, packages, python, platform):
         prefix = self.micromamba.path_to_environment(id_)
@@ -123,7 +128,7 @@ class Pip(object):
                         **res,
                         subdir_str=(
                             "#subdirectory=%s" % subdirectory if subdirectory else ""
-                        )
+                        ),
                     )
                     # used to deduplicate the storage location in case wheel does not
                     # build with enough unique identifiers.

{ob_metaflow-2.12.36.2 → ob_metaflow-2.12.39.1}/metaflow/runner/utils.py

@@ -111,6 +111,11 @@ def read_from_fifo_when_ready(
     poll.register(fifo_fd, select.POLLIN)
     max_timeout = 3  # Wait for 10 * 3 = 30 ms after last write
     while True:
+        if check_process_exited(command_obj) and command_obj.process.returncode != 0:
+            raise CalledProcessError(
+                command_obj.process.returncode, command_obj.command
+            )
+
         if timeout < 0:
             raise TimeoutError("Timeout while waiting for the file content")
 

ob_metaflow-2.12.39.1/metaflow/version.py

@@ -0,0 +1 @@
+metaflow_version = "2.12.39.1"