code: def load_readers(filenames=None, reader=None, reader_kwargs=None):
      """Create specified readers and assign files to them.
  
      Args:
          filenames (iterable or dict): A sequence of files that will be used to load data from. A ``dict`` object
                                        should map reader names to a list of filenames for that reader.
          reader (str or list): The name of the reader to use for loading the data or a list of names.
          reader_kwargs (dict): Keyword arguments to pass to specific reader instances.
              This can either be a single dictionary that will be passed to all
              reader instances, or a mapping of reader names to dictionaries.  If
              the keys of ``reader_kwargs`` match exactly the list of strings in
              ``reader`` or the keys of filenames, each reader instance will get its
              own keyword arguments accordingly.
  
      Returns: Dictionary mapping reader name to reader instance
  
      """
      reader_instances = {}
      if _early_exit(filenames, reader):
          return {}
  
      (
          reader,
          filenames,
          remaining_filenames,
      ) = _get_reader_and_filenames(reader, filenames)
      (
          reader_kwargs,
          reader_kwargs_without_filter,
      ) = _get_reader_kwargs(reader, reader_kwargs)
  
      for idx, reader_configs in enumerate(configs_for_reader(reader)):
          if isinstance(filenames, dict):
              readers_files = set(filenames[reader[idx]])
          else:
              readers_files = remaining_filenames
  
          try:
              reader_instance = load_reader(
                  reader_configs,
                  **reader_kwargs[
                      None if reader is None else reader[idx]
                  ],
              )
          except (KeyError, IOError, yaml.YAMLError) as err:
              LOG.info("Cannot use %s", str(reader_configs))
              LOG.debug(str(err))
              continue
  
          if not readers_files:
              # we weren't given any files for this reader
              continue
          loadables = reader_instance.select_files_from_pathnames(
              readers_files
          )
          if loadables:
              reader_instance.create_filehandlers(
                  loadables,
                  fh_kwargs=reader_kwargs_without_filter[
                      None if reader is None else reader[idx]
                  ],
              )
              reader_instances[reader_instance.name] = reader_instance
              remaining_filenames -= set(loadables)
          if not remaining_filenames:
              break
  
      _check_remaining_files(remaining_filenames)
      _check_reader_instances(reader_instances)
      return reader_instances
  
imports: from __future__ import annotations
  import logging
  import os
  import pathlib
  import pickle
  import warnings
  from datetime import datetime, timedelta
  from functools import total_ordering
  import yaml
  from yaml import UnsafeLoader
  from satpy._config import config_search_paths, get_entry_points_config_dirs, glob_config
  from .yaml_reader import AbstractYAMLReader
  from .yaml_reader import load_yaml_configs
label_desc: Use image node_id 14 for calling a global function with example usage: load_readers(filenames, reader, reader_kwargs) and returns: reader_instances, dict