metaflow 2.13.6__tar.gz → 2.13.8__tar.gz

{metaflow-2.13.6/metaflow.egg-info → metaflow-2.13.8}/PKG-INFO

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

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/decorators.py

@@ -591,9 +591,13 @@ def _init_flow_decorators(
                 )
         else:
             # Each "non-multiple" flow decorator is only allowed to have one set of options
+            # Note that there may be no deco_options if a MutableFlow config injected
+            # the decorator.
             deco_flow_init_options = {
-                option: deco_options[option.replace("-", "_")]
-                for option in deco.options
+                option: deco_options.get(
+                    option.replace("-", "_"), option_info["default"]
+                )
+                for option, option_info in deco.options.items()
             }
         for deco in decorators:
             deco.flow_init(

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/flowspec.py

@@ -86,6 +86,11 @@ class FlowSpecMeta(type):
         super().__init__(name, bases, attrs)
         if name == "FlowSpec":
             return
+
+        from .decorators import (
+            DuplicateFlowDecoratorException,
+        )  # Prevent circular import
+
         # We store some state in the flow class itself. This is primarily used to
         # attach global state to a flow. It is *not* an actual global because of
         # Runner/NBRunner. This is also created here in the meta class to avoid it being
@@ -98,6 +103,31 @@ class FlowSpecMeta(type):
         # Keys are _FlowState enum values
         cls._flow_state = {}
 
+        # We inherit stuff from our parent classes as well -- we need to be careful
+        # in terms of the order; we will follow the MRO with the following rules:
+        #  - decorators (cls._flow_decorators) will cause an error if they do not
+        #    support multiple and we see multiple instances of the same
+        #  - config decorators will be joined
+        #  - configs will be added later directly by the class; base class configs will
+        #    be taken into account as they would be inherited.
+
+        # We only need to do this for the base classes since the current class will
+        # get updated as decorators are parsed.
+        for base in cls.__mro__:
+            if base != cls and base != FlowSpec and issubclass(base, FlowSpec):
+                # Take care of decorators
+                for deco_name, deco in base._flow_decorators.items():
+                    if deco_name in cls._flow_decorators and not deco.allow_multiple:
+                        raise DuplicateFlowDecoratorException(deco_name)
+                    cls._flow_decorators.setdefault(deco_name, []).extend(deco)
+
+                # Take care of configs and config decorators
+                base_configs = base._flow_state.get(_FlowState.CONFIG_DECORATORS)
+                if base_configs:
+                    cls._flow_state.setdefault(_FlowState.CONFIG_DECORATORS, []).extend(
+                        base_configs
+                    )
+
         cls._init_attrs()
 
     def _init_attrs(cls):
@@ -196,7 +226,9 @@ class FlowSpec(metaclass=FlowSpecMeta):
     def _process_config_decorators(cls, config_options, ignore_errors=False):
 
         # Fast path for no user configurations
-        if not cls._flow_state.get(_FlowState.CONFIG_DECORATORS):
+        if not cls._flow_state.get(_FlowState.CONFIG_DECORATORS) and all(
+            len(step.config_decorators) == 0 for step in cls._steps
+        ):
             # Process parameters to allow them to also use config values easily
             for var, param in cls._get_parameters():
                 if param.IS_CONFIG_PARAMETER:

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/metaflow_config.py

@@ -433,6 +433,9 @@ CONDA_PACKAGE_GSROOT = from_conf("CONDA_PACKAGE_GSROOT")
 # should result in an appreciable speedup in flow environment initialization.
 CONDA_DEPENDENCY_RESOLVER = from_conf("CONDA_DEPENDENCY_RESOLVER", "conda")
 
+# Default to not using fast init binary.
+CONDA_USE_FAST_INIT = from_conf("CONDA_USE_FAST_INIT", False)
+
 ###
 # Escape hatch configuration
 ###

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/parameters.py

@@ -316,7 +316,7 @@ class Parameter(object):
     help : str, optional, default None
         Help text to show in `run --help`.
     required : bool, optional, default None
-        Require that the user specified a value for the parameter. Note that if
+        Require that the user specifies a value for the parameter. Note that if
         a default is provide, the required flag is ignored.
         A value of None is equivalent to False.
     show_default : bool, optional, default None

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/plugins/kubernetes/kubernetes_decorator.py

@@ -600,10 +600,10 @@ class KubernetesDecorator(StepDecorator):
             # local file system after the user code has finished execution.
             # This happens via datastore as a communication bridge.
 
-            # TODO:  There is no guarantee that task_prestep executes before
-            #        task_finished is invoked. That will result in AttributeError:
-            #        'KubernetesDecorator' object has no attribute 'metadata' error.
-            if self.metadata.TYPE == "local":
+            # TODO:  There is no guarantee that task_pre_step executes before
+            #        task_finished is invoked.
+            # For now we guard against the missing metadata object in this case.
+            if hasattr(self, "metadata") and self.metadata.TYPE == "local":
                 # Note that the datastore is *always* Amazon S3 (see
                 # runtime_task_created function).
                 sync_local_metadata_to_datastore(

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/plugins/pypi/bootstrap.py

@@ -10,7 +10,7 @@ import tarfile
 import time
 from urllib.error import URLError
 from urllib.request import urlopen
-from metaflow.metaflow_config import DATASTORE_LOCAL_DIR
+from metaflow.metaflow_config import DATASTORE_LOCAL_DIR, CONDA_USE_FAST_INIT
 from metaflow.plugins import DATASTORES
 from metaflow.plugins.pypi.utils import MICROMAMBA_MIRROR_URL, MICROMAMBA_URL
 from metaflow.util import which
@@ -19,6 +19,8 @@ import warnings
 
 from . import MAGIC_FILE, _datastore_packageroot
 
+FAST_INIT_BIN_URL = "https://fast-flow-init.outerbounds.sh/{platform}/fast-env-0.1.1.gz"
+
 # Bootstraps a valid conda virtual environment composed of conda and pypi packages
 
 
@@ -58,9 +60,14 @@ if __name__ == "__main__":
     #     fi
     # fi
 
-    def run_cmd(cmd):
+    def run_cmd(cmd, stdin_str=None):
         result = subprocess.run(
-            cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+            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}")
@@ -68,6 +75,58 @@ if __name__ == "__main__":
             print("Stderr:", result.stderr)
             sys.exit(1)
 
+    @timer
+    def install_fast_initializer(architecture):
+        import gzip
+
+        fast_initializer_path = os.path.join(
+            os.getcwd(), "fast-initializer", "bin", "fast-initializer"
+        )
+
+        if which("fast-initializer"):
+            return which("fast-initializer")
+        if os.path.exists(fast_initializer_path):
+            os.environ["PATH"] += os.pathsep + os.path.dirname(fast_initializer_path)
+            return fast_initializer_path
+
+        url = FAST_INIT_BIN_URL.format(platform=architecture)
+
+        # Prepare directory once
+        os.makedirs(os.path.dirname(fast_initializer_path), exist_ok=True)
+
+        # Download and decompress in one go
+        def _download_and_extract(url):
+            headers = {
+                "Accept-Encoding": "gzip, deflate, br",
+                "Connection": "keep-alive",
+                "User-Agent": "python-urllib",
+            }
+
+            max_retries = 3
+            for attempt in range(max_retries):
+                try:
+                    req = Request(url, headers=headers)
+                    with urlopen(req) as response:
+                        with gzip.GzipFile(fileobj=response) as gz:
+                            with open(fast_initializer_path, "wb") as f:
+                                f.write(gz.read())
+                    break
+                except (URLError, IOError) as e:
+                    if attempt == max_retries - 1:
+                        raise Exception(
+                            f"Failed to download fast-initializer after {max_retries} attempts: {e}"
+                        )
+                    time.sleep(2**attempt)
+
+        _download_and_extract(url)
+
+        # Set executable permission
+        os.chmod(fast_initializer_path, 0o755)
+
+        # Update PATH only once at the end
+        os.environ["PATH"] += os.pathsep + os.path.dirname(fast_initializer_path)
+        return fast_initializer_path
+
     @timer
     def install_micromamba(architecture):
         micromamba_dir = os.path.join(os.getcwd(), "micromamba")
@@ -268,6 +327,29 @@ if __name__ == "__main__":
                 # wait for conda environment to be created
                 futures["conda_env"].result()
 
+    @timer
+    def fast_setup_environment(architecture, storage, env, prefix, pkgs_dir):
+        install_fast_initializer(architecture)
+
+        # Get package urls
+        conda_pkgs = env["conda"]
+        pypi_pkgs = env.get("pypi", [])
+        conda_pkg_urls = [package["path"] for package in conda_pkgs]
+        pypi_pkg_urls = [package["path"] for package in pypi_pkgs]
+
+        # Create string with package URLs
+        all_package_urls = ""
+        for url in conda_pkg_urls:
+            all_package_urls += f"{storage.datastore_root}/{url}\n"
+        all_package_urls += "---\n"
+        for url in pypi_pkg_urls:
+            all_package_urls += f"{storage.datastore_root}/{url}\n"
+
+        # Initialize environment
+        # NOTE: For the time being the fast-initializer only works for the S3 datastore implementation
+        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>")
         sys.exit(1)
@@ -299,9 +381,12 @@ if __name__ == "__main__":
         with open(os.path.join(manifest_dir, MAGIC_FILE)) as f:
             env = json.load(f)[id_][architecture]
 
-        setup_environment(
-            architecture, storage, env, prefix, conda_pkgs_dir, pypi_pkgs_dir
-        )
+        if CONDA_USE_FAST_INIT:
+            fast_setup_environment(architecture, storage, env, prefix, pkgs_dir)
+        else:
+            setup_environment(
+                architecture, storage, env, prefix, conda_pkgs_dir, pypi_pkgs_dir
+            )
 
     except Exception as e:
         print(f"Error: {str(e)}", file=sys.stderr)

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/plugins/pypi/micromamba.py

@@ -37,7 +37,7 @@ class Micromamba(object):
             _home = os.environ.get("METAFLOW_TOKEN_HOME")
         else:
             _home = os.environ.get("METAFLOW_HOME", "~/.metaflowconfig")
-        _path_to_hidden_micromamba = os.path.join(
+        self._path_to_hidden_micromamba = os.path.join(
             os.path.expanduser(_home),
             "micromamba",
         )
@@ -47,19 +47,26 @@ class Micromamba(object):
         else:
             self.logger = lambda *args, **kwargs: None  # No-op logger if not provided
 
-        self.bin = (
+        self._bin = (
             which(os.environ.get("METAFLOW_PATH_TO_MICROMAMBA") or "micromamba")
             or which("./micromamba")  # to support remote execution
             or which("./bin/micromamba")
-            or which(os.path.join(_path_to_hidden_micromamba, "bin/micromamba"))
+            or which(os.path.join(self._path_to_hidden_micromamba, "bin/micromamba"))
         )
-        if self.bin is None:
-            # Install Micromamba on the fly.
-            # TODO: Make this optional at some point.
-            _install_micromamba(_path_to_hidden_micromamba)
-            self.bin = which(os.path.join(_path_to_hidden_micromamba, "bin/micromamba"))
 
-        if self.bin is None:
+    @property
+    def bin(self):
+        "Defer installing Micromamba until when the binary path is actually requested"
+        if self._bin is not None:
+            return self._bin
+        # Install Micromamba on the fly.
+        # TODO: Make this optional at some point.
+        _install_micromamba(self._path_to_hidden_micromamba)
+        self._bin = which(
+            os.path.join(self._path_to_hidden_micromamba, "bin/micromamba")
+        )
+
+        if self._bin is None:
             msg = "No installation for *Micromamba* found.\n"
             msg += "Visit https://mamba.readthedocs.io/en/latest/micromamba-installation.html for installation instructions."
             raise MetaflowException(msg)

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/runner/click_api.py

@@ -16,7 +16,7 @@ import itertools
 import uuid
 import json
 from collections import OrderedDict
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Type
 from typing import OrderedDict as TOrderedDict
 from typing import Tuple as TTuple
 from typing import Union
@@ -96,8 +96,13 @@ def _method_sanity_check(
             check_type(supplied_v, annotations[supplied_k])
         except TypeCheckError:
             raise TypeError(
-                "Invalid type for '%s', expected: '%s', default is '%s'"
-                % (supplied_k, annotations[supplied_k], defaults[supplied_k])
+                "Invalid type for '%s' (%s), expected: '%s', default is '%s'"
+                % (
+                    supplied_k,
+                    type(supplied_k),
+                    annotations[supplied_k],
+                    defaults[supplied_k],
+                )
             )
 
         # Clean up values to make them into what click expects
@@ -184,26 +189,35 @@ def _lazy_load_command(
         raise AttributeError()
 
 
-def get_annotation(param: Union[click.Argument, click.Option]):
+def get_annotation(param: click.Parameter) -> TTuple[Type, bool]:
     py_type = click_to_python_types[type(param.type)]
+    if param.nargs == -1:
+        # This is the equivalent of *args effectively
+        # so the type annotation should be the type of the
+        # elements in the list
+        return py_type, True
     if not param.required:
-        if param.multiple or param.nargs == -1:
-            return Optional[List[py_type]]
+        if param.multiple or param.nargs > 1:
+            return Optional[Union[List[py_type], TTuple[py_type]]], False
         else:
-            return Optional[py_type]
+            return Optional[py_type], False
     else:
-        if param.multiple or param.nargs == -1:
-            return List[py_type]
+        if param.multiple or param.nargs > 1:
+            return Union[List[py_type], TTuple[py_type]], False
         else:
-            return py_type
+            return py_type, False
 
 
 def get_inspect_param_obj(p: Union[click.Argument, click.Option], kind: str):
-    return inspect.Parameter(
-        name=p.name,
-        kind=kind,
-        default=p.default,
-        annotation=get_annotation(p),
+    annotation, is_vararg = get_annotation(p)
+    return (
+        inspect.Parameter(
+            name="args" if is_vararg else p.name,
+            kind=inspect.Parameter.VAR_POSITIONAL if is_vararg else kind,
+            default=inspect.Parameter.empty if is_vararg else p.default,
+            annotation=annotation,
+        ),
+        annotation,
     )
 
 
@@ -224,21 +238,29 @@ def extract_flow_class_from_file(flow_file: str) -> FlowSpec:
         path_was_added = True
 
     try:
+        # Get module name from the file path
+        module_name = os.path.splitext(os.path.basename(flow_file))[0]
+
         # Check if the module has already been loaded
         if flow_file in loaded_modules:
             module = loaded_modules[flow_file]
         else:
             # Load the module if it's not already loaded
-            spec = importlib.util.spec_from_file_location("module", flow_file)
+            spec = importlib.util.spec_from_file_location(module_name, flow_file)
             module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(module)
             # Cache the loaded module
             loaded_modules[flow_file] = module
-        classes = inspect.getmembers(module, inspect.isclass)
 
+        classes = inspect.getmembers(module, inspect.isclass)
         flow_cls = None
+
         for _, kls in classes:
-            if kls != FlowSpec and issubclass(kls, FlowSpec):
+            if (
+                kls is not FlowSpec
+                and kls.__module__ == module_name
+                and issubclass(kls, FlowSpec)
+            ):
                 if flow_cls is not None:
                     raise MetaflowException(
                         "Multiple FlowSpec classes found in %s" % flow_file
@@ -319,7 +341,7 @@ class MetaflowAPI(object):
             defaults,
         ) = extract_all_params(cli_collection)
 
-        def _method(_self, **kwargs):
+        def _method(_self, *args, **kwargs):
             method_params = _method_sanity_check(
                 possible_arg_params,
                 possible_opt_params,
@@ -371,6 +393,8 @@ class MetaflowAPI(object):
                     else:
                         components.append(v)
                 for k, v in options.items():
+                    if v is None:
+                        continue
                     if isinstance(v, list):
                         for i in v:
                             if isinstance(i, tuple):
@@ -379,6 +403,9 @@ class MetaflowAPI(object):
                             else:
                                 components.append("--%s" % k)
                                 components.append(str(i))
+                    elif v is None:
+                        continue  # Skip None values -- they are defaults and converting
+                        # them to string will not be what the user wants
                     else:
                         components.append("--%s" % k)
                         if v != "flag":
@@ -490,17 +517,16 @@ def extract_all_params(cmd_obj: Union[click.Command, click.Group]):
 
     for each_param in cmd_obj.params:
         if isinstance(each_param, click.Argument):
-            arg_params_sigs[each_param.name] = get_inspect_param_obj(
-                each_param, inspect.Parameter.POSITIONAL_ONLY
+            arg_params_sigs[each_param.name], annotations[each_param.name] = (
+                get_inspect_param_obj(each_param, inspect.Parameter.POSITIONAL_ONLY)
             )
             arg_parameters[each_param.name] = each_param
         elif isinstance(each_param, click.Option):
-            opt_params_sigs[each_param.name] = get_inspect_param_obj(
-                each_param, inspect.Parameter.KEYWORD_ONLY
+            opt_params_sigs[each_param.name], annotations[each_param.name] = (
+                get_inspect_param_obj(each_param, inspect.Parameter.KEYWORD_ONLY)
             )
             opt_parameters[each_param.name] = each_param
 
-        annotations[each_param.name] = get_annotation(each_param)
         defaults[each_param.name] = each_param.default
 
     # first, fill in positional arguments
@@ -537,7 +563,7 @@ def extract_group(cmd_obj: click.Group, flow_parameters: List[Parameter]) -> Cal
         defaults,
     ) = extract_all_params(cmd_obj)
 
-    def _method(_self, **kwargs):
+    def _method(_self, *args, **kwargs):
         method_params = _method_sanity_check(
             possible_arg_params, possible_opt_params, annotations, defaults, **kwargs
         )
@@ -570,7 +596,7 @@ def extract_command(
         defaults,
     ) = extract_all_params(cmd_obj)
 
-    def _method(_self, **kwargs):
+    def _method(_self, *args, **kwargs):
         method_params = _method_sanity_check(
             possible_arg_params, possible_opt_params, annotations, defaults, **kwargs
         )

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/runner/deployer_impl.py

@@ -63,11 +63,20 @@ class DeployerImpl(object):
 
         from metaflow.parameters import flow_context
 
-        if "metaflow.cli" in sys.modules:
-            # Reload the CLI with an "empty" flow -- this will remove any configuration
-            # options. They are re-added in from_cli (called below).
-            with flow_context(None) as _:
-                importlib.reload(sys.modules["metaflow.cli"])
+        # Reload the CLI with an "empty" flow -- this will remove any configuration
+        # and parameter options. They are re-added in from_cli (called below).
+        to_reload = [
+            "metaflow.cli",
+            "metaflow.cli_components.run_cmds",
+            "metaflow.cli_components.init_cmd",
+        ]
+        with flow_context(None):
+            [
+                importlib.reload(sys.modules[module])
+                for module in to_reload
+                if module in sys.modules
+            ]
+
         from metaflow.cli import start
         from metaflow.runner.click_api import MetaflowAPI
 

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/runner/metaflow_runner.py

@@ -269,11 +269,20 @@ class Runner(metaclass=RunnerMeta):
 
         from metaflow.parameters import flow_context
 
-        if "metaflow.cli" in sys.modules:
-            # Reload the CLI with an "empty" flow -- this will remove any configuration
-            # options. They are re-added in from_cli (called below).
-            with flow_context(None) as _:
-                importlib.reload(sys.modules["metaflow.cli"])
+        # Reload the CLI with an "empty" flow -- this will remove any configuration
+        # and parameter options. They are re-added in from_cli (called below).
+        to_reload = [
+            "metaflow.cli",
+            "metaflow.cli_components.run_cmds",
+            "metaflow.cli_components.init_cmd",
+        ]
+        with flow_context(None):
+            [
+                importlib.reload(sys.modules[module])
+                for module in to_reload
+                if module in sys.modules
+            ]
+
         from metaflow.cli import start
         from metaflow.runner.click_api import MetaflowAPI
 

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/user_configs/config_options.py

@@ -169,7 +169,7 @@ class ConfigInput:
                     "Please contact support."
                 )
             cls.loaded_configs = all_configs
-        return cls.loaded_configs.get(config_name, None)
+        return cls.loaded_configs[config_name]
 
     def process_configs(
         self,
@@ -326,6 +326,8 @@ class ConfigInput:
         for name, val in merged_configs.items():
             if val is None:
                 missing_configs.add(name)
+                to_return[name] = None
+                flow_cls._flow_state[_FlowState.CONFIGS][name] = None
                 continue
             if val.startswith(_CONVERTED_DEFAULT_NO_FILE):
                 no_default_file.append(name)
@@ -339,15 +341,16 @@ class ConfigInput:
                 val = val[len(_DEFAULT_PREFIX) :]
             if val.startswith("kv."):
                 # This means to load it from a file
-                read_value = self.get_config(val[3:])
-                if read_value is None:
+                try:
+                    read_value = self.get_config(val[3:])
+                except KeyError as e:
                     exc = click.UsageError(
                         "Could not find configuration '%s' in INFO file" % val
                     )
                     if click_obj:
                         click_obj.delayed_config_exception = exc
                         return None
-                    raise exc
+                    raise exc from e
                 flow_cls._flow_state[_FlowState.CONFIGS][name] = read_value
                 to_return[name] = ConfigValue(read_value)
             else:

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow/user_configs/config_parameters.py

@@ -290,17 +290,17 @@ class Config(Parameter, collections.abc.Mapping):
     default : Union[str, Callable[[ParameterContext], str], optional, default None
         Default path from where to read this configuration. A function implies that the
         value will be computed using that function.
-        You can only specify default or default_value.
+        You can only specify default or default_value, not both.
     default_value : Union[str, Dict[str, Any], Callable[[ParameterContext, Union[str, Dict[str, Any]]], Any], optional, default None
         Default value for the parameter. A function
         implies that the value will be computed using that function.
-        You can only specify default or default_value.
+        You can only specify default or default_value, not both.
     help : str, optional, default None
         Help text to show in `run --help`.
     required : bool, optional, default None
-        Require that the user specified a value for the configuration. Note that if
-        a default is provided, the required flag is ignored. A value of None is
-        equivalent to False.
+        Require that the user specifies a value for the configuration. Note that if
+        a default or default_value is provided, the required flag is ignored.
+        A value of None is equivalent to False.
     parser : Union[str, Callable[[str], Dict[Any, Any]]], optional, default None
         If a callable, it is a function that can parse the configuration string
         into an arbitrarily nested dictionary. If a string, the string should refer to
@@ -330,13 +330,13 @@ class Config(Parameter, collections.abc.Mapping):
         **kwargs: Dict[str, str]
     ):
 
-        if default and default_value:
+        if default is not None and default_value is not None:
             raise MetaflowException(
                 "For config '%s', you can only specify default or default_value, not both"
                 % name
             )
         self._default_is_file = default is not None
-        kwargs["default"] = default or default_value
+        kwargs["default"] = default if default is not None else default_value
         super(Config, self).__init__(
             name, required=required, help=help, type=str, **kwargs
         )

metaflow-2.13.8/metaflow/version.py

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

{metaflow-2.13.6 → metaflow-2.13.8/metaflow.egg-info}/PKG-INFO

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

{metaflow-2.13.6 → metaflow-2.13.8}/metaflow.egg-info/requires.txt

@@ -2,4 +2,4 @@ requests
 boto3
 
 [stubs]
-metaflow-stubs==2.13.6
+metaflow-stubs==2.13.8

metaflow-2.13.6/metaflow/version.py

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