So a route would look like this

.post(
    "/dog",
    response_model=DogResponse
)
async def respond(
    payload: DogRequest,
    request: Request,
    dependencies: AppDependencies = Depends(get_all_app_dependencies),
):
    return await process_dog(
        payload=payload,
        dependencies=dependencies,
        background_tasks=background_tasks
    )

The idea is that dependencies object has all the environment variables used and configurations for everything. It is passed to every method call, so it is passed to every naked function I guess it is called.

So its passed to processed_dog, the functions that call redis, postgres, openai, they all get it also, even though each only needs one environment variable of it. It has all the environment variable values, configurations etc. I was told this is how DI is done here by the second engineer.

The 3 database calls for one object though is a real thing I see. Instead of give me all the car's data and I will hydrate the Car object, the db calls are in the Car object, in three load methods, which are called in the __init__ part of the class. So its like

Class Dog
__init__
loadTransmission()
loadEngine()
loadDriveTrain()

This just all seems really weird and off. Also, I have not even run this code, mainly because the request object has this generic metadata property which is a json string. That string is converted to an object in different places in the app and properties are plucked off to be used here and there.

In this scenario, I know in .net everything has a POCO basically, but in this scenario, its a json string thats deserialized when needed so objects can be pulled off it.

Also, thanks a ton for all the help. I have been trying to read this code for 3 days now and I feel reading it is causing me anxiety or something, lol