metaflow 2.12.3__tar.gz → 2.12.5__tar.gz

{metaflow-2.12.3/metaflow.egg-info → metaflow-2.12.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: metaflow
-Version: 2.12.3
+Version: 2.12.5
 Summary: Metaflow: More Data Science, 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.12.3; extra == "stubs"
+Requires-Dist: metaflow-stubs==2.12.5; extra == "stubs"
 
 ![Metaflow_Logo_Horizontal_FullColor_Ribbon_Dark_RGB](https://user-images.githubusercontent.com/763451/89453116-96a57e00-d713-11ea-9fa6-82b29d4d6eff.png)
 

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/R.py

@@ -3,6 +3,7 @@ import sys
 from importlib import util as imp_util, machinery as imp_machinery
 from tempfile import NamedTemporaryFile
 
+from . import parameters
 from .util import to_bytes
 
 R_FUNCTIONS = {}
@@ -125,15 +126,17 @@ def run(
     flow = module.FLOW(use_cli=False)
 
     from . import exception
-    from . import cli
 
     try:
-        cli.main(
-            flow,
-            args=metaflow_args,
-            handle_exceptions=False,
-            entrypoint=full_cmdline[: -len(metaflow_args)],
-        )
+        with parameters.flow_context(flow.__class__) as _:
+            from . import cli
+
+            cli.main(
+                flow,
+                args=metaflow_args,
+                handle_exceptions=False,
+                entrypoint=full_cmdline[: -len(metaflow_args)],
+            )
     except exception.MetaflowException as e:
         cli.print_metaflow_exception(e)
         os.remove(tmp.name)

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/cli.py

@@ -946,7 +946,7 @@ def start(
     ctx.obj.environment = [
         e for e in ENVIRONMENTS + [MetaflowEnvironment] if e.TYPE == environment
     ][0](ctx.obj.flow)
-    ctx.obj.environment.validate_environment(echo, datastore)
+    ctx.obj.environment.validate_environment(ctx.obj.logger, datastore)
 
     ctx.obj.event_logger = LOGGING_SIDECARS[event_logger](
         flow=ctx.obj.flow, env=ctx.obj.environment

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/client/core.py

@@ -268,11 +268,13 @@ class MetaflowObject(object):
         _object: Optional["MetaflowObject"] = None,
         _parent: Optional["MetaflowObject"] = None,
         _namespace_check: bool = True,
+        _current_namespace: Optional[str] = None,
     ):
         self._metaflow = Metaflow()
         self._parent = _parent
         self._path_components = None
         self._attempt = attempt
+        self._current_namespace = _current_namespace or get_namespace()
         self._namespace_check = _namespace_check
 
         if self._attempt is not None:
@@ -339,8 +341,8 @@ class MetaflowObject(object):
         self._user_tags = frozenset(self._object.get("tags") or [])
         self._system_tags = frozenset(self._object.get("system_tags") or [])
 
-        if self._namespace_check and not self.is_in_namespace():
-            raise MetaflowNamespaceMismatch(current_namespace)
+        if self._namespace_check and not self._is_in_namespace(self._current_namespace):
+            raise MetaflowNamespaceMismatch(self._current_namespace)
 
     def _get_object(self, *path_components):
         result = self._metaflow.metadata.get_object(
@@ -365,8 +367,8 @@ class MetaflowObject(object):
         query_filter = {}
 
         # skip namespace filtering if _namespace_check is unset.
-        if self._namespace_check and current_namespace:
-            query_filter = {"any_tags": current_namespace}
+        if self._namespace_check and self._current_namespace:
+            query_filter = {"any_tags": self._current_namespace}
 
         unfiltered_children = self._metaflow.metadata.get_object(
             self._NAME,
@@ -383,7 +385,10 @@ class MetaflowObject(object):
                     attempt=self._attempt,
                     _object=obj,
                     _parent=self,
-                    _namespace_check=False,
+                    _namespace_check=self._namespace_check,
+                    _current_namespace=self._current_namespace
+                    if self._namespace_check
+                    else None,
                 )
                 for obj in unfiltered_children
             ),
@@ -422,6 +427,23 @@ class MetaflowObject(object):
 
         If the current namespace is None, this will always return True.
 
+        Returns
+        -------
+        bool
+            Whether or not the object is in the current namespace
+        """
+        return self._is_in_namespace(current_namespace)
+
+    def _is_in_namespace(self, ns: str) -> bool:
+        """
+        Returns whether this object is in namespace passed in.
+
+        If the current namespace is None, this will always return True.
+
+        Parameters
+        ----------
+        ns : str
+            Namespace to check if the object is in.
         Returns
         -------
         bool
@@ -430,7 +452,7 @@ class MetaflowObject(object):
         if self._NAME == "flow":
             return any(True for _ in self)
         else:
-            return current_namespace is None or current_namespace in self._tags
+            return ns is None or ns in self._tags
 
     def __str__(self):
         if self._attempt is not None:
@@ -479,6 +501,9 @@ class MetaflowObject(object):
                 _object=obj,
                 _parent=self,
                 _namespace_check=self._namespace_check,
+                _current_namespace=self._current_namespace
+                if self._namespace_check
+                else None,
             )
         else:
             raise KeyError(id)
@@ -509,7 +534,20 @@ class MetaflowObject(object):
             pathspec=pathspec, attempt=attempt, _namespace_check=namespace_check
         )
 
-    _UNPICKLE_FUNC = {"2.8.4": _unpickle_284}
+    def _unpickle_2124(self, data):
+        if len(data) != 4:
+            raise MetaflowInternalError(
+                "Unexpected size of array: {}".format(len(data))
+            )
+        pathspec, attempt, ns, namespace_check = data
+        self.__init__(
+            pathspec=pathspec,
+            attempt=attempt,
+            _namespace_check=namespace_check,
+            _current_namespace=ns,
+        )
+
+    _UNPICKLE_FUNC = {"2.8.4": _unpickle_284, "2.12.4": _unpickle_2124}
 
     def __setstate__(self, state):
         """
@@ -529,12 +567,13 @@ class MetaflowObject(object):
             self._UNPICKLE_FUNC[version](self, state["data"])
         else:
             # For backward compatibility: handles pickled objects that were serialized without a __getstate__ override
-            # We set namespace_check to False if it doesn't exist for the same
-            # reason as the one listed in __getstate__
+            # We set namespace_check to False if it doesn't exist so that the user can
+            # continue accessing this object once unpickled.
             self.__init__(
                 pathspec=state.get("_pathspec", None),
                 attempt=state.get("_attempt", None),
                 _namespace_check=state.get("_namespace_check", False),
+                _current_namespace=None,
             )
 
     def __getstate__(self):
@@ -546,16 +585,17 @@ class MetaflowObject(object):
         from this object) are pickled (serialized) in a later version of Metaflow, it may not be possible
         to unpickle (deserialize) them in a previous version of Metaflow.
         """
-        # Note that we set _namespace_check to False because we want the user to
-        # be able to access this object even after unpickling it. If we set it to
-        # True, it would check the namespace again at the time of unpickling even
-        # if the user properly got the object in the first place and pickled it.
+        # Note that we now record the namespace at the time of the object creation so
+        # we don't need to force namespace_check to be False and can properly continue
+        # checking for the namespace even after unpickling since we will know which
+        # namespace to check.
         return {
-            "version": "2.8.4",
+            "version": "2.12.4",
             "data": [
                 self.pathspec,
                 self._attempt,
-                False,
+                self._current_namespace,
+                self._namespace_check,
             ],
         }
 

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/decorators.py

@@ -11,6 +11,8 @@ from .exception import (
     InvalidDecoratorAttribute,
 )
 
+from .parameters import current_flow
+
 from metaflow._vendor import click
 
 try:
@@ -174,13 +176,9 @@ class Decorator(object):
 
 
 class FlowDecorator(Decorator):
-    _flow_decorators = []
     options = {}
 
     def __init__(self, *args, **kwargs):
-        # Note that this assumes we are executing one flow per process, so we have a global list of
-        # _flow_decorators. A similar setup is used in parameters.
-        self._flow_decorators.append(self)
         super(FlowDecorator, self).__init__(*args, **kwargs)
 
     def flow_init(
@@ -206,7 +204,10 @@ class FlowDecorator(Decorator):
 # compare this to parameters.add_custom_parameters
 def add_decorator_options(cmd):
     seen = {}
-    for deco in flow_decorators():
+    flow_cls = getattr(current_flow, "flow_cls", None)
+    if flow_cls is None:
+        return cmd
+    for deco in flow_decorators(flow_cls):
         for option, kwargs in deco.options.items():
             if option in seen:
                 msg = (
@@ -222,8 +223,8 @@ def add_decorator_options(cmd):
     return cmd
 
 
-def flow_decorators():
-    return FlowDecorator._flow_decorators
+def flow_decorators(flow_cls):
+    return [d for deco_list in flow_cls._flow_decorators.values() for d in deco_list]
 
 
 class StepDecorator(Decorator):

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/flowspec.py

@@ -53,7 +53,18 @@ class ParallelUBF(UnboundedForeachInput):
         return item or 0  # item is None for the control task, but it is also split 0
 
 
-class FlowSpec(object):
+class _FlowSpecMeta(type):
+    def __new__(cls, name, bases, dct):
+        f = super().__new__(cls, name, bases, dct)
+        # This makes sure to give _flow_decorators to each
+        # child class (and not share it with the FlowSpec base
+        # class). This is important to not make a "global"
+        # _flow_decorators
+        f._flow_decorators = {}
+        return f
+
+
+class FlowSpec(metaclass=_FlowSpecMeta):
     """
     Main class from which all Flows should inherit.
 
@@ -83,8 +94,6 @@ class FlowSpec(object):
     # names starting with `_` as those are already excluded from `_get_parameters`.
     _NON_PARAMETERS = {"cmd", "foreach_stack", "index", "input", "script_name", "name"}
 
-    _flow_decorators = {}
-
     def __init__(self, use_cli=True):
         """
         Construct a FlowSpec
@@ -104,15 +113,11 @@ class FlowSpec(object):
         self._graph = FlowGraph(self.__class__)
         self._steps = [getattr(self, node.name) for node in self._graph]
 
-        # This must be set before calling cli.main() below (or specifically, add_custom_parameters)
-        parameters.parameters = [p for _, p in self._get_parameters()]
-
         if use_cli:
-            # we import cli here to make sure custom parameters in
-            # args.py get fully evaluated before cli.py is imported.
-            from . import cli
+            with parameters.flow_context(self.__class__) as _:
+                from . import cli
 
-            cli.main(self)
+                cli.main(self)
 
     @property
     def script_name(self) -> str:
@@ -192,18 +197,19 @@ class FlowSpec(object):
                     "attributes": deco.attributes,
                     "statically_defined": deco.statically_defined,
                 }
-                for deco in flow_decorators()
+                for deco in flow_decorators(self)
                 if not deco.name.startswith("_")
             ],
         }
         self._graph_info = graph_info
 
-    def _get_parameters(self):
-        for var in dir(self):
-            if var[0] == "_" or var in self._NON_PARAMETERS:
+    @classmethod
+    def _get_parameters(cls):
+        for var in dir(cls):
+            if var[0] == "_" or var in cls._NON_PARAMETERS:
                 continue
             try:
-                val = getattr(self, var)
+                val = getattr(cls, var)
             except:
                 continue
             if isinstance(val, Parameter):

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/parameters.py

@@ -1,4 +1,8 @@
 import json
+
+from contextlib import contextmanager
+from threading import local
+
 from typing import Any, Callable, Dict, NamedTuple, Optional, Type, Union
 
 from metaflow._vendor import click
@@ -31,7 +35,40 @@ ParameterContext = NamedTuple(
     ],
 )
 
-parameters = []  # Set by FlowSpec.__init__()
+
+# When we launch a flow, we need to know the parameters so we can
+# attach them with add_custom_parameters to commands. This used to be a global
+# but causes problems when multiple FlowSpec are loaded (as can happen when using
+# the Runner or just if multiple Flows are defined and instantiated). To minimally
+# impact code, we now create the CLI with a thread local value of the FlowSpec
+# that is being used to create the CLI which enables us to extract the parameters
+# directly from the Flow.
+current_flow = local()
+
+
+@contextmanager
+def flow_context(flow_cls):
+    """
+    Context manager to set the current flow for the thread. This is used
+    to extract the parameters from the FlowSpec that is being used to create
+    the CLI.
+    """
+    # Use a stack because with the runner this can get called multiple times in
+    # a nested fashion
+    current_flow.flow_cls_stack = getattr(current_flow, "flow_cls_stack", [])
+    current_flow.flow_cls_stack.insert(0, flow_cls)
+    current_flow.flow_cls = current_flow.flow_cls_stack[0]
+    try:
+        yield
+    finally:
+        current_flow.flow_cls_stack = current_flow.flow_cls_stack[1:]
+        if len(current_flow.flow_cls_stack) == 0:
+            del current_flow.flow_cls_stack
+            del current_flow.flow_cls
+        else:
+            current_flow.flow_cls = current_flow.flow_cls_stack[0]
+
+
 context_proto = None
 
 
@@ -391,6 +428,10 @@ def add_custom_parameters(deploy_mode=False):
         cmd.has_flow_params = True
         # Iterate over parameters in reverse order so cmd.params lists options
         # in the order they are defined in the FlowSpec subclass
+        flow_cls = getattr(current_flow, "flow_cls", None)
+        if flow_cls is None:
+            return cmd
+        parameters = [p for _, p in flow_cls._get_parameters()]
         for arg in parameters[::-1]:
             kwargs = arg.option_kwargs(deploy_mode)
             cmd.params.insert(0, click.Option(("--" + arg.name,), **kwargs))

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/plugins/airflow/airflow.py

@@ -539,7 +539,7 @@ class Airflow(object):
         # FlowDecorators can define their own top-level options. They are
         # responsible for adding their own top-level options and values through
         # the get_top_level_options() hook. See similar logic in runtime.py.
-        for deco in flow_decorators():
+        for deco in flow_decorators(self.flow):
             top_opts_dict.update(deco.get_top_level_options())
 
         top_opts = list(dict_to_cli_options(top_opts_dict))

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/plugins/airflow/sensors/base_sensor.py

@@ -1,5 +1,5 @@
 import uuid
-from metaflow.decorators import FlowDecorator
+from metaflow.decorators import FlowDecorator, flow_decorators
 from ..exception import AirflowException
 from ..airflow_utils import AirflowTask, id_creator, TASK_ID_HASH_LEN
 
@@ -49,7 +49,7 @@ class AirflowSensorDecorator(FlowDecorator):
             operator_type=self.operator_type,
         ).set_operator_args(**{k: v for k, v in task_args.items() if v is not None})
 
-    def validate(self):
+    def validate(self, flow):
         """
         Validate if the arguments for the sensor are correct.
         """
@@ -58,7 +58,7 @@ class AirflowSensorDecorator(FlowDecorator):
         if self.attributes["name"] is None:
             deco_index = [
                 d._id
-                for d in self._flow_decorators
+                for d in flow_decorators(flow)
                 if issubclass(d.__class__, AirflowSensorDecorator)
             ].index(self._id)
             self._airflow_task_name = "%s-%s" % (
@@ -71,4 +71,4 @@ class AirflowSensorDecorator(FlowDecorator):
     def flow_init(
         self, flow, graph, environment, flow_datastore, metadata, logger, echo, options
     ):
-        self.validate()
+        self.validate(flow)

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/plugins/airflow/sensors/external_task_sensor.py

@@ -85,7 +85,7 @@ class ExternalTaskSensorDecorator(AirflowSensorDecorator):
             )
         return task_args
 
-    def validate(self):
+    def validate(self, flow):
         if self.attributes["external_dag_id"] is None:
             raise AirflowException(
                 "`%s` argument of `@%s`cannot be `None`."
@@ -131,4 +131,4 @@ class ExternalTaskSensorDecorator(AirflowSensorDecorator):
                         self.name,
                     )
                 )
-        super().validate()
+        super().validate(flow)

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/plugins/airflow/sensors/s3_sensor.py

@@ -58,9 +58,9 @@ class S3KeySensorDecorator(AirflowSensorDecorator):
         #  `verify` is a airflow variable.
     )
 
-    def validate(self):
+    def validate(self, flow):
         if self.attributes["bucket_key"] is None:
             raise AirflowException(
                 "`bucket_key` for `@%s`cannot be empty." % (self.name)
             )
-        super().validate()
+        super().validate(flow)

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/plugins/argo/argo_workflows.py

@@ -1237,7 +1237,7 @@ class ArgoWorkflows(object):
             # FlowDecorators can define their own top-level options. They are
             # responsible for adding their own top-level options and values through
             # the get_top_level_options() hook. See similar logic in runtime.py.
-            for deco in flow_decorators():
+            for deco in flow_decorators(self.flow):
                 top_opts_dict.update(deco.get_top_level_options())
 
             top_level = list(dict_to_cli_options(top_opts_dict)) + [

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/plugins/aws/step_functions/step_functions.py

@@ -881,7 +881,7 @@ class StepFunctions(object):
         # FlowDecorators can define their own top-level options. They are
         # responsible for adding their own top-level options and values through
         # the get_top_level_options() hook. See similar logic in runtime.py.
-        for deco in flow_decorators():
+        for deco in flow_decorators(self.flow):
             top_opts_dict.update(deco.get_top_level_options())
 
         top_opts = list(dict_to_cli_options(top_opts_dict))

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/plugins/cards/card_cli.py

@@ -388,6 +388,22 @@ def card_read_options_and_arguments(func):
     return wrapper
 
 
+def _extract_reload_token(data, task, mf_card):
+    if "render_seq" not in data:
+        return "never"
+
+    if data["render_seq"] == "final":
+        # final data update should always trigger a card reload to show
+        # the final card, hence a different token for the final update
+        return "final"
+    elif mf_card.RELOAD_POLICY == mf_card.RELOAD_POLICY_ALWAYS:
+        return "render-seq-%s" % data["render_seq"]
+    elif mf_card.RELOAD_POLICY == mf_card.RELOAD_POLICY_NEVER:
+        return "never"
+    elif mf_card.RELOAD_POLICY == mf_card.RELOAD_POLICY_ONCHANGE:
+        return mf_card.reload_content_token(task, data)
+
+
 def update_card(mf_card, mode, task, data, timeout_value=None):
     """
     This method will be responsible for creating a card/data-update based on the `mode`.
@@ -432,31 +448,21 @@ def update_card(mf_card, mode, task, data, timeout_value=None):
             - `timeout_stack_trace` : stack trace of the function if it timed out.
     """
 
-    def _reload_token():
-        if "render_seq" not in data:
-            return "never"
-
-        if data["render_seq"] == "final":
-            # final data update should always trigger a card reload to show
-            # the final card, hence a different token for the final update
-            return "final"
-        elif mf_card.RELOAD_POLICY == mf_card.RELOAD_POLICY_ALWAYS:
-            return "render-seq-%s" % data["render_seq"]
-        elif mf_card.RELOAD_POLICY == mf_card.RELOAD_POLICY_NEVER:
-            return "never"
-        elif mf_card.RELOAD_POLICY == mf_card.RELOAD_POLICY_ONCHANGE:
-            return mf_card.reload_content_token(task, data)
-
     def _add_token_html(html):
         if html is None:
             return None
-        return html.replace(mf_card.RELOAD_POLICY_TOKEN, _reload_token())
+        return html.replace(
+            mf_card.RELOAD_POLICY_TOKEN,
+            _extract_reload_token(data=data, task=task, mf_card=mf_card),
+        )
 
     def _add_token_json(json_msg):
         if json_msg is None:
             return None
         return {
-            "reload_token": _reload_token(),
+            "reload_token": _extract_reload_token(
+                data=data, task=task, mf_card=mf_card
+            ),
             "data": json_msg,
             "created_on": time.time(),
         }
@@ -740,8 +746,16 @@ def create(
     #   3. `refresh` is implemented but it raises an exception. (We do nothing. Don't store anything.)
     #   4. `refresh` is implemented but it times out. (We do nothing. Don't store anything.)
 
+    def _render_error_card(stack_trace):
+        _card = error_card()
+        token = _extract_reload_token(data, task, _card)
+        return _card.render(
+            task,
+            stack_trace=stack_trace,
+        ).replace(mf_card.RELOAD_POLICY_TOKEN, token)
+
     if error_stack_trace is not None and mode != "refresh":
-        rendered_content = error_card().render(task, stack_trace=error_stack_trace)
+        rendered_content = _render_error_card(error_stack_trace)
     elif (
         rendered_info.is_implemented
         and rendered_info.timed_out
@@ -753,18 +767,15 @@ def create(
             "To increase the timeout duration for card rendering, please set the `timeout` parameter in the @card decorator. "
             "\nStack Trace : \n%s"
         ) % (timeout, rendered_info.timeout_stack_trace)
-        rendered_content = error_card().render(
-            task,
-            stack_trace=timeout_stack_trace,
-        )
+        rendered_content = _render_error_card(timeout_stack_trace)
     elif (
         rendered_info.is_implemented
         and rendered_info.data is None
         and render_error_card
         and mode != "refresh"
     ):
-        rendered_content = error_card().render(
-            task, stack_trace="No information rendered from card of type %s" % type
+        rendered_content = _render_error_card(
+            "No information rendered from card of type %s" % type
         )
     elif (
         not rendered_info.is_implemented
@@ -775,7 +786,7 @@ def create(
             "Card of type %s is a runtime time card with no `render_runtime` implemented. "
             "Please implement `render_runtime` method to allow rendering this card at runtime."
         ) % type
-        rendered_content = error_card().render(task, stack_trace=message)
+        rendered_content = _render_error_card(message)
 
     # todo : should we save native type for error card or error type ?
     if type is not None and re.match(CARD_ID_PATTERN, type) is not None:

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/plugins/cards/card_modules/basic.py

@@ -542,11 +542,24 @@ class ErrorCard(MetaflowCard):
 
     type = "error"
 
+    RELOAD_POLICY = MetaflowCard.RELOAD_POLICY_ONCHANGE
+
     def __init__(self, options={}, components=[], graph=None):
         self._only_repr = True
         self._graph = None if graph is None else transform_flow_graph(graph)
         self._components = components
 
+    def reload_content_token(self, task, data):
+        """
+        The reload token will change when the component array has changed in the Metaflow card.
+        The change in the component array is signified by the change in the component_update_ts.
+        """
+        if task.finished:
+            return "final"
+        # `component_update_ts` will never be None. It is set to a default value when the `ComponentStore` is instantiated
+        # And it is updated when components added / removed / changed from the `ComponentStore`.
+        return "runtime-%s" % (str(data["component_update_ts"]))
+
     def render(self, task, stack_trace=None):
         RENDER_TEMPLATE = read_file(RENDER_TEMPLATE_PATH)
         JS_DATA = read_file(JS_PATH)

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/plugins/env_escape/stub.py

@@ -146,7 +146,7 @@ class Stub(with_metaclass(StubMetaClass, object)):
             return object.__getattribute__(self, name)
 
     def __getattr__(self, name):
-        if name in DELETED_ATTRS:
+        if name in DELETED_ATTRS or self.___is_returned_exception___:
             raise AttributeError()
         return fwd_request(self, OP_GETATTR, name)
 
@@ -166,6 +166,8 @@ class Stub(with_metaclass(StubMetaClass, object)):
         ):
             object.__setattr__(self, name, value)
         else:
+            if self.___is_returned_exception___:
+                raise AttributeError()
             fwd_request(self, OP_SETATTR, name, value)
 
     def __dir__(self):

{metaflow-2.12.3 → metaflow-2.12.5}/metaflow/plugins/pypi/bootstrap.py

@@ -123,7 +123,7 @@ if __name__ == "__main__":
             [
                 f"""set -e;
                 export PATH=$PATH:$(pwd)/micromamba;
-                micromamba run --prefix {prefix} pip --disable-pip-version-check install --root-user-action=ignore --no-compile {pypi_pkgs_dir}/*.whl"""
+                micromamba run --prefix {prefix} python -m pip --disable-pip-version-check install --root-user-action=ignore --no-compile {pypi_pkgs_dir}/*.whl --no-user"""
             ]
         )