Bring your towel and join one of the fastest growing data communities. Welcome to our second-generation open source orchestration platform, a completely rethought approach to dataflow automation.

Prefect Community

I was searching for a paradigm where a task will create small results and another task will take that data and start instantly. So something like a flow (A -&gt; B) where A, B are tasks and A will `yield` result for B. B will start when it gets first `yield` from A

Hi <@U01C4HUMS56>!  It sounds like you are describing Prefect data dependencies:

```@task
def task_A():
    return 3

@task
def task_B(a):
    return a + 1

with Flow("data") as flow:
    task_B(task_A)```
the moment that A finishes, B will begin with sub-second latency.  Is there something else you’re looking for?

Hi Chris, watched almost all of your videos on youtube. I have another problem

With running dask executor,  dask-worker do not seem to recognize a module in its working directory.

Here is a minimal reproducable.
```from test_custom import HelloWorld
helloworld_task = HelloWorld()

with Flow("outside-task") as flow:
    val = helloworld_task()

executor = DaskExecutor(address="<tcp://192.168.0.7:8786>")
flow_state = flow.run(executor=executor)```
And here is what it is in test_custom.py
```from prefect import Task
class HelloWorld(Task):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def run(self):
        return val```
I used `dask-scheduler` and `dask-worker &lt;IP&gt;`  in local for debugging. All run from the same directory. And, if the flow is run without passing the `executor`  from that dir, it runs perfectly fine.

Oh, and sorry for not responding on your previous message <@UKNSNMUE6>
No, I wasn't looking for data dependency.
I want the below code to "taskIZE" in prefect.
```def task_A():
    for i in range(3):
        yield i

def task_B(a):
    for i in task_A():
        return i + 1

# The flow
task_B(task_A)```
And, I want the flow to do something like this:
1. First run task_A
2. Whenever task_A yields something: pass it to task_B
3. Perellelly keep running task_A and task_B (when task_B has a single data from task_A).

<@U01C4HUMS56> I think you're asking about depth-first-execution? <https://medium.com/the-prefect-blog/map-faster-mapping-improvements-in-prefect-0-12-0-7cacc3f14e16>

Yes, thank you. I was exactly looking for this feature.