Enable Resolve Attr Path for List or Dict of Promise

flytekit/core/promise.py

@@ -99,6 +99,10 @@ def my_wf(in1: int, in2: int) -> int:
         try:
             if type(v) is Promise:
                 v = await resolve_attr_path_in_promise(v)
+            elif type(v) is list:
+                for i, elem in enumerate(v):
+                    if type(elem) is Promise:
+                        v[i] = await resolve_attr_path_in_promise(elem)
             result[k] = await TypeEngine.async_to_literal(ctx, v, t, var.type)
         except TypeTransformerFailedError as exc:
             exc.args = (f"Failed argument '{k}': {exc.args[0]}",)

tests/flytekit/unit/core/test_promise.py

@@ -21,6 +21,7 @@
 )
 from flytekit.core.type_engine import TypeEngine
 from flytekit.exceptions.user import FlyteAssertion, FlytePromiseAttributeResolveException
+from flytekit.models import literals as literal_models
 from flytekit.models.types import LiteralType, SimpleType, TypeStructure
 from flytekit.types.pickle.pickle import BatchSize
 
@@ -147,6 +148,45 @@ def t1(a: typing.Union[float, MyDataclass, Annotated[typing.List[typing.Any], Ba
     translate_inputs_to_literals(ctx, {"a": input}, t1.interface.inputs, t1.python_interface.inputs)
 
 
+def test_translate_inputs_to_literals_with_list():
+    ctx = context_manager.FlyteContext.current_context()
+
+    @dataclass_json
+    @dataclass
+    class Foo:
+        b: str
+
+    @dataclass_json
+    @dataclass
+    class Bar:
+        a: List[Foo]
+        b: str
+
+    src = {"a": [Bar(a=[Foo(b="foo")], b="bar")]}
+    src_lit = TypeEngine.to_literal(
+        ctx,
+        src,
+        Dict[str, List[Bar]],
+        TypeEngine.to_literal_type(Dict[str, List[Bar]]),
+    )
+    src_promise = Promise("val1", src_lit)
+
+    i0 = "foo"
+    i1 = Promise("n1", TypeEngine.to_literal(ctx, "bar", str, TypeEngine.to_literal_type(str)))
+
+    @task
+    def t1(a: List[str]):
+        print(a)
+
+
+    lits = translate_inputs_to_literals(ctx, {"a": [
+        i0, i1, src_promise["a"][0]["a"][0]["b"], src_promise["a"][0]["b"]
+    ]}, t1.interface.inputs, t1.python_interface.inputs)
+    literal_map = literal_models.LiteralMap(literals=lits)
+    python_values = TypeEngine.literal_map_to_kwargs(ctx, literal_map, t1.python_interface.inputs)["a"]
+    assert python_values == ["foo", "bar", "foo", "bar"]
+
+
 def test_translate_inputs_to_literals_with_wrong_types():
     ctx = context_manager.FlyteContext.current_context()
     with pytest.raises(TypeError, match="Cannot convert"):