metaflow 2.12.29__tar.gz → 2.12.31__tar.gz

{metaflow-2.12.29/metaflow.egg-info → metaflow-2.12.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: metaflow
-Version: 2.12.29
+Version: 2.12.31
 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.29; extra == "stubs"
+Requires-Dist: metaflow-stubs==2.12.31; 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.29 → metaflow-2.12.31}/metaflow/cli.py

@@ -282,31 +282,21 @@ def dump(obj, input_path, private=None, max_value_size=None, include=None, file=
     else:
         ds_list = list(datastore_set)  # get all tasks
 
-    tasks_processed = False
     for ds in ds_list:
-        if ds is not None:
-            tasks_processed = True
-            echo(
-                "Dumping output of run_id=*{run_id}* "
-                "step=*{step}* task_id=*{task_id}*".format(
-                    run_id=ds.run_id, step=ds.step_name, task_id=ds.task_id
-                ),
-                fg="magenta",
-            )
-
-            if file is None:
-                echo_always(
-                    ds.format(**kwargs),
-                    highlight="green",
-                    highlight_bold=False,
-                    err=False,
-                )
-            else:
-                output[ds.pathspec] = ds.to_dict(**kwargs)
+        echo(
+            "Dumping output of run_id=*{run_id}* "
+            "step=*{step}* task_id=*{task_id}*".format(
+                run_id=ds.run_id, step=ds.step_name, task_id=ds.task_id
+            ),
+            fg="magenta",
+        )
 
-    if not tasks_processed:
-        echo(f"No task(s) found for pathspec {input_path}", fg="red")
-        return
+        if file is None:
+            echo_always(
+                ds.format(**kwargs), highlight="green", highlight_bold=False, err=False
+            )
+        else:
+            output[ds.pathspec] = ds.to_dict(**kwargs)
 
     if file is not None:
         with open(file, "wb") as f:

{metaflow-2.12.29 → metaflow-2.12.31}/metaflow/parameters.py

@@ -151,6 +151,7 @@ class DeployTimeField(object):
             return self._check_type(val, deploy_time)
 
     def _check_type(self, val, deploy_time):
+
         # it is easy to introduce a deploy-time function that accidentally
         # returns a value whose type is not compatible with what is defined
         # in Parameter. Let's catch those mistakes early here, instead of
@@ -158,7 +159,7 @@ class DeployTimeField(object):
 
         # note: this doesn't work with long in Python2 or types defined as
         # click types, e.g. click.INT
-        TYPES = {bool: "bool", int: "int", float: "float", list: "list"}
+        TYPES = {bool: "bool", int: "int", float: "float", list: "list", dict: "dict"}
 
         msg = (
             "The value returned by the deploy-time function for "
@@ -166,7 +167,12 @@ class DeployTimeField(object):
             % (self.parameter_name, self.field)
         )
 
-        if self.parameter_type in TYPES:
+        if isinstance(self.parameter_type, list):
+            if not any(isinstance(val, x) for x in self.parameter_type):
+                msg += "Expected one of the following %s." % TYPES[self.parameter_type]
+                raise ParameterFieldTypeMismatch(msg)
+            return str(val) if self.return_str else val
+        elif self.parameter_type in TYPES:
             if type(val) != self.parameter_type:
                 msg += "Expected a %s." % TYPES[self.parameter_type]
                 raise ParameterFieldTypeMismatch(msg)

{metaflow-2.12.29 → metaflow-2.12.31}/metaflow/plugins/argo/argo_workflows.py

@@ -522,7 +522,9 @@ class ArgoWorkflows(object):
             params = set(
                 [param.name.lower() for var, param in self.flow._get_parameters()]
             )
-            for event in self.flow._flow_decorators.get("trigger")[0].triggers:
+            trigger_deco = self.flow._flow_decorators.get("trigger")[0]
+            trigger_deco.format_deploytime_value()
+            for event in trigger_deco.triggers:
                 parameters = {}
                 # TODO: Add a check to guard against names starting with numerals(?)
                 if not re.match(r"^[A-Za-z0-9_.-]+$", event["name"]):
@@ -562,9 +564,11 @@ class ArgoWorkflows(object):
 
         # @trigger_on_finish decorator
         if self.flow._flow_decorators.get("trigger_on_finish"):
-            for event in self.flow._flow_decorators.get("trigger_on_finish")[
-                0
-            ].triggers:
+            trigger_on_finish_deco = self.flow._flow_decorators.get(
+                "trigger_on_finish"
+            )[0]
+            trigger_on_finish_deco.format_deploytime_value()
+            for event in trigger_on_finish_deco.triggers:
                 # Actual filters are deduced here since we don't have access to
                 # the current object in the @trigger_on_finish decorator.
                 triggers.append(

{metaflow-2.12.29 → metaflow-2.12.31}/metaflow/plugins/events_decorator.py

@@ -1,9 +1,11 @@
 import re
+import json
 
 from metaflow import current
 from metaflow.decorators import FlowDecorator
 from metaflow.exception import MetaflowException
 from metaflow.util import is_stringish
+from metaflow.parameters import DeployTimeField, deploy_time_eval
 
 # TODO: Support dynamic parameter mapping through a context object that exposes
 #       flow name and user name similar to parameter context
@@ -68,6 +70,75 @@ class TriggerDecorator(FlowDecorator):
         "options": {},
     }
 
+    def process_event_name(self, event):
+        if is_stringish(event):
+            return {"name": str(event)}
+        elif isinstance(event, dict):
+            if "name" not in event:
+                raise MetaflowException(
+                    "The *event* attribute for *@trigger* is missing the *name* key."
+                )
+            if callable(event["name"]) and not isinstance(
+                event["name"], DeployTimeField
+            ):
+                event["name"] = DeployTimeField(
+                    "event_name", str, None, event["name"], False
+                )
+            event["parameters"] = self.process_parameters(event.get("parameters", {}))
+            return event
+        elif callable(event) and not isinstance(event, DeployTimeField):
+            return DeployTimeField("event", [str, dict], None, event, False)
+        else:
+            raise MetaflowException(
+                "Incorrect format for *event* attribute in *@trigger* decorator. "
+                "Supported formats are string and dictionary - \n"
+                "@trigger(event='foo') or @trigger(event={'name': 'foo', "
+                "'parameters': {'alpha': 'beta'}})"
+            )
+
+    def process_parameters(self, parameters):
+        new_param_values = {}
+        if isinstance(parameters, (list, tuple)):
+            for mapping in parameters:
+                if is_stringish(mapping):
+                    new_param_values[mapping] = mapping
+                elif callable(mapping) and not isinstance(mapping, DeployTimeField):
+                    mapping = DeployTimeField(
+                        "parameter_val", str, None, mapping, False
+                    )
+                    new_param_values[mapping] = mapping
+                elif isinstance(mapping, (list, tuple)) and len(mapping) == 2:
+                    if callable(mapping[0]) and not isinstance(
+                        mapping[0], DeployTimeField
+                    ):
+                        mapping[0] = DeployTimeField(
+                            "parameter_val", str, None, mapping[0], False
+                        )
+                    if callable(mapping[1]) and not isinstance(
+                        mapping[1], DeployTimeField
+                    ):
+                        mapping[1] = DeployTimeField(
+                            "parameter_val", str, None, mapping[1], False
+                        )
+                    new_param_values[mapping[0]] = mapping[1]
+                else:
+                    raise MetaflowException(
+                        "The *parameters* attribute for event is invalid. "
+                        "It should be a list/tuple of strings and lists/tuples of size 2"
+                    )
+        elif callable(parameters) and not isinstance(parameters, DeployTimeField):
+            return DeployTimeField(
+                "parameters", [list, dict, tuple], None, parameters, False
+            )
+        elif isinstance(parameters, dict):
+            for key, value in parameters.items():
+                if callable(key) and not isinstance(key, DeployTimeField):
+                    key = DeployTimeField("flow_parameter", str, None, key, False)
+                if callable(value) and not isinstance(value, DeployTimeField):
+                    value = DeployTimeField("signal_parameter", str, None, value, False)
+                new_param_values[key] = value
+        return new_param_values
+
     def flow_init(
         self,
         flow_name,
@@ -86,41 +157,9 @@ class TriggerDecorator(FlowDecorator):
                 "attributes in *@trigger* decorator."
             )
         elif self.attributes["event"]:
-            # event attribute supports the following formats -
-            #     1. event='table.prod_db.members'
-            #     2. event={'name': 'table.prod_db.members',
-            #               'parameters': {'alpha': 'member_weight'}}
-            if is_stringish(self.attributes["event"]):
-                self.triggers.append({"name": str(self.attributes["event"])})
-            elif isinstance(self.attributes["event"], dict):
-                if "name" not in self.attributes["event"]:
-                    raise MetaflowException(
-                        "The *event* attribute for *@trigger* is missing the "
-                        "*name* key."
-                    )
-                param_value = self.attributes["event"].get("parameters", {})
-                if isinstance(param_value, (list, tuple)):
-                    new_param_value = {}
-                    for mapping in param_value:
-                        if is_stringish(mapping):
-                            new_param_value[mapping] = mapping
-                        elif isinstance(mapping, (list, tuple)) and len(mapping) == 2:
-                            new_param_value[mapping[0]] = mapping[1]
-                        else:
-                            raise MetaflowException(
-                                "The *parameters* attribute for event '%s' is invalid. "
-                                "It should be a list/tuple of strings and lists/tuples "
-                                "of size 2" % self.attributes["event"]["name"]
-                            )
-                    self.attributes["event"]["parameters"] = new_param_value
-                self.triggers.append(self.attributes["event"])
-            else:
-                raise MetaflowException(
-                    "Incorrect format for *event* attribute in *@trigger* decorator. "
-                    "Supported formats are string and dictionary - \n"
-                    "@trigger(event='foo') or @trigger(event={'name': 'foo', "
-                    "'parameters': {'alpha': 'beta'}})"
-                )
+            event = self.attributes["event"]
+            processed_event = self.process_event_name(event)
+            self.triggers.append(processed_event)
         elif self.attributes["events"]:
             # events attribute supports the following formats -
             #     1. events=[{'name': 'table.prod_db.members',
@@ -128,43 +167,17 @@ class TriggerDecorator(FlowDecorator):
             #                {'name': 'table.prod_db.metadata',
             #               'parameters': {'beta': 'grade'}}]
             if isinstance(self.attributes["events"], list):
+                # process every event in events
                 for event in self.attributes["events"]:
-                    if is_stringish(event):
-                        self.triggers.append({"name": str(event)})
-                    elif isinstance(event, dict):
-                        if "name" not in event:
-                            raise MetaflowException(
-                                "One or more events in *events* attribute for "
-                                "*@trigger* are missing the *name* key."
-                            )
-                        param_value = event.get("parameters", {})
-                        if isinstance(param_value, (list, tuple)):
-                            new_param_value = {}
-                            for mapping in param_value:
-                                if is_stringish(mapping):
-                                    new_param_value[mapping] = mapping
-                                elif (
-                                    isinstance(mapping, (list, tuple))
-                                    and len(mapping) == 2
-                                ):
-                                    new_param_value[mapping[0]] = mapping[1]
-                                else:
-                                    raise MetaflowException(
-                                        "The *parameters* attribute for event '%s' is "
-                                        "invalid. It should be a list/tuple of strings "
-                                        "and lists/tuples of size 2" % event["name"]
-                                    )
-                            event["parameters"] = new_param_value
-                        self.triggers.append(event)
-                    else:
-                        raise MetaflowException(
-                            "One or more events in *events* attribute in *@trigger* "
-                            "decorator have an incorrect format. Supported format "
-                            "is dictionary - \n"
-                            "@trigger(events=[{'name': 'foo', 'parameters': {'alpha': "
-                            "'beta'}}, {'name': 'bar', 'parameters': "
-                            "{'gamma': 'kappa'}}])"
-                        )
+                    processed_event = self.process_event_name(event)
+                    self.triggers.append("processed event", processed_event)
+            elif callable(self.attributes["events"]) and not isinstance(
+                self.attributes["events"], DeployTimeField
+            ):
+                trig = DeployTimeField(
+                    "events", list, None, self.attributes["events"], False
+                )
+                self.triggers.append(trig)
             else:
                 raise MetaflowException(
                     "Incorrect format for *events* attribute in *@trigger* decorator. "
@@ -178,7 +191,12 @@ class TriggerDecorator(FlowDecorator):
             raise MetaflowException("No event(s) specified in *@trigger* decorator.")
 
         # same event shouldn't occur more than once
-        names = [x["name"] for x in self.triggers]
+        names = [
+            x["name"]
+            for x in self.triggers
+            if not isinstance(x, DeployTimeField)
+            and not isinstance(x["name"], DeployTimeField)
+        ]
         if len(names) != len(set(names)):
             raise MetaflowException(
                 "Duplicate event names defined in *@trigger* decorator."
@@ -188,6 +206,104 @@ class TriggerDecorator(FlowDecorator):
 
         # TODO: Handle scenario for local testing using --trigger.
 
+    def format_deploytime_value(self):
+        new_triggers = []
+        for trigger in self.triggers:
+            # Case where trigger is a function that returns a list of events
+            # Need to do this bc we need to iterate over list later
+            if isinstance(trigger, DeployTimeField):
+                evaluated_trigger = deploy_time_eval(trigger)
+                if isinstance(evaluated_trigger, dict):
+                    trigger = evaluated_trigger
+                elif isinstance(evaluated_trigger, str):
+                    trigger = {"name": evaluated_trigger}
+                if isinstance(evaluated_trigger, list):
+                    for trig in evaluated_trigger:
+                        if is_stringish(trig):
+                            new_triggers.append({"name": trig})
+                        else:  # dict or another deploytimefield
+                            new_triggers.append(trig)
+                else:
+                    new_triggers.append(trigger)
+            else:
+                new_triggers.append(trigger)
+
+        self.triggers = new_triggers
+        for trigger in self.triggers:
+            old_trigger = trigger
+            trigger_params = trigger.get("parameters", {})
+            # Case where param is a function (can return list or dict)
+            if isinstance(trigger_params, DeployTimeField):
+                trigger_params = deploy_time_eval(trigger_params)
+            # If params is a list of strings, convert to dict with same key and value
+            if isinstance(trigger_params, (list, tuple)):
+                new_trigger_params = {}
+                for mapping in trigger_params:
+                    if is_stringish(mapping) or callable(mapping):
+                        new_trigger_params[mapping] = mapping
+                    elif callable(mapping) and not isinstance(mapping, DeployTimeField):
+                        mapping = DeployTimeField(
+                            "parameter_val", str, None, mapping, False
+                        )
+                        new_trigger_params[mapping] = mapping
+                    elif isinstance(mapping, (list, tuple)) and len(mapping) == 2:
+                        if callable(mapping[0]) and not isinstance(
+                            mapping[0], DeployTimeField
+                        ):
+                            mapping[0] = DeployTimeField(
+                                "parameter_val",
+                                str,
+                                None,
+                                mapping[1],
+                                False,
+                            )
+                        if callable(mapping[1]) and not isinstance(
+                            mapping[1], DeployTimeField
+                        ):
+                            mapping[1] = DeployTimeField(
+                                "parameter_val",
+                                str,
+                                None,
+                                mapping[1],
+                                False,
+                            )
+
+                        new_trigger_params[mapping[0]] = mapping[1]
+                    else:
+                        raise MetaflowException(
+                            "The *parameters* attribute for event '%s' is invalid. "
+                            "It should be a list/tuple of strings and lists/tuples "
+                            "of size 2" % self.attributes["event"]["name"]
+                        )
+                trigger_params = new_trigger_params
+            trigger["parameters"] = trigger_params
+
+            trigger_name = trigger.get("name")
+            # Case where just the name is a function (always a str)
+            if isinstance(trigger_name, DeployTimeField):
+                trigger_name = deploy_time_eval(trigger_name)
+                trigger["name"] = trigger_name
+
+            # Third layer
+            # {name:, parameters:[func, ..., ...]}
+            # {name:, parameters:{func : func2}}
+            for trigger in self.triggers:
+                old_trigger = trigger
+                trigger_params = trigger.get("parameters", {})
+                new_trigger_params = {}
+                for key, value in trigger_params.items():
+                    if isinstance(value, DeployTimeField) and key is value:
+                        evaluated_param = deploy_time_eval(value)
+                        new_trigger_params[evaluated_param] = evaluated_param
+                    elif isinstance(value, DeployTimeField):
+                        new_trigger_params[key] = deploy_time_eval(value)
+                    elif isinstance(key, DeployTimeField):
+                        new_trigger_params[deploy_time_eval(key)] = value
+                    else:
+                        new_trigger_params[key] = value
+                trigger["parameters"] = new_trigger_params
+            self.triggers[self.triggers.index(old_trigger)] = trigger
+
 
 class TriggerOnFinishDecorator(FlowDecorator):
     """
@@ -312,6 +428,13 @@ class TriggerOnFinishDecorator(FlowDecorator):
                             "The *project_branch* attribute of the *flow* is not a string"
                         )
                 self.triggers.append(result)
+            elif callable(self.attributes["flow"]) and not isinstance(
+                self.attributes["flow"], DeployTimeField
+            ):
+                trig = DeployTimeField(
+                    "fq_name", [str, dict], None, self.attributes["flow"], False
+                )
+                self.triggers.append(trig)
             else:
                 raise MetaflowException(
                     "Incorrect type for *flow* attribute in *@trigger_on_finish* "
@@ -369,6 +492,13 @@ class TriggerOnFinishDecorator(FlowDecorator):
                             "Supported type is string or Dict[str, str]- \n"
                             "@trigger_on_finish(flows=['FooFlow', 'BarFlow']"
                         )
+            elif callable(self.attributes["flows"]) and not isinstance(
+                self.attributes["flows"], DeployTimeField
+            ):
+                trig = DeployTimeField(
+                    "flows", list, None, self.attributes["flows"], False
+                )
+                self.triggers.append(trig)
             else:
                 raise MetaflowException(
                     "Incorrect type for *flows* attribute in *@trigger_on_finish* "
@@ -383,6 +513,8 @@ class TriggerOnFinishDecorator(FlowDecorator):
 
         # Make triggers @project aware
         for trigger in self.triggers:
+            if isinstance(trigger, DeployTimeField):
+                continue
             if trigger["fq_name"].count(".") == 0:
                 # fully qualified name is just the flow name
                 trigger["flow"] = trigger["fq_name"]
@@ -427,5 +559,54 @@ class TriggerOnFinishDecorator(FlowDecorator):
                 run_objs.append(run_obj)
             current._update_env({"trigger": Trigger.from_runs(run_objs)})
 
+    def _parse_fq_name(self, trigger):
+        if isinstance(trigger, DeployTimeField):
+            trigger["fq_name"] = deploy_time_eval(trigger["fq_name"])
+        if trigger["fq_name"].count(".") == 0:
+            # fully qualified name is just the flow name
+            trigger["flow"] = trigger["fq_name"]
+        elif trigger["fq_name"].count(".") >= 2:
+            # fully qualified name is of the format - project.branch.flow_name
+            trigger["project"], tail = trigger["fq_name"].split(".", maxsplit=1)
+            trigger["branch"], trigger["flow"] = tail.rsplit(".", maxsplit=1)
+        else:
+            raise MetaflowException(
+                "Incorrect format for *flow* in *@trigger_on_finish* "
+                "decorator. Specify either just the *flow_name* or a fully "
+                "qualified name like *project_name.branch_name.flow_name*."
+            )
+        if not re.match(r"^[A-Za-z0-9_]+$", trigger["flow"]):
+            raise MetaflowException(
+                "Invalid flow name *%s* in *@trigger_on_finish* "
+                "decorator. Only alphanumeric characters and "
+                "underscores(_) are allowed." % trigger["flow"]
+            )
+        return trigger
+
+    def format_deploytime_value(self):
+        for trigger in self.triggers:
+            # Case were trigger is a function that returns a list
+            # Need to do this bc we need to iterate over list and process
+            if isinstance(trigger, DeployTimeField):
+                deploy_value = deploy_time_eval(trigger)
+                if isinstance(deploy_value, list):
+                    self.triggers = deploy_value
+            else:
+                break
+        for trigger in self.triggers:
+            # Entire trigger is a function (returns either string or dict)
+            old_trig = trigger
+            if isinstance(trigger, DeployTimeField):
+                trigger = deploy_time_eval(trigger)
+            if isinstance(trigger, dict):
+                trigger["fq_name"] = trigger.get("name")
+                trigger["project"] = trigger.get("project")
+                trigger["branch"] = trigger.get("project_branch")
+            # We also added this bc it won't be formatted yet
+            if isinstance(trigger, str):
+                trigger = {"fq_name": trigger}
+                trigger = self._parse_fq_name(trigger)
+            self.triggers[self.triggers.index(old_trig)] = trigger
+
     def get_top_level_options(self):
         return list(self._option_values.items())

{metaflow-2.12.29 → metaflow-2.12.31}/metaflow/plugins/kubernetes/kubernetes_jobsets.py

@@ -4,7 +4,6 @@ import math
 import random
 import time
 from collections import namedtuple
-
 from metaflow.exception import MetaflowException
 from metaflow.metaflow_config import KUBERNETES_JOBSET_GROUP, KUBERNETES_JOBSET_VERSION
 from metaflow.tracing import inject_tracing_vars
@@ -320,33 +319,49 @@ class RunningJobSet(object):
     def kill(self):
         plural = "jobsets"
         client = self._client.get()
-        # Get the jobset
-        with client.ApiClient() as api_client:
-            api_instance = client.CustomObjectsApi(api_client)
-            try:
-                obj = api_instance.get_namespaced_custom_object(
-                    group=self._group,
-                    version=self._version,
-                    namespace=self._namespace,
-                    plural=plural,
-                    name=self._name,
-                )
-
-                # Suspend the jobset
-                obj["spec"]["suspend"] = True
-
-                api_instance.replace_namespaced_custom_object(
-                    group=self._group,
-                    version=self._version,
-                    namespace=self._namespace,
-                    plural=plural,
-                    name=obj["metadata"]["name"],
-                    body=obj,
-                )
-            except Exception as e:
-                raise KubernetesJobsetException(
-                    "Exception when suspending existing jobset: %s\n" % e
-                )
+        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
+            # to succeed for the jobset to succeed.
+            from kubernetes.stream import stream
+
+            control_pod = self._fetch_pod()
+            stream(
+                client.CoreV1Api().connect_get_namespaced_pod_exec,
+                name=control_pod["metadata"]["name"],
+                namespace=control_pod["metadata"]["namespace"],
+                command=[
+                    "/bin/sh",
+                    "-c",
+                    "/sbin/killall5",
+                ],
+                stderr=True,
+                stdin=False,
+                stdout=True,
+                tty=False,
+            )
+        except Exception as e:
+            with client.ApiClient() as api_client:
+                # If we are unable to kill the control pod then
+                # Delete the jobset to kill the subsequent pods.
+                # There are a few reasons for deleting a jobset to kill it :
+                # 1. Jobset has a `suspend` attribute to suspend it's execution, but this
+                # doesn't play nicely when jobsets are deployed with other components like kueue.
+                # 2. Jobset doesn't play nicely when we mutate status
+                # 3. Deletion is a gaurenteed way of removing any pods.
+                api_instance = client.CustomObjectsApi(api_client)
+                try:
+                    api_instance.delete_namespaced_custom_object(
+                        group=self._group,
+                        version=self._version,
+                        namespace=self._namespace,
+                        plural=plural,
+                        name=self._name,
+                    )
+                except Exception as e:
+                    raise KubernetesJobsetException(
+                        "Exception when deleting existing jobset: %s\n" % e
+                    )
 
     @property
     def id(self):

metaflow-2.12.31/metaflow/version.py

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

{metaflow-2.12.29 → metaflow-2.12.31/metaflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: metaflow
-Version: 2.12.29
+Version: 2.12.31
 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.29; extra == "stubs"
+Requires-Dist: metaflow-stubs==2.12.31; 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.29 → metaflow-2.12.31}/metaflow.egg-info/requires.txt

@@ -2,4 +2,4 @@ requests
 boto3
 
 [stubs]
-metaflow-stubs==2.12.29
+metaflow-stubs==2.12.31

metaflow-2.12.29/metaflow/version.py

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