docs: def open(self, path, encoding=None, use_cached_encoding=True):
          """
          Open a file and set its content on the editor widget.
  
          pyqode does not try to guess encoding. It's up to the client code to
          handle encodings. You can either use a charset detector to detect
          encoding or rely on a settings in your application. It is also up to
          you to handle UnicodeDecodeError, unless you've added
          class:`pyqode.core.panels.EncodingPanel` on the editor.
  
          pyqode automatically caches file encoding that you can later reuse it
          automatically.
  
          :param path: Path of the file to open.
          :param encoding: Default file encoding. Default is to use the locale
                           encoding.
          :param use_cached_encoding: True to use the cached encoding instead
              of ``encoding``. Set it to True if you want to force reload with a
              new encoding.
  
          :raises: UnicodeDecodeError in case of error if no EncodingPanel
              were set on the editor.
          """
          ret_val = False
          if encoding is None:
              encoding = locale.getpreferredencoding()
          self.opening = True
          settings = Cache()
          self._path = path
          # get encoding from cache
          if use_cached_encoding:
              try:
                  cached_encoding = settings.get_file_encoding(
                      path, preferred_encoding=encoding)
              except KeyError:
                  pass
              else:
                  encoding = cached_encoding
          enable_modes = os.path.getsize(path) < self._limit
          for m in self.editor.modes:
              if m.enabled:
                  m.enabled = enable_modes
          # open file and get its content
          try:
              with open(path, 'Ur', encoding=encoding) as file:
                  content = file.read()
                  if self.autodetect_eol:
                      self._eol = file.newlines
                      if isinstance(self._eol, tuple):
                          self._eol = self._eol[0]
                      if self._eol is None:
                          # empty file has no newlines
                          self._eol = self.EOL.string(self.preferred_eol)
                  else:
                      self._eol = self.EOL.string(self.preferred_eol)
          except (UnicodeDecodeError, UnicodeError) as e:
              try:
                  from pyqode.core.panels import EncodingPanel
                  panel = self.editor.panels.get(EncodingPanel)
              except KeyError:
                  raise e  # panel not found, not automatic error management
              else:
                  panel.on_open_failed(path, encoding)
          else:
              # success! Cache the encoding
              settings.set_file_encoding(path, encoding)
              self._encoding = encoding
              # replace tabs by spaces
              if self.replace_tabs_by_spaces:
                  content = content.replace("\t", " " * self.editor.tab_length)
              # set plain text
              self.editor.setPlainText(
                  content, self.get_mimetype(path), self.encoding)
              self.editor.setDocumentTitle(self.editor.file.name)
              ret_val = True
              _logger().debug('file open: %s', path)
          self.opening = False
          if self.restore_cursor:
              self._restore_cached_pos()
          self._check_for_readonly()
          return ret_val