class_docstr: :py:func:`parso.load_grammar` returns instances of this class.
  
  Creating custom none-python grammars by calling this is not supported, yet.
class_docstr_tok: [":","py",":","func",":","`","parso.load_grammar","`","returns","instances","of","this","class",".","Creating","custom","none-python","grammars","by","calling","this","is","not","supported",",","yet","."]
docstr: Wanted python3.5 * operator and keyword only arguments. Therefore just
  wrap it all.
  start_pos here is just a parameter internally used. Might be public
  sometime in the future.
docstr_tok: ["Wanted","python3.5","*","operator","and","keyword","only","arguments",".","Therefore","just","wrap","it","all",".","start_pos","here","is","just","a","parameter","internally","used",".","Might","be","public","sometime","in","the","future","."]
code: def _parse(
      self,
      code=None,
      error_recovery=True,
      path=None,
      start_symbol=None,
      cache=False,
      diff_cache=False,
      cache_path=None,
      file_io=None,
      start_pos=(1, 0),
  ):
      """
      Wanted python3.5 * operator and keyword only arguments. Therefore just
      wrap it all.
      start_pos here is just a parameter internally used. Might be public
      sometime in the future.
      """
      if code is None and path is None and file_io is None:
          raise TypeError("Please provide either code or a path.")
  
      if start_symbol is None:
          start_symbol = self._start_nonterminal
  
      if error_recovery and start_symbol != "file_input":
          raise NotImplementedError(
              "This is currently not implemented."
          )
  
      if file_io is None:
          if code is None:
              file_io = FileIO(path)
          else:
              file_io = KnownContentFileIO(path, code)
  
      if cache and file_io.path is not None:
          module_node = load_module(
              self._hashed, file_io, cache_path=cache_path
          )
          if module_node is not None:
              return module_node
  
      if code is None:
          code = file_io.read()
      code = python_bytes_to_unicode(code)
  
      lines = split_lines(code, keepends=True)
      if diff_cache:
          if self._diff_parser is None:
              raise TypeError(
                  "You have to define a diff parser to be able "
                  "to use this option."
              )
          try:
              module_cache_item = parser_cache[self._hashed][
                  file_io.path
              ]
          except KeyError:
              pass
          else:
              module_node = module_cache_item.node
              old_lines = module_cache_item.lines
              if old_lines == lines:
                  return module_node
  
              new_node = self._diff_parser(
                  self._pgen_grammar, self._tokenizer, module_node
              ).update(old_lines=old_lines, new_lines=lines)
              try_to_save_module(
                  self._hashed,
                  file_io,
                  new_node,
                  lines,
                  # Never pickle in pypy, it's slow as hell.
                  pickling=cache and not is_pypy,
                  cache_path=cache_path,
              )
              return new_node
  
      tokens = self._tokenizer(lines, start_pos=start_pos)
  
      p = self._parser(
          self._pgen_grammar,
          error_recovery=error_recovery,
          start_nonterminal=start_symbol,
      )
      root_node = p.parse(tokens=tokens)
  
      if cache or diff_cache:
          try_to_save_module(
              self._hashed,
              file_io,
              root_node,
              lines,
              # Never pickle in pypy, it's slow as hell.
              pickling=cache and not is_pypy,
              cache_path=cache_path,
          )
      return root_node
  
imports: import hashlib
  import os
  import sys
  import pkgutil
  from parso._compatibility import FileNotFoundError, is_pypy
  from parso.pgen2 import generate_grammar
  from parso.utils import split_lines, python_bytes_to_unicode, parse_version_string
  from parso.python.diff import DiffParser
  from parso.python.tokenize import tokenize_lines, tokenize
  from parso.python.token import PythonTokenTypes
  from parso.cache import parser_cache, load_module, try_to_save_module
  from parso.parser import BaseParser
  from parso.python.parser import Parser
  from parso.python.errors import ErrorFinderConfig
  from parso.python import pep8
  from parso.file_io import FileIO, KnownContentFileIO
  from parso.normalizer import RefactoringNormalizer
label_desc: Use image node_id 3 for calling the Grammar obj's underlying member method code with example usage: obj._parse(code, error_recovery, path, start_symbol, cache, diff_cache, cache_path, file_io, start_pos) and returns: root_node, module_node, new_node, module_node