metaflow 2.12.33__py2.py3-none-any.whl → 2.12.34__py2.py3-none-any.whl

metaflow/multicore_utils.py

@@ -6,7 +6,18 @@ from tempfile import NamedTemporaryFile
 import time
 import metaflow.tracing as tracing
 
-from typing import Any, Callable, Iterable, Iterator, List, Optional
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    NoReturn,
+    Tuple,
+    TypeVar,
+    Union,
+)
 
 try:
     # Python 2
@@ -30,7 +41,13 @@ class MulticoreException(Exception):
     pass
 
 
-def _spawn(func, arg, dir):
+_A = TypeVar("_A")
+_R = TypeVar("_R")
+
+
+def _spawn(
+    func: Callable[[_A], _R], arg: _A, dir: Optional[str]
+) -> Union[Tuple[int, str], NoReturn]:
     with NamedTemporaryFile(prefix="parallel_map_", dir=dir, delete=False) as tmpfile:
         output_file = tmpfile.name
 
@@ -63,11 +80,11 @@ def _spawn(func, arg, dir):
 
 
 def parallel_imap_unordered(
-    func: Callable[[Any], Any],
-    iterable: Iterable[Any],
+    func: Callable[[_A], _R],
+    iterable: Iterable[_A],
     max_parallel: Optional[int] = None,
     dir: Optional[str] = None,
-) -> Iterator[Any]:
+) -> Iterator[_R]:
     """
     Parallelizes execution of a function using multiprocessing. The result
     order is not guaranteed.
@@ -79,9 +96,9 @@ def parallel_imap_unordered(
     iterable : Iterable[Any]
         Iterable over arguments to pass to fun
     max_parallel int, optional, default None
-        Maximum parallelism. If not specified, uses the number of CPUs
+        Maximum parallelism. If not specified, it uses the number of CPUs
     dir : str, optional, default None
-        If specified, directory where temporary files are created
+        If specified, it's the directory where temporary files are created
 
     Yields
     ------
@@ -121,14 +138,14 @@ def parallel_imap_unordered(
 
 
 def parallel_map(
-    func: Callable[[Any], Any],
-    iterable: Iterable[Any],
+    func: Callable[[_A], _R],
+    iterable: Iterable[_A],
     max_parallel: Optional[int] = None,
     dir: Optional[str] = None,
-) -> List[Any]:
+) -> List[_R]:
     """
     Parallelizes execution of a function using multiprocessing. The result
-    order is that of the arguments in `iterable`
+    order is that of the arguments in `iterable`.
 
     Parameters
     ----------
@@ -137,9 +154,9 @@ def parallel_map(
     iterable : Iterable[Any]
         Iterable over arguments to pass to fun
     max_parallel int, optional, default None
-        Maximum parallelism. If not specified, uses the number of CPUs
+        Maximum parallelism. If not specified, it uses the number of CPUs
     dir : str, optional, default None
-        If specified, directory where temporary files are created
+        If specified, it's the directory where temporary files are created
 
     Returns
     -------
@@ -155,4 +172,4 @@ def parallel_map(
     res = parallel_imap_unordered(
         wrapper, enumerate(iterable), max_parallel=max_parallel, dir=dir
     )
-    return [r for idx, r in sorted(res)]
+    return [r for _, r in sorted(res)]

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/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/plugins/argo/argo_workflows_deployer_objects.py

@@ -10,7 +10,7 @@ from metaflow.metaflow_config import KUBERNETES_NAMESPACE
 from metaflow.plugins.argo.argo_workflows import ArgoWorkflows
 from metaflow.runner.deployer import Deployer, DeployedFlow, TriggeredRun
 
-from metaflow.runner.utils import get_lower_level_group, handle_timeout
+from metaflow.runner.utils import get_lower_level_group, handle_timeout, temporary_fifo
 
 
 def generate_fake_flow_file_contents(
@@ -341,18 +341,14 @@ class ArgoWorkflowsDeployedFlow(DeployedFlow):
         Exception
             If there is an error during the trigger process.
         """
-        with tempfile.TemporaryDirectory() as temp_dir:
-            tfp_runner_attribute = tempfile.NamedTemporaryFile(
-                dir=temp_dir, delete=False
-            )
-
+        with temporary_fifo() as (attribute_file_path, attribute_file_fd):
             # every subclass needs to have `self.deployer_kwargs`
             command = get_lower_level_group(
                 self.deployer.api,
                 self.deployer.top_level_kwargs,
                 self.deployer.TYPE,
                 self.deployer.deployer_kwargs,
-            ).trigger(deployer_attribute_file=tfp_runner_attribute.name, **kwargs)
+            ).trigger(deployer_attribute_file=attribute_file_path, **kwargs)
 
             pid = self.deployer.spm.run_command(
                 [sys.executable, *command],
@@ -363,7 +359,7 @@ class ArgoWorkflowsDeployedFlow(DeployedFlow):
 
             command_obj = self.deployer.spm.get(pid)
             content = handle_timeout(
-                tfp_runner_attribute, command_obj, self.deployer.file_read_timeout
+                attribute_file_fd, command_obj, self.deployer.file_read_timeout
             )
 
             if command_obj.process.returncode == 0:

metaflow/plugins/aws/step_functions/step_functions_deployer_objects.py

@@ -6,7 +6,7 @@ from typing import ClassVar, Optional, List
 from metaflow.plugins.aws.step_functions.step_functions import StepFunctions
 from metaflow.runner.deployer import DeployedFlow, TriggeredRun
 
-from metaflow.runner.utils import get_lower_level_group, handle_timeout
+from metaflow.runner.utils import get_lower_level_group, handle_timeout, temporary_fifo
 
 
 class StepFunctionsTriggeredRun(TriggeredRun):
@@ -196,18 +196,14 @@ class StepFunctionsDeployedFlow(DeployedFlow):
         Exception
             If there is an error during the trigger process.
         """
-        with tempfile.TemporaryDirectory() as temp_dir:
-            tfp_runner_attribute = tempfile.NamedTemporaryFile(
-                dir=temp_dir, delete=False
-            )
-
+        with temporary_fifo() as (attribute_file_path, attribute_file_fd):
             # every subclass needs to have `self.deployer_kwargs`
             command = get_lower_level_group(
                 self.deployer.api,
                 self.deployer.top_level_kwargs,
                 self.deployer.TYPE,
                 self.deployer.deployer_kwargs,
-            ).trigger(deployer_attribute_file=tfp_runner_attribute.name, **kwargs)
+            ).trigger(deployer_attribute_file=attribute_file_path, **kwargs)
 
             pid = self.deployer.spm.run_command(
                 [sys.executable, *command],
@@ -218,7 +214,7 @@ class StepFunctionsDeployedFlow(DeployedFlow):
 
             command_obj = self.deployer.spm.get(pid)
             content = handle_timeout(
-                tfp_runner_attribute, command_obj, self.deployer.file_read_timeout
+                attribute_file_fd, command_obj, self.deployer.file_read_timeout
             )
 
             if command_obj.process.returncode == 0:

metaflow/plugins/datatools/s3/s3.py

@@ -600,7 +600,9 @@ class S3(object):
         # returned are Unicode.
         key = getattr(key_value, "key", key_value)
         if self._s3root is None:
-            parsed = urlparse(to_unicode(key))
+            # NOTE: S3 allows fragments as part of object names, e.g. /dataset #1/data.txt
+            # Without allow_fragments=False the parsed.path for an object name with fragments is incomplete.
+            parsed = urlparse(to_unicode(key), allow_fragments=False)
             if parsed.scheme == "s3" and parsed.path:
                 return key
             else:
@@ -765,7 +767,9 @@ class S3(object):
         """
 
         url = self._url(key)
-        src = urlparse(url)
+        # NOTE: S3 allows fragments as part of object names, e.g. /dataset #1/data.txt
+        # Without allow_fragments=False the parsed src.path for an object name with fragments is incomplete.
+        src = urlparse(url, allow_fragments=False)
 
         def _info(s3, tmp):
             resp = s3.head_object(Bucket=src.netloc, Key=src.path.lstrip('/"'))
@@ -891,7 +895,9 @@ class S3(object):
         DOWNLOAD_MAX_CHUNK = 2 * 1024 * 1024 * 1024 - 1
 
         url, r = self._url_and_range(key)
-        src = urlparse(url)
+        # NOTE: S3 allows fragments as part of object names, e.g. /dataset #1/data.txt
+        # Without allow_fragments=False the parsed src.path for an object name with fragments is incomplete.
+        src = urlparse(url, allow_fragments=False)
 
         def _download(s3, tmp):
             if r:
@@ -1173,7 +1179,9 @@ class S3(object):
         blob.close = lambda: None
 
         url = self._url(key)
-        src = urlparse(url)
+        # NOTE: S3 allows fragments as part of object names, e.g. /dataset #1/data.txt
+        # Without allow_fragments=False the parsed src.path for an object name with fragments is incomplete.
+        src = urlparse(url, allow_fragments=False)
         extra_args = None
         if content_type or metadata or self._encryption:
             extra_args = {}

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)
+            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())