docs: def resolve_multiple_existing_paths(paths):
      """
      :param paths: A list of paths to items that need to be resolved
      :type paths: list
      :returns: A dictionary mapping a specified path to either its resolved
                object or Nones, if the object could not be resolved
      :rtype: dict
  
      For each input given in paths, attempts to resolve the path, and returns
      the resolved object in a dictionary.
  
      The return value will look like:
      {<path1>: <resolved_object1>, <path2>: <resolved_object2>,...}
  
      If entity_id is a DX ID that can be described,
          <resolved_object*> ::= {"project": None,
                                  "folder": None,
                                  "name": {"id": <id>,
                                           "describe": <describe_output>}}
  
      Else if a general resolution (or search) method will be used to resolve
      the entity,
          <resolved_object*> ::= {"project": <project>,
                                  "folder": None,
                                  "name": {"project": <project>,
                                           "id": <resolved_id>}}
  
      Else if <project> is a job ID,
          <resolved_object*> ::= {"project": None,
                                  "folder": None,
                                  "name": {"project": <project>,
                                           "id": <resolved_id>}}
  
      Else if the path refers to a folder instead of a data object,
          <resolved_object*> ::= {"project": <project>,
                                  "folder": <folder>,
                                  "name": None}
  
      Else if description or resolution fails,
          <resolved_object*> ::= {"project": None, "folder": None, "name": None}
      """
      done_objects = {}  # Return value
      to_resolve_in_batch_paths = []  # Paths to resolve
      to_resolve_in_batch_inputs = []  # Project, folderpath, and entity name
      for path in paths:
          project, folderpath, entity_name = resolve_path(path, expected='entity')
          try:
              must_resolve, project, folderpath, entity_name = _check_resolution_needed(
                  path, project, folderpath, entity_name)
          except:
              must_resolve = False
  
          if must_resolve:
              if is_glob_pattern(entity_name):
                  # TODO: Must call findDataObjects because resolveDataObjects does not support glob patterns
                  try:
                      find_results = _resolve_global_entity(project, folderpath, entity_name)
                      done_objects[path] = _format_resolution_output(path, project, folderpath, entity_name,
                                                                     find_results)
                  except ResolutionError:
                      # Catches any ResolutionError thrown by _resolve_global_entity
                      done_objects[path] = {"project": None, "folder": None, "name": None}
              else:
                  # Prepare batch call for resolveDataObjects
                  to_resolve_in_batch_paths.append(path)
                  to_resolve_in_batch_inputs.append({"project": project, "folder": folderpath, "name": entity_name})
          else:
              # No need to resolve
              done_objects[path] = {"project": project, "folder": folderpath, "name": entity_name}
  
      # Call resolveDataObjects
      resolution_results = dxpy.resolve_data_objects(to_resolve_in_batch_inputs)
      for path, inputs, result in zip(to_resolve_in_batch_paths, to_resolve_in_batch_inputs,
                                      resolution_results):
          done_objects[path] = _format_resolution_output(path, inputs["project"], inputs["folder"], inputs["name"],
                                                         result)
      return done_objects