docs: def post_create_app(cls, app, **settings):
          """Init the extension for our chosen ORM Backend, if possible.
  
          This method will ensure that the ``db`` proxy is set to the right
          extension and that that extension is properly created and configured.
          Since it needs to call ``init_app`` it MUST be a Post Create Hook.
  
          If the chosen backend is PeeWee and no ``DATABASE`` config value is
          provided, we will delay initializing the extension until one is.
  
          Args:
              app (flask.Flask): The Flask application that was just made through
                  the :meth:`create_app` factory that we should bind extensions
                  to.
  
          Kwargs:
              orm_backend (str): If you want to explicitly specify an ORM Backend
                  to use, you should send it in this kwarg. Valid values are
                  either: ``'peewee'`` or ``'sqlalchemy'``.
              peewee_database (str): An explicit database connection URI we
                  should immeditately add to the configuration that should be
                  used to configure the PeeWee ORM Backend. This will result in
                  the ``DATABASE`` key being set to this value in the config and
                  will result in the PeeWee Flask extension being initialized
                  IMMEDIATELY and not delayed until the next call to
                  :meth:`configure`.
  
          Returns:
              flask.Flask: Returns the app it was given once this is done.
  
          Raises:
              RuntimeError: This is raised if we are asked to create the PeeWee
                  ORM, but are not given a database URI in either the
                  ``DATABASE`` config value, or the explicit ``peewee_database``
                  setting.
          """
          global _SELECTED_BACKEND
          backend = settings.pop('orm_backend', None)
          backend = _discover_ideal_backend(backend)
  
          # did not specify a backend, bail early
          if backend is MISSING:
              return app
  
          _swap_backends_error = ('Cannot swap ORM backends after one is '
                                  'declared!')
  
          if backend == _PEEWEE_BACKEND:
              if (_SELECTED_BACKEND is not MISSING
                      and _SELECTED_BACKEND != _PEEWEE_EXT):
                  raise RuntimeError(_swap_backends_error)
  
              # @TODO (orm): Does this really need to be ``peewee_database``? can
              # it be ``orm_database``?
              database_uri = settings.pop('peewee_database', None)
              if database_uri:
                  app.config['DATABASE'] = database_uri
  
              if 'DATABASE' not in app.config:
                  # since there is no DATABASE in the config, we need to wait
                  # until we init this; so we'll just do it after configure is
                  # called.
                  try:
                      app.add_post_configure_callback(
                          partial(cls._init_peewee_ext, app),
                          run_once=True
                      )
                  except NotImplementedError:
                      # this composed app doesn't implement multi-stage
                      # configuration, so there's no way we can proceed without
                      # an explicit DB =/; yes it's possible this could swallow
                      # another error, but if it does... the easiest fix is to do
                      # the same
                      # @TODO (docs): Multi Stage Configuration should be in
                      # the docs
                      err_msg = """\
                      The app you are trying to construct does not support
                      Multi Stage Configuration and no connection info for the
                      database was given at creation! Please call `create_app`
                      again and provide your database connection string as the
                      `peewee_database` kwarg!\
                      """
                      raise RuntimeError(err_msg)
              else:
                  # the DATABASE is already present, go ahead and just init now
                  cls._init_peewee_ext(app)
  
              _SELECTED_BACKEND = _PEEWEE_EXT
  
          elif backend == _SQLALCHEMY_BACKEND:
              # @TODO (orm): Finish SQLA implementation
              # do sqla bootstrap code
              if (_SELECTED_BACKEND is not MISSING
                      and _SELECTED_BACKEND != _SQLA_EXT):
                  raise RuntimeError(_swap_backends_error)
  
              _SELECTED_BACKEND = _SQLA_EXT
              _SQLA_EXT.init_app(app)
  
          else:
              err_msg = ("Explicit ORM backend provided, but could not recognize"
                         " the value! Valid values are: '{}'  and '{}';"
                         " received: '{}' instead!")
              err_msg = err_msg.format(_PEEWEE_BACKEND, _SQLALCHEMY_BACKEND,
                                       backend)
  
              raise RuntimeError(err_msg)
          return app