class_docstr: An advanced form of parsing a file faster. Unfortunately comes with huge
  side effects. It changes the given module.
class_docstr_tok: ["An","advanced","form","of","parsing","a","file","faster",".","Unfortunately","comes","with","huge","side","effects",".","It","changes","the","given","module","."]
code: def _diff_tokenize(self, lines, until_line, line_offset=0):
      was_newline = False
      indents = self._nodes_tree.indents
      initial_indentation_count = len(indents)
  
      tokens = self._tokenizer(
          lines,
          start_pos=(line_offset + 1, 0),
          indents=indents,
          is_first_token=line_offset == 0,
      )
      stack = self._active_parser.stack
      self._replace_tos_indent = None
      self._keyword_token_indents = {}
      # print('start', line_offset + 1, indents)
      for token in tokens:
          # print(token, indents)
          typ = token.type
          if typ == DEDENT:
              if len(indents) < initial_indentation_count:
                  # We are done here, only thing that can come now is an
                  # endmarker or another dedented code block.
                  while True:
                      typ, string, start_pos, prefix = token = next(
                          tokens
                      )
                      if typ in (DEDENT, ERROR_DEDENT):
                          if typ == ERROR_DEDENT:
                              # We want to force an error dedent in the next
                              # parser/pass. To make this possible we just
                              # increase the location by one.
                              self._replace_tos_indent = (
                                  start_pos[1] + 1
                              )
                              pass
                      else:
                          break
  
                  if "\n" in prefix or "\r" in prefix:
                      prefix = re.sub(r"[^\n\r]+\Z", "", prefix)
                  else:
                      assert start_pos[1] >= len(prefix), repr(prefix)
                      if start_pos[1] - len(prefix) == 0:
                          prefix = ""
                  yield PythonToken(ENDMARKER, "", start_pos, prefix)
                  break
          elif typ == NEWLINE and token.start_pos[0] >= until_line:
              was_newline = True
          elif was_newline:
              was_newline = False
              if len(indents) == initial_indentation_count:
                  # Check if the parser is actually in a valid suite state.
                  if _suite_or_file_input_is_valid(
                      self._pgen_grammar, stack
                  ):
                      yield PythonToken(
                          ENDMARKER, "", token.start_pos, ""
                      )
                      break
  
          if typ == NAME and token.string in ("class", "def"):
              self._keyword_token_indents[token.start_pos] = list(
                  indents
              )
  
          yield token
  
imports: import re
  import difflib
  from collections import namedtuple
  import logging
  from parso.utils import split_lines
  from parso.python.parser import Parser
  from parso.python.tree import EndMarker
  from parso.python.tokenize import PythonToken, BOM_UTF8_STRING
  from parso.python.token import PythonTokenTypes
label_desc: Use image node_id 9 for calling the DiffParser obj's underlying member method code with example usage: obj._diff_tokenize(lines, until_line, line_offset) without return types