Fastapi: how to avoid circular import when models are in a separate file - admin.init_app is missing for factory pattern

[simonsax]

In contrast to many tutorials I have the my models in a separate file (see simplified example below). But how can I instantiate the Admin() package in main.py and import it in my models file to add the model to the adminpanel? -> this leads to a circular import.

#main.py
from fastapi import FastAPI
from .routes import assessments
from .database import engine
...

app = FastAPI()
admin = Admin(app, engine)
app.include_router(assessments.router)

#assessments.router
from .. import models

router = APIRouter(prefix="/assessment")

#models.py
...
class Note(Base):
    __tablename__ = 'notes'
    id = Column(GUID, primary_key=True, default=GUID_DEFAULT_SQLITE)

class UserAdmin(ModelView, model=Note):
    from .main import admin_backend
    column_list = [Note.id, Note.title]

admin_backend.add_view(UserAdmin)

In flask I could do admin = Admin(template_mode="bootstrap3", index_view=MyAdminView()) without the app object and then call admin.init_app(app) later -> therefore I was able to import the admin object in my models.py (as it was not bound to the app yet)

Any help is highly appreciated! Thanks a lot for your amazing sqladmin (I was looking for something like this for a long time!)

[aminalaee]

Hey @simonsax I think one workaround is that you do admin_backend.add_view(UserAdmin) in the main.py the same as routers, but I agree this is not ideal.
I think as you said init_app or Django style of @register will work here, which I also prefer Flask's appraoch.

[simonsax]

thanks a lot for your fast feedback

[lesleslie]

@simonsax, along the lines of what @aminalaee is saying here a couple of examples to avoid the circular import:

I have an authentication backend as well that requires I have the models being loaded before initializing the admin.

# main.py

from fastapi import FastAPI

app = FastApi()

@app.on_event("startup")
async def on_startup():
    import models
    from database import db_engine
    from sqladmin import Admin
    from my_auth_module import AppAuthBackend

    admin_backend = Admin(
        app=app_main,
        engine=db_engine,
        authentication_backend=AppAuthBackend(my_secret_key, models.Person),
    )

    # you can put the model view right here and no longer need the admin_backend import

    from sqladmin import ModelView

    class UserAdmin(ModelView, model=models.Note):
        column_list = ["id", "title"]    # you just need the field names here

    admin_backend.add_view(UserAdmin)

    # or you can create an init function in models.py and then pass it the admin_backend from here (ala flask extensions)

    models.init(admin_backend)

then models.py would look like this:

# models.py

class Note(Base):
    __tablename__ = 'notes'
    id = Column(GUID, primary_key=True, default=GUID_DEFAULT_SQLITE)

class UserAdmin(ModelView, model=Note):
       column_list = ["id", "title"]

def init(admin_backend):
    admin_backend.add_view(UserAdmin)

Personally, I like to separate my model views from my models by putting them in an admin.py, along with any other admin related classes & things, and then use a create_view function in admin.py to dynamically create my views by passing the model from main.py (my views share the same name as the model, just with 'Admin' added btw otherwise you'll have to pass the name in create_view as well):

# admin.py

from sqladmin import ModelView

async def create_view(model):
    class model_cls(ModelView, model=model):
        # all the things my views share here

        page_size = 25
        page_size_options = [25, 50, 100, 200]
        can_delete = True

        def is_visible(self, request: Request) -> bool:
                return True

        # then add stuff by fields or model name      

        _fields = model.__fields__

        form_columns = list(_fields.keys())
       
        column_default_sort = "name"

        if "position" in _fields:
            column_default_sort = "position"
        elif "date" in _fields:
            column_default_sort = "date"

        if model.__name__ = "Stuff":
            column_details_list = ["some_field", "some_other_field"]
            if "published" in _fields:
                column_default_sort = ("published", True)
        
        # and so on and so on

    # then you can add or change other attributes here as well before returning the model view class    

    model_cls.__name__ = f"{model.__name__}Admin"
    return model_cls

then main.py on_startup would look like this:

# main.py

@app.on_event("startup")
async def on_startup():
    import models
    from database import db_engine
    from sqladmin import Admin

    admin_backend = Admin(
        app=app_main,
        engine=db_engine,
        authentication_backend=AppAuthBackend(ac.secrets.my_secret_key, models.Person),
    )

   from admin import create_view

   for model_name in some_list_of_model_names:
        model = getattr(models, model_name)
        admin_backend.add_model_view(await admin_backend.create_view(model))

To avoid circular imports, I like to use an init function for most modules & classes and import them after any dependencies have been initialized:

@app.on_event("startup")
async def on_startup(): 
    from database import db

    await db.init()

    import models

    await models.init()

    from storage import stor
    from cache import caches

    task_1 = create_task(caches.init())
    task_2 = create_task(stor.init())
    await wait([task_1, task_2])

   # and so on and so on

Hope this helps.

-- les

[simonsax]

thanks a lot for your comprehensive feedback which helped me to fix the issue