code: def get_incremental_uncovered_lines(abs_path: str,
                                      base_commit: str,
                                      actual_commit: Optional[str]
                                      ) -> List[Tuple[int, str, str]]:
      
      # Deleted files don't have any lines that need to be covered.
      if not os.path.isfile(abs_path):
          return []
  
      unified_diff_lines_str = shell_tools.output_of(
          'git',
          'diff',
          '--unified=0',
          base_commit,
          actual_commit,
          '--',
          abs_path)
      unified_diff_lines = [e
                            for e in unified_diff_lines_str.split('\n')
                            if e.strip()]
  
      touched_lines = diff_to_new_interesting_lines(unified_diff_lines)
  
      with open(abs_path, 'r') as actual_file:
          ignored_lines = determine_ignored_lines(actual_file.read())
  
      cover_path = abs_path + ',cover'
      has_cover_file = os.path.isfile(cover_path)
      content_file = cover_path if has_cover_file else abs_path
      with open(content_file, 'r') as annotated_coverage_file:
          return [(i, fix_line_from_coverage_file(line), touched_lines[i])
                  for i, line in enumerate(annotated_coverage_file, start=1)
                  if i in touched_lines and i not in ignored_lines
                  if line_counts_as_uncovered(line, has_cover_file)]
docs: Uses git diff and the annotation files created by
      `pytest --cov-report annotate` to find touched but uncovered lines in the
      given file.
  
      Args:
          abs_path: The path of a file to look for uncovered lines in.
          base_commit: Old state to diff against.
          actual_commit: Current state. Use None to use local uncommitted files.
  
      Returns:
          A list of the indices, content, and reason-for-including of
          'interesting' uncovered lines. An interesting uncovered line is one
          involved with the diff.