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

Hi there, I'm trying to figure out how I would leverage the caching functionality to ensure that any dependent tasks are re-run after a parent is re-run. :thread:

The test code is here:
```from prefect import flow, task                                          
from prefect.tasks import task_input_hash                               
                                                                        
@task(cache_key_fn=task_input_hash, refresh_cache=True)                 
def a():                                                                
    print("executing a")                                                
    return 1                                                            
                                                                        
@task(cache_key_fn=task_input_hash)                                     
def b(result_from_a):                                                   
    print("executing b")                                                
    return result_from_a + 2                                            
                                                                        
@flow                                                                   
def test1():                                                            
    res_a = a()                                                         
    return b(res_a)                                                     
                                                                        
if __name__ == "__main__":                                              
    print(test1())                                                      ```

The behavior I'm hoping to see is that, when running this, no matter what the cached state of `b` is, it reruns because `a` was rerun

I can see that `a` is re-run, but `b` is not - and the result of course still uses the old value from `b`

I've looked into the `TaskRunContext` object and I don't see anything that would give me this information that I could use to incorporate into the hash

But I might be missing something - is it possible to support this functionality?

I think `b` is not re-run because the result of task `a` is always `1`. So it does not matter if `a` is re-run. The input to `b` stays the same, which results in the same `cache_key` which keeps `b` from being executed again.

Yeah, I realize that - I was wondering if there was a way to force `b` to be re-run based on `a` being re-run, in case e.g. `a` produces side effects that are not part of `b`

It's not a big deal, although I haven't tried to run large objects through the caching hash - my other question is more important to me