ob-metaflow 2.11.10.3__tar.gz → 2.11.14.1__tar.gz

{ob_metaflow-2.11.10.3/ob_metaflow.egg-info → ob_metaflow-2.11.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ob-metaflow
-Version: 2.11.10.3
+Version: 2.11.14.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: ob-metaflow-stubs==2.11.10.3; extra == "stubs"
+Requires-Dist: ob-metaflow-stubs==2.11.14.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.11.10.3 → ob_metaflow-2.11.14.1}/metaflow/metaflow_config.py

@@ -326,6 +326,10 @@ KUBERNETES_PORT = from_conf("KUBERNETES_PORT", None)
 KUBERNETES_SHARED_MEMORY = from_conf("KUBERNETES_SHARED_MEMORY", None)
 # Default port number to open on the pods
 KUBERNETES_PORT = from_conf("KUBERNETES_PORT", None)
+# Default kubernetes resource requests for CPU, memory and disk
+KUBERNETES_CPU = from_conf("KUBERNETES_CPU", None)
+KUBERNETES_MEMORY = from_conf("KUBERNETES_MEMORY", None)
+KUBERNETES_DISK = from_conf("KUBERNETES_DISK", None)
 
 
 ARGO_WORKFLOWS_KUBERNETES_SECRETS = from_conf("ARGO_WORKFLOWS_KUBERNETES_SECRETS", "")
@@ -376,6 +380,12 @@ 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")
 
+###
+# Escape hatch configuration
+###
+# Print out warning if escape hatch is not used for the target packages
+ESCAPE_HATCH_WARNING = from_conf("ESCAPE_HATCH_WARNING", True)
+
 ###
 # Debug configuration
 ###

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1}/metaflow/plugins/argo/argo_workflows.py

@@ -836,7 +836,9 @@ class ArgoWorkflows(object):
 
     # Visit every node and yield the uber DAGTemplate(s).
     def _dag_templates(self):
-        def _visit(node, exit_node=None, templates=None, dag_tasks=None):
+        def _visit(
+            node, exit_node=None, templates=None, dag_tasks=None, parent_foreach=None
+        ):
             if node.parallel_foreach:
                 raise ArgoWorkflowsException(
                     "Deploying flows with @parallel decorator(s) "
@@ -889,6 +891,37 @@ class ArgoWorkflows(object):
                         )
                     )
                 ]
+                # NOTE: Due to limitations with Argo Workflows Parameter size we
+                #       can not pass arbitrarily large lists of task id's to join tasks.
+                #       Instead we ensure that task id's for foreach tasks can be
+                #       deduced deterministically and pass the relevant information to
+                #       the join task.
+                #
+                #       We need to add the split-index and root-input-path for the last
+                #       step in any foreach scope and use these to generate the task id,
+                #       as the join step uses the root and the cardinality of the
+                #       foreach scope to generate the required id's.
+                if (
+                    node.is_inside_foreach
+                    and self.graph[node.out_funcs[0]].type == "join"
+                ):
+                    if any(
+                        self.graph[parent].matching_join
+                        == self.graph[node.out_funcs[0]].name
+                        and self.graph[parent].type == "foreach"
+                        for parent in self.graph[node.out_funcs[0]].split_parents
+                    ):
+                        parameters.extend(
+                            [
+                                Parameter("split-index").value(
+                                    "{{inputs.parameters.split-index}}"
+                                ),
+                                Parameter("root-input-path").value(
+                                    "{{inputs.parameters.input-paths}}"
+                                ),
+                            ]
+                        )
+
                 dag_task = (
                     DAGTask(self._sanitize(node.name))
                     .dependencies(
@@ -909,9 +942,19 @@ class ArgoWorkflows(object):
             # For split nodes traverse all the children
             if node.type == "split":
                 for n in node.out_funcs:
-                    _visit(self.graph[n], node.matching_join, templates, dag_tasks)
+                    _visit(
+                        self.graph[n],
+                        node.matching_join,
+                        templates,
+                        dag_tasks,
+                        parent_foreach,
+                    )
                 return _visit(
-                    self.graph[node.matching_join], exit_node, templates, dag_tasks
+                    self.graph[node.matching_join],
+                    exit_node,
+                    templates,
+                    dag_tasks,
+                    parent_foreach,
                 )
             # For foreach nodes generate a new sub DAGTemplate
             elif node.type == "foreach":
@@ -935,6 +978,16 @@ class ArgoWorkflows(object):
                                 ),
                                 Parameter("split-index").value("{{item}}"),
                             ]
+                            + (
+                                [
+                                    Parameter("root-input-path").value(
+                                        "argo-{{workflow.name}}/%s/{{tasks.%s.outputs.parameters.task-id}}"
+                                        % (node.name, self._sanitize(node.name))
+                                    ),
+                                ]
+                                if parent_foreach
+                                else []
+                            )
                         )
                     )
                     .with_param(
@@ -944,13 +997,18 @@ class ArgoWorkflows(object):
                 )
                 dag_tasks.append(foreach_task)
                 templates, dag_tasks_1 = _visit(
-                    self.graph[node.out_funcs[0]], node.matching_join, templates, []
+                    self.graph[node.out_funcs[0]],
+                    node.matching_join,
+                    templates,
+                    [],
+                    node.name,
                 )
                 templates.append(
                     Template(foreach_template_name)
                     .inputs(
                         Inputs().parameters(
                             [Parameter("input-paths"), Parameter("split-index")]
+                            + ([Parameter("root-input-path")] if parent_foreach else [])
                         )
                     )
                     .outputs(
@@ -977,13 +1035,26 @@ class ArgoWorkflows(object):
                         Arguments().parameters(
                             [
                                 Parameter("input-paths").value(
-                                    "argo-{{workflow.name}}/%s/{{tasks.%s.outputs.parameters}}"
-                                    % (
-                                        self.graph[node.matching_join].in_funcs[-1],
-                                        foreach_template_name,
-                                    )
-                                )
+                                    "argo-{{workflow.name}}/%s/{{tasks.%s.outputs.parameters.task-id}}"
+                                    % (node.name, self._sanitize(node.name))
+                                ),
+                                Parameter("split-cardinality").value(
+                                    "{{tasks.%s.outputs.parameters.split-cardinality}}"
+                                    % self._sanitize(node.name)
+                                ),
                             ]
+                            + (
+                                [
+                                    Parameter("split-index").value(
+                                        "{{inputs.parameters.split-index}}"
+                                    ),
+                                    Parameter("root-input-path").value(
+                                        "{{inputs.parameters.input-paths}}"
+                                    ),
+                                ]
+                                if parent_foreach
+                                else []
+                            )
                         )
                     )
                 )
@@ -993,11 +1064,16 @@ class ArgoWorkflows(object):
                     exit_node,
                     templates,
                     dag_tasks,
+                    parent_foreach,
                 )
             # For linear nodes continue traversing to the next node
             if node.type in ("linear", "join", "start"):
                 return _visit(
-                    self.graph[node.out_funcs[0]], exit_node, templates, dag_tasks
+                    self.graph[node.out_funcs[0]],
+                    exit_node,
+                    templates,
+                    dag_tasks,
+                    parent_foreach,
                 )
             else:
                 raise ArgoWorkflowsException(
@@ -1041,17 +1117,42 @@ class ArgoWorkflows(object):
             # (modulo retry suffix) on Argo Workflows but that doesn't seem feasible
             # right now.
 
-            task_str = node.name + "-{{workflow.creationTimestamp}}"
-            # The input paths might be quite large for foreach joins,
-            # so we need to take care not to unnecessarily repeat these in the scripts due to a template max size limit with Argo.
-            # Note: We inline a Python script here because jq might not be present, and bundling this as an utility will not work
-            # as the metaflow module initializes only after this line.
-            # read input-paths directly from ARGO_TEMPLATE environment variable.
-            input_paths_expr = """export INPUT_PATHS=$(python -c \\"import sys, os, json; template = json.loads(os.environ['ARGO_TEMPLATE']); input_paths = next((param['value'] for param in template.get('inputs', {'parameters': []})['parameters'] if param['name'] == 'input-paths'), None); sys.stdout.write(input_paths if input_paths else '')\\")"""
+            task_idx = ""
+            input_paths = ""
+            root_input = None
+            # export input_paths as it is used multiple times in the container script
+            # and we do not want to repeat the values.
+            input_paths_expr = "export INPUT_PATHS=''"
             if node.name != "start":
-                task_str += "-$(echo $INPUT_PATHS)"
+                input_paths_expr = (
+                    "export INPUT_PATHS={{inputs.parameters.input-paths}}"
+                )
+                input_paths = "$(echo $INPUT_PATHS)"
             if any(self.graph[n].type == "foreach" for n in node.in_funcs):
-                task_str += "-{{inputs.parameters.split-index}}"
+                task_idx = "{{inputs.parameters.split-index}}"
+            if node.is_inside_foreach and self.graph[node.out_funcs[0]].type == "join":
+                if any(
+                    self.graph[parent].matching_join
+                    == self.graph[node.out_funcs[0]].name
+                    for parent in self.graph[node.out_funcs[0]].split_parents
+                    if self.graph[parent].type == "foreach"
+                ) and any(not self.graph[f].type == "foreach" for f in node.in_funcs):
+                    # we need to propagate the split-index and root-input-path info for
+                    # the last step inside a foreach for correctly joining nested
+                    # foreaches
+                    task_idx = "{{inputs.parameters.split-index}}"
+                    root_input = "{{inputs.parameters.root-input-path}}"
+
+            # Task string to be hashed into an ID
+            task_str = "-".join(
+                [
+                    node.name,
+                    "{{workflow.creationTimestamp}}",
+                    root_input or input_paths,
+                    task_idx,
+                ]
+            )
+
             # Generated task_ids need to be non-numeric - see register_task_id in
             # service.py. We do so by prefixing `t-`
             task_id_expr = (
@@ -1112,8 +1213,6 @@ class ArgoWorkflows(object):
                 node.name, self.flow_datastore.TYPE
             )
 
-            input_paths = "$(echo $INPUT_PATHS)"
-
             top_opts_dict = {
                 "with": [
                     decorator.make_decorator_spec()
@@ -1182,10 +1281,16 @@ class ArgoWorkflows(object):
                 node.type == "join"
                 and self.graph[node.split_parents[-1]].type == "foreach"
             ):
-                # Set aggregated input-paths for a foreach-join
+                # Set aggregated input-paths for a for-each join
+                foreach_step = next(
+                    n for n in node.in_funcs if self.graph[n].is_inside_foreach
+                )
                 input_paths = (
-                    "$(python -m metaflow.plugins.argo.process_input_paths %s)"
-                    % input_paths
+                    "$(python -m metaflow.plugins.argo.generate_input_paths %s {{workflow.creationTimestamp}} %s {{inputs.parameters.split-cardinality}})"
+                    % (
+                        foreach_step,
+                        input_paths,
+                    )
                 )
             step = [
                 "step",
@@ -1352,13 +1457,37 @@ class ArgoWorkflows(object):
             # input. Analogously, if the node under consideration is a foreach
             # node, then we emit split cardinality as an extra output. I would like
             # to thank the designers of Argo Workflows for making this so
-            # straightforward!
+            # straightforward! Things become a bit more complicated to support very
+            # wide foreaches where we have to resort to passing a root-input-path
+            # so that we can compute the task ids for each parent task of a for-each
+            # join task deterministically inside the join task without resorting to
+            # passing a rather long list of (albiet compressed)
             inputs = []
             if node.name != "start":
                 inputs.append(Parameter("input-paths"))
             if any(self.graph[n].type == "foreach" for n in node.in_funcs):
                 # Fetch split-index from parent
                 inputs.append(Parameter("split-index"))
+            if (
+                node.type == "join"
+                and self.graph[node.split_parents[-1]].type == "foreach"
+            ):
+                # append this only for joins of foreaches, not static splits
+                inputs.append(Parameter("split-cardinality"))
+            if node.is_inside_foreach and self.graph[node.out_funcs[0]].type == "join":
+                if any(
+                    self.graph[parent].matching_join
+                    == self.graph[node.out_funcs[0]].name
+                    for parent in self.graph[node.out_funcs[0]].split_parents
+                    if self.graph[parent].type == "foreach"
+                ) and any(not self.graph[f].type == "foreach" for f in node.in_funcs):
+                    # we need to propagate the split-index and root-input-path info for
+                    # the last step inside a foreach for correctly joining nested
+                    # foreaches
+                    if not any(self.graph[n].type == "foreach" for n in node.in_funcs):
+                        # Don't add duplicate split index parameters.
+                        inputs.append(Parameter("split-index"))
+                    inputs.append(Parameter("root-input-path"))
 
             outputs = []
             if node.name != "end":
@@ -1368,6 +1497,11 @@ class ArgoWorkflows(object):
                 outputs.append(
                     Parameter("num-splits").valueFrom({"path": "/mnt/out/splits"})
                 )
+                outputs.append(
+                    Parameter("split-cardinality").valueFrom(
+                        {"path": "/mnt/out/split_cardinality"}
+                    )
+                )
 
             # It makes no sense to set env vars to None (shows up as "None" string)
             # Also we skip some env vars (e.g. in case we want to pull them from KUBERNETES_SECRETS)

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1}/metaflow/plugins/argo/argo_workflows_decorator.py

@@ -102,6 +102,9 @@ class ArgoWorkflowsInternalDecorator(StepDecorator):
         if graph[step_name].type == "foreach":
             with open("/mnt/out/splits", "w") as file:
                 json.dump(list(range(flow._foreach_num_splits)), file)
+            with open("/mnt/out/split_cardinality", "w") as file:
+                json.dump(flow._foreach_num_splits, file)
+
         # Unfortunately, we can't always use pod names as task-ids since the pod names
         # are not static across retries. We write the task-id to a file that is read
         # by the next task here.

ob_metaflow-2.11.14.1/metaflow/plugins/argo/generate_input_paths.py

@@ -0,0 +1,23 @@
+import sys
+from hashlib import md5
+
+
+def generate_input_paths(step_name, timestamp, input_paths, split_cardinality):
+    # => run_id/step/:foo,bar
+    run_id = input_paths.split("/")[0]
+    foreach_base_id = "{}-{}-{}".format(step_name, timestamp, input_paths)
+
+    ids = [_generate_task_id(foreach_base_id, i) for i in range(int(split_cardinality))]
+    return "{}/{}/:{}".format(run_id, step_name, ",".join(ids))
+
+
+def _generate_task_id(base, idx):
+    # For foreach splits generate the expected input-paths based on split_cardinality and base_id.
+    # newline required at the end due to 'echo' appending one in the shell side task_id creation.
+    task_str = "%s-%s\n" % (base, idx)
+    hash = md5(task_str.encode("utf-8")).hexdigest()[-8:]
+    return "t-" + hash
+
+
+if __name__ == "__main__":
+    print(generate_input_paths(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]))

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1}/metaflow/plugins/aws/aws_utils.py

@@ -20,14 +20,30 @@ def get_ec2_instance_metadata():
     # access to this end-point might be blocked on AWS and not available
     # for non-AWS deployments.
     # https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-identity-documents.html
+    # Set a very aggressive timeout, as the communication is happening in the same subnet,
+    # there should not be any significant delay in the response.
+    # Having a long default timeout here introduces unnecessary delay in launching tasks when the
+    # instance is unreachable.
+    timeout = (1, 10)
+    token = None
     try:
-        # Set a very aggressive timeout, as the communication is happening in the same subnet,
-        # there should not be any significant delay in the response.
-        # Having a long default timeout here introduces unnecessary delay in launching tasks when the
-        # instance is unreachable.
+        # Try to get an IMDSv2 token.
+        token = requests.put(
+            url="http://169.254.169.254/latest/api/token",
+            headers={"X-aws-ec2-metadata-token-ttl-seconds": 100},
+            timeout=timeout,
+        ).text
+    except:
+        pass
+    try:
+        headers = {}
+        # Add IMDSv2 token if available, else fall back to IMDSv1.
+        if token:
+            headers["X-aws-ec2-metadata-token"] = token
         instance_meta = requests.get(
             url="http://169.254.169.254/latest/dynamic/instance-identity/document",
-            timeout=(1, 10),
+            headers=headers,
+            timeout=timeout,
         ).json()
         meta["ec2-instance-id"] = instance_meta.get("instanceId")
         meta["ec2-instance-type"] = instance_meta.get("instanceType")

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1}/metaflow/plugins/aws/step_functions/step_functions.py

@@ -439,7 +439,7 @@ class StepFunctions(object):
                             JSONItemReader()
                             .resource("arn:aws:states:::s3:getObject")
                             .parameter("Bucket.$", "$.Body.DestinationBucket")
-                            .parameter("Key.$", "$.Body.ResultFiles.SUCCEEDED.[0].Key")
+                            .parameter("Key.$", "$.Body.ResultFiles.SUCCEEDED[0].Key")
                         )
                         .output_path("$.[0]")
                     )

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1}/metaflow/plugins/datastores/azure_storage.py

@@ -145,12 +145,19 @@ class _AzureRootClient(object):
                     # It is good enough 99.9% of the time.
                     # Depending on ResourceExistsError is more costly, though
                     # we are still going to handle it right.
+
+                    # The default timeout in the Azure blobstore python SDK
+                    # doesn't work well on slower network connections and largish
+                    # files. Hence increasing the connection_timeout below.
+                    # For more details, see this:
+                    # https://github.com/Azure/azure-sdk-for-python/issues/23232
                     if overwrite or not blob.exists():
                         blob.upload_blob(
                             byte_stream,
                             overwrite=overwrite,
                             metadata=metadata_to_upload,
                             max_concurrency=AZURE_STORAGE_UPLOAD_MAX_CONCURRENCY,
+                            connection_timeout=14400,
                         )
                 except ResourceExistsError:
                     if overwrite:

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1}/metaflow/plugins/datatools/s3/s3.py

@@ -1626,6 +1626,7 @@ class S3(object):
                         # Run the operation.
                         env = os.environ.copy()
                         tracing.inject_tracing_vars(env)
+                        env["METAFLOW_ESCAPE_HATCH_WARNING"] = "False"
                         stdout = subprocess.check_output(
                             cmdline + addl_cmdline,
                             cwd=self._tmpdir,

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1}/metaflow/plugins/env_escape/__init__.py

@@ -110,6 +110,7 @@ import importlib
 import os
 import sys
 from metaflow.plugins.env_escape.client_modules import ModuleImporter
+from metaflow.metaflow_config import ESCAPE_HATCH_WARNING
 
 # This is a trampoline file to ensure that the ModuleImporter to handle the emulated
 # modules gets properly loaded. If multiple modules are emulated by a single configuration
@@ -146,7 +147,7 @@ def load():
             # print("Env escape using executable {python_executable}")
         else:
             # Inverse logic as above here.
-            if sys.executable != "{python_executable}":
+            if sys.executable != "{python_executable}" and ESCAPE_HATCH_WARNING:
                 # We use the package locally and warn user.
                 print("Not using environment escape for '%s' as module present" % prefix)
             # In both cases, we don't load our loader since

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1}/metaflow/plugins/kubernetes/kubernetes_decorator.py

@@ -24,6 +24,9 @@ from metaflow.metaflow_config import (
     KUBERNETES_PORT,
     KUBERNETES_SHARED_MEMORY,
     KUBERNETES_PORT,
+    KUBERNETES_CPU,
+    KUBERNETES_MEMORY,
+    KUBERNETES_DISK,
 )
 from metaflow.plugins.resources_decorator import ResourcesDecorator
 from metaflow.plugins.timeout_decorator import get_run_time_limit_for_task
@@ -179,6 +182,15 @@ class KubernetesDecorator(StepDecorator):
             except (NameError, ImportError):
                 pass
 
+        # parse the CPU, memory, disk, values from the KUBERNETES_ environment variable (you would need to export the METAFLOW_KUBERNETES_CPU, METAFLOW_KUBERNETES_MEMORY and/or METAFLOW_KUBERNTES_DISK environment variable with the desired values before running the flow)
+        # find the values from the environment variables, then validate if the values are still the default ones, if so, then replace them with the values from the environment variables (otherwise, keep the values from the decorator)
+        if self.attributes["cpu"] == self.defaults["cpu"] and KUBERNETES_CPU:
+            self.attributes["cpu"] = KUBERNETES_CPU
+        if self.attributes["memory"] == self.defaults["memory"] and KUBERNETES_MEMORY:
+            self.attributes["memory"] = KUBERNETES_MEMORY
+        if self.attributes["disk"] == self.defaults["disk"] and KUBERNETES_DISK:
+            self.attributes["disk"] = KUBERNETES_DISK
+
         # If no docker image is explicitly specified, impute a default image.
         if not self.attributes["image"]:
             # If metaflow-config specifies a docker image, just use that.

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1}/metaflow/plugins/pypi/conda_environment.py

@@ -266,7 +266,9 @@ class CondaEnvironment(MetaflowEnvironment):
         # Resolve `linux-64` Conda environments if @batch or @kubernetes are in play
         target_platform = conda_platform()
         for decorator in step.decorators:
-            if decorator.name in ["batch", "kubernetes"]:
+            # TODO: rather than relying on decorator names, rely on attributes
+            #       to make them extensible.
+            if decorator.name in ["batch", "kubernetes", "nvidia"]:
                 # TODO: Support arm architectures
                 target_platform = "linux-64"
                 break

ob_metaflow-2.11.14.1/metaflow/version.py

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

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1/ob_metaflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ob-metaflow
-Version: 2.11.10.3
+Version: 2.11.14.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: ob-metaflow-stubs==2.11.10.3; extra == "stubs"
+Requires-Dist: ob-metaflow-stubs==2.11.14.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.11.10.3 → ob_metaflow-2.11.14.1}/ob_metaflow.egg-info/SOURCES.txt

@@ -157,7 +157,7 @@ metaflow/plugins/argo/argo_events.py
 metaflow/plugins/argo/argo_workflows.py
 metaflow/plugins/argo/argo_workflows_cli.py
 metaflow/plugins/argo/argo_workflows_decorator.py
-metaflow/plugins/argo/process_input_paths.py
+metaflow/plugins/argo/generate_input_paths.py
 metaflow/plugins/aws/__init__.py
 metaflow/plugins/aws/aws_client.py
 metaflow/plugins/aws/aws_utils.py

{ob_metaflow-2.11.10.3 → ob_metaflow-2.11.14.1}/ob_metaflow.egg-info/requires.txt

@@ -4,4 +4,4 @@ pylint
 kubernetes
 
 [stubs]
-ob-metaflow-stubs==2.11.10.3
+ob-metaflow-stubs==2.11.14.1

ob_metaflow-2.11.10.3/metaflow/plugins/argo/process_input_paths.py

@@ -1,19 +0,0 @@
-import re
-import sys
-
-
-def process_input_paths(input_paths):
-    # Convert Argo Workflows provided input-paths string to something that Metaflow
-    # understands
-    #
-    # flow/step/[{task-id:foo},{task-id:bar}] => flow/step/:foo,bar
-
-    flow, run_id, task_ids = input_paths.split("/")
-    task_ids = re.sub("[\[\]{}]", "", task_ids)
-    task_ids = task_ids.split(",")
-    tasks = [t.split(":")[1].strip('"') for t in task_ids]
-    return "{}/{}/:{}".format(flow, run_id, ",".join(tasks))
-
-
-if __name__ == "__main__":
-    print(process_input_paths(sys.argv[1]))

ob_metaflow-2.11.10.3/metaflow/version.py

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