docs: 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