docs: def Open(cls, fd, component, handlers, pathspec=None, progress_callback=None):
      """Try to correct the casing of component.
  
      This method is called when we failed to open the component directly. We try
      to transform the component into something which is likely to work.
  
      In this implementation, we correct the case of the component until we can
      not open the path any more.
  
      Args:
        fd: The base fd we will use.
        component: The component we should open.
        handlers: A mapping from rdf_paths.PathSpec.PathType to classes
          implementing VFSHandler.
        pathspec: The rest of the pathspec object.
        progress_callback: A callback to indicate that the open call is still
          working but needs more time.
  
      Returns:
        A file object.
  
      Raises:
        IOError: If nothing could be opened still.
      """
      # The handler for this component
      try:
        handler = handlers[component.pathtype]
      except KeyError:
        raise UnsupportedHandlerError(component.pathtype)
  
      # We will not do any case folding unless requested.
      if component.path_options == rdf_paths.PathSpec.Options.CASE_LITERAL:
        return handler(base_fd=fd, pathspec=component, handlers=handlers)
  
      path_components = client_utils.LocalPathToCanonicalPath(component.path)
      path_components = ["/"] + list(filter(None, path_components.split("/")))
      for i, path_component in enumerate(path_components):
        try:
          if fd:
            new_pathspec = fd.MatchBestComponentName(path_component)
          else:
            new_pathspec = component
            new_pathspec.path = path_component
  
          # The handler for this component
          try:
            handler = handlers[new_pathspec.pathtype]
          except KeyError:
            raise UnsupportedHandlerError(new_pathspec.pathtype)
  
          fd = handler(
              base_fd=fd,
              handlers=handlers,
              pathspec=new_pathspec,
              progress_callback=progress_callback)
        except IOError as e:
          # Can not open the first component, we must raise here.
          if i <= 1:
            raise IOError("File not found: {}".format(component))
  
          # Do not try to use TSK to open a not-found registry entry, fail
          # instead. Using TSK would lead to confusing error messages, hiding
          # the fact that the Registry entry is simply not there.
          if component.pathtype == rdf_paths.PathSpec.PathType.REGISTRY:
            raise IOError("Registry entry not found: {}".format(e))
  
          # Insert the remaining path at the front of the pathspec.
          pathspec.Insert(
              0,
              path=utils.JoinPath(*path_components[i:]),
              pathtype=rdf_paths.PathSpec.PathType.TSK)
          break
  
      return fd