def configure(self, *args, **kwargs):
        """Configure the Application through a varied number of sources of
        different types.

        This function chains multiple possible configuration methods together
        in order to just "make it work". You can pass multiple configuration
        sources in to the method and each one will be tried in a sane fashion.
        Later sources will override earlier sources if keys collide. For
        example:

        .. code:: python

            from application import default_config
            app.configure(default_config, os.environ, '.secrets')

        In the above example, values stored in ``default_config`` will be
        loaded first, then overwritten by those in ``os.environ``, and so on.

        An endless number of configuration sources may be passed.

        Configuration sources are type checked and processed according to the
        following rules:

        * ``string`` - if the source is a ``str``, we will assume it is a file
          or module that should be loaded. If the file ends in ``.json``, then
          :meth:`flask.Config.from_json` is used; if the file ends in ``.py``
          or ``.cfg``, then :meth:`flask.Config.from_pyfile` is used; if the
          module has any other extension we assume it is an import path, import
          the module and pass that to :meth:`flask.Config.from_object`. See
          below for a few more semantics on module loading.
        * ``dict-like`` - if the source is ``dict-like``, then
          :meth:`flask.Config.from_mapping` will be used. ``dict-like`` is
          defined as anything implementing an ``items`` method that returns
          a tuple of ``key``, ``val``.
        * ``class`` or ``module`` - if the source is an uninstantiated
          ``class`` or ``module``, then :meth:`flask.Config.from_object` will
          be used.

        Just like Flask's standard configuration, only uppercased keys will be
        loaded into the config.

        If the item we are passed is a ``string`` and it is determined to be
        a possible Python module, then a leading ``.`` is relevant. If
        a leading ``.`` is provided, we assume that the module to import is
        located in the current package and operate as such; if it begins with
        anything else we assume the import path provided is absolute. This
        allows you to source configuration stored in a module in your package,
        or in another package.

        Args:
            *args (object):
                Any object you want us to try to configure from.

        Keyword Args:
            whitelist_keys_from_mappings (bool):
                Should we whitelist the keys we pull from mappings? Very useful
                if you're passing in an entire OS ``environ`` and you want to
                omit things like ``LESSPIPE``. If no whitelist is provided, we
                use the pre-existing config keys as a whitelist.
            whitelist (list[str]):
                An explicit list of keys that should be allowed. If provided
                and ``whitelist_keys`` is ``True``, we will use that as our
                whitelist instead of pre-existing app config keys.
        """
        whitelist_keys_from_mappings = kwargs.get(
            'whitelist_keys_from_mappings', False
        )
        whitelist = kwargs.get('whitelist')

        for item in args:
            if isinstance(item, string_types):
                _, ext = splitext(item)

                if ext == '.json':
                    self._configure_from_json(item)
                elif ext in ('.cfg', '.py'):
                    self._configure_from_pyfile(item)
                else:
                    self._configure_from_module(item)

            elif isinstance(item, (types.ModuleType, type)):
                self._configure_from_object(item)

            elif hasattr(item, 'items'):
                # assume everything else is a mapping like object; ``.items()``
                # is what Flask uses under the hood for this method
                # @TODO: This doesn't handle the edge case of using a tuple of
                # two element tuples to config; but Flask does that. IMO, if
                # you do that, you're a monster.
                self._configure_from_mapping(
                    item,
                    whitelist_keys=whitelist_keys_from_mappings,
                    whitelist=whitelist
                )

            else:
                raise TypeError("Could not determine a valid type for this"
                                " configuration object: `{}`!".format(item))

        # we just finished here, run the post configure callbacks
        self._run_post_configure_callbacks(args)
Configure the Application through a varied number of sources of
        different types.

        This function chains multiple possible configuration methods together
        in order to just "make it work". You can pass multiple configuration
        sources in to the method and each one will be tried in a sane fashion.
        Later sources will override earlier sources if keys collide. For
        example:

        .. code:: python

            from application import default_config
            app.configure(default_config, os.environ, '.secrets')

        In the above example, values stored in ``default_config`` will be
        loaded first, then overwritten by those in ``os.environ``, and so on.

        An endless number of configuration sources may be passed.

        Configuration sources are type checked and processed according to the
        following rules:

        * ``string`` - if the source is a ``str``, we will assume it is a file
          or module that should be loaded. If the file ends in ``.json``, then
          :meth:`flask.Config.from_json` is used; if the file ends in ``.py``
          or ``.cfg``, then :meth:`flask.Config.from_pyfile` is used; if the
          module has any other extension we assume it is an import path, import
          the module and pass that to :meth:`flask.Config.from_object`. See
          below for a few more semantics on module loading.
        * ``dict-like`` - if the source is ``dict-like``, then
          :meth:`flask.Config.from_mapping` will be used. ``dict-like`` is
          defined as anything implementing an ``items`` method that returns
          a tuple of ``key``, ``val``.
        * ``class`` or ``module`` - if the source is an uninstantiated
          ``class`` or ``module``, then :meth:`flask.Config.from_object` will
          be used.

        Just like Flask's standard configuration, only uppercased keys will be
        loaded into the config.

        If the item we are passed is a ``string`` and it is determined to be
        a possible Python module, then a leading ``.`` is relevant. If
        a leading ``.`` is provided, we assume that the module to import is
        located in the current package and operate as such; if it begins with
        anything else we assume the import path provided is absolute. This
        allows you to source configuration stored in a module in your package,
        or in another package.

        Args:
            *args (object):
                Any object you want us to try to configure from.

        Keyword Args:
            whitelist_keys_from_mappings (bool):
                Should we whitelist the keys we pull from mappings? Very useful
                if you're passing in an entire OS ``environ`` and you want to
                omit things like ``LESSPIPE``. If no whitelist is provided, we
                use the pre-existing config keys as a whitelist.
            whitelist (list[str]):
                An explicit list of keys that should be allowed. If provided
                and ``whitelist_keys`` is ``True``, we will use that as our
                whitelist instead of pre-existing app config keys.