Loads the relevant settings from the specified ``source``.

        :returns: a standard :func:`dict` containing the settings from the source
        :rtype: dict

def _load_settings_from_source(self, source):
        """
        Loads the relevant settings from the specified ``source``.

        :returns: a standard :func:`dict` containing the settings from the source
        :rtype: dict
        """
        if not source:
            pass
        elif source == 'env_settings_uri':
            for env_settings_uri_key in self.env_settings_uri_keys:
                env_settings_uri = self._search_environ(env_settings_uri_key)
                if env_settings_uri:
                    logger.debug('Found {} in the environment.'.format(env_settings_uri_key))
                    yield env_settings_uri, self._load_settings_from_uri(env_settings_uri)
                #end if
            #end for

        elif source == 'env':
            logger.debug('Loaded {} settings from the environment.'.format(len(os.environ)))
            yield source, dict(os.environ.items())

        elif isinstance(source, ParseResult):
            settings = self._load_settings_from_uri(source)
            yield source, settings

        elif isinstance(source, str):
            try: spec = importlib.util.find_spec(source)
            except (AttributeError, ImportError): spec = None

            settings = self._load_settings_from_spec(spec, name=source)
            if settings is None:
                _, ext = os.path.splitext(source)
                with uri_open(source, 'rb') as f:
                    yield source, self._load_settings_from_file(f, ext=ext)
            else:
                yield source, settings
            #end if

        elif hasattr(source, 'read'):
            yield source.name, self._load_settings_from_file(source)

        elif hasattr(source, 'items'):
            source_type = type(source).__name__
            for dict_settings_uri_key in self.dict_settings_uri_keys:
                if dict_settings_uri_key and dict_settings_uri_key in source and source[dict_settings_uri_key]:
                    logger.debug('Found {} in the dict-like object <{}>.'.format(dict_settings_uri_key, source_type))
                    yield from self._load_settings_from_source(source[dict_settings_uri_key])
                #end if
            #end for

            logger.debug('Loaded {} settings from dict-like object <{}>.'.format(len(source), source_type))
            yield self._get_unique_name(source_type), source

        else:
            source_type = type(source).__name__
            for object_settings_uri_key in self.object_settings_uri_keys:
                if object_settings_uri_key and hasattr(source, object_settings_uri_key) and getattr(source, object_settings_uri_key):
                    logger.debug('Found {} in the object <{}>.'.format(object_settings_uri_key, source_type))
                    yield from self._load_settings_from_source(getattr(source, object_settings_uri_key))
                #end if
            #end for

            settings = dict((k, v) for k, v in source.__dict__.items() if not k.startswith('__'))
            logger.debug('Loaded {} settings from object <{}>.'.format(len(settings), source_type))
            yield self._get_unique_name(source_type), settings