code: def _init_peewee_ext(cls, app, dummy_configuration=None,
                           dummy_configure_args=None):
          
          # the database still isn't present, go ahead and register the callback
          # again, so we can try later.
          if 'DATABASE' not in app.config:
              app.add_post_configure_callback(partial(cls._init_peewee_ext, app),
                                              run_once=True)
              return
  
          _PEEWEE_EXT.init_app(app)
docs: Init the actual PeeWee extension with the app that was created.
  
          Since PeeWee requires the ``DATABASE`` config parameter to be present
          IMMEDIATELY upon initializing the application, we need to delay this
          construction. This is because, in standard use, we will create the app
          and attempt to init this extension BEFORE we configure the app, which
          is totally fine. To fix this, we just need to set this up to try and
          run after every call to configure. If there is not ``DATABASE`` config
          parameter present when run, this method does nothing other than
          reschedule itself to run in the future.
  
          In all cases, this is a Post Configure Hook that should RUN ONCE!
  
          Args:
              app (flask.Flask): The application you want to init the PeeWee
                  Flask extension for. Hint: if you need to use this as
                  a callback, use a partial to provide this.
              dummy_configuration (dict): The resulting application configuration
                  that the post_configure hook provides to all of it's callbacks.
                  We will NEVER use this, but since we utilize the post_configure
                  system to register this for complicated apps, we gotta accept
                  it.
              dummy_configure_args (list[object]): The args passed to the
                  :meth:`configure` function that triggered this callback. Just
                  like the above arg, we'll never use it, but we must accept it.