@Marvin, if a flow fails, can I expect it to be relaunched with an additional parameter? how can I do that?

In Prefect, if a flow fails, it doesn't automatically relaunch with additional parameters. However, you could implement a retry mechanism that includes a change in parameters during the retry. This needs custom logic within your flow definition. Here's a high-level approach: 1. Define a Parameter: Define a parameter with a default value that you can change upon retries. 2. Create a State Handler: Use a custom state handler function that gets called when the state of a task or flow changes. In the event of a failure, you can increment or change the parameter. 3. Implement a Retry Mechanism: Use Prefect's built-in retry settings in the

@task

decorator to specify the number of retries and retry delay. 4. Pass the Updated Parameter: When a retry occurs, make sure the updated parameter is being passed to the task. Here's a simplified example in Python using Prefect code:

python
from prefect import Flow, task, Parameter
from prefect.engine.state import Failed, Retrying

@task(max_retries=3, retry_delay=timedelta(seconds=10))
def my_task(param):
    # Some operation that may fail
    pass

def my_state_handler(obj, old_state, new_state):
    if isinstance(new_state, Failed):
        param_value = obj.parameters.get('my_param', default_value)
        # Modify the parameter before retrying
        new_param_value = modify_parameter_logic(param_value)
        obj.parameters['my_param'] = new_param_value
    if isinstance(new_state, Retrying):
        # Make sure to pass along the modified parameter
        new_state.context.update(parameters=obj.parameters)
    return new_state

with Flow("My Flow", state_handlers=[my_state_handler]) as flow:
    my_param = Parameter("my_param", default=default_value)
    my_task(my_param)

# Run the flow
flow.run()

In this code,

modify_parameter_logic

would be your custom function to change the parameter based on your specific logic or conditions. Keep in mind, the flow has to be written in such a way that it can accept the changed parameter and behave accordingly. You would need to handle the parameter change logic within your tasks as well. If the failure is unpredictable, it might be challenging to determine the correct parameter changes automatically.