@Marvin How can I hydrate a pydantic model that has been passed to a deployed flow?

To hydrate a Pydantic model that's passed to a deployed Prefect flow, you can follow these steps: 1. Parameter Handling: Prefect's flow can accept parameters, and if you're using Pydantic models, you should ensure that the models are properly instantiated before passing them to the flow. Prefect supports both Pydantic v1 and v2 models, but you cannot mix them in the same flow call. 2. Validation: Prefect uses validated functions to handle Pydantic models. Depending on the version of Pydantic you're using, Prefect will use either

V1ValidatedFunction

or

V2ValidatedFunction

to initialize the model instance. This ensures that your Pydantic models are correctly validated when the flow is called. 3. Warnings and Compatibility: Prefect suppresses certain Pydantic deprecation warnings internally, so you don't need to worry about them when passing models to flows. For more details on how Prefect handles Pydantic models, you can refer to the flows.py implementation in the Prefect GitHub repository. Additionally, you can explore Prefect's top-level API where functions like

flow

and

task

are defined, which might be useful for setting up your flow and tasks with Pydantic models. Here's a brief overview of the Prefect top-level API. If you're using Prefect 3.x, ensure your models are compatible with the Pydantic version you are using to avoid any issues.

@Marvin currently I only get a dict. I call

run_deployment(<flow_name>, parameters={'model'=MyPydanticModel})

but in the function I only have a dict

When you use

run_deployment

with a Pydantic model, Prefect serializes the parameters using a

jsonable_encoder

, which turns the Pydantic model into a dictionary. This is why you're seeing a dictionary in your flow function. To handle this, you can manually rehydrate the Pydantic model inside your flow function. Here's a general approach: 1. Pass the Serialized Model: When you call

run_deployment

, the Pydantic model is serialized to a dictionary. 2. Rehydrate the Model: In your flow function, convert the dictionary back into a Pydantic model instance. Here's an example:

python
from prefect import flow
from pydantic import BaseModel

# Define your Pydantic model
class MyPydanticModel(BaseModel):
    field1: str
    field2: int

@flow
def my_flow(model_data: dict):
    # Rehydrate the Pydantic model
    model = MyPydanticModel(**model_data)
    # Now you can use `model` as a Pydantic model instance
    print(model)

# Run the deployment
run_deployment("my_flow", parameters={"model": MyPydanticModel(field1="value", field2=42).dict()})

This method ensures that you convert the dictionary back into a Pydantic model within the flow. For more on how Prefect handles parameters, you can check the Prefect 3.x documentation on writing flows.

@Marvin can I pass an handler to the internal functionality so that I don't have to do it manually?

Currently, Prefect doesn't provide a built-in mechanism to pass a custom handler directly to manage the rehydration of Pydantic models automatically within the flow. However, Prefect does support type hints with Pydantic models, which can be useful for type conversion and validation. Here's what you can do: 1. Type Hints: Use Pydantic models as type hints in your flow function. Prefect will attempt to perform type conversion based on these hints, but it still requires you to manually convert dictionaries back to Pydantic models. 2. Custom Serialization: You can implement custom serialization logic using Pydantic’s features or Prefect's caching mechanisms. This approach allows you to control how your models are serialized and deserialized, but it requires additional setup. For further details on handling flow parameters and type conversion, you can refer to the Prefect documentation on writing flows. If you want to automate the process further, you might consider wrapping the flow call in a function that handles serialization and deserialization, effectively acting as a custom handler. This would be a more manual setup but could streamline your workflow.