Subflow won't map over a `list` parameter

Description

A clear description of the bug I have a flow that maps a task to a list. Each list item itself is a list. The task runs a subflow that has a task mapped to each element of that nested list that runs conditionally. This prevents me from simply flattening the nested list and doing a single map. The subflow receives each nested list as a pf.Parameter. The apparent bug is that inside this subflow, the Task mapped to the inner list receives the entire inner list instead of just an element, and the Task is called len(list) times with this argument.

Expected Behavior

What did you expect to happen instead? I expected my inner map to receive a single element of the nested list.

Reproduction

A minimal example that exhibits the behavior.

import prefect as pf


@pf.task
def process_list_element(element):
    print('ELEMENT:', element)


@pf.task
def run_map_flow(inner_list, nested_flow):
    print('LIST:', inner_list)
    if is_valid(inner_list):
        nested_flow.run(inner_list=inner_list)


@pf.task
def make_nested_list(i):
    nested_list = [list(range(i)) for _ in range(i)]
    print('NESTED LIST: ', nested_list)
    return nested_list


if __name__ == '__main__':

    with pf.Flow('nested_flow') as nested_flow:
        inner_list = pf.Parameter('inner_list')
        process_list_element.map(inner_list)

    with pf.Flow('outer_flow') as outer_flow:
        nested_list = make_nested_list(3)
        run_map_flow.map(nested_list, nested_flow=pf.unmapped(nested_flow))

    nested_flow.run(inner_list=range(10)) # runs as expected
    outer_flow.run() # not what I expected

Environment

python 3.6.8 prefect 0.8.1

[schmidt-jake]

Understood! Unfortunately, flattening won’t work in my case because there is some conditional logic that determines the execution of the nested list. I’ll update my code example to reflect what I mean.

[lauralorenz]

Closing, there was some offline chatter about this that we think means this issue is resolved, and on top of that, upcoming subflows feature may help make this paradigm a more first class experience.