code: def split_iter(src, sep=None, maxsplit=None):
      """Splits an iterable based on a separator, *sep*, a max of
      *maxsplit* times (no max by default). *sep* can be:
        * a single value
        * an iterable of separators
        * a single-argument callable that returns True when a separator is
          encountered
      ``split_iter()`` yields lists of non-separator values. A separator will
      never appear in the output.
      >>> list(split_iter(['hi', 'hello', None, None, 'sup', None, 'soap', None]))
      [['hi', 'hello'], ['sup'], ['soap']]
  
      Note that ``split_iter`` is based on :func:`str.split`, so if
      *sep* is ``None``, ``split()`` **groups** separators. If empty lists
      are desired between two contiguous ``None`` values, simply use
      ``sep=[None]``:
      >>> list(split_iter(['hi', 'hello', None, None, 'sup', None]))
      [['hi', 'hello'], ['sup']]
      >>> list(split_iter(['hi', 'hello', None, None, 'sup', None], sep=[None]))
      [['hi', 'hello'], [], ['sup'], []]
  
      Using a callable separator:
      >>> falsy_sep = lambda x: not x
      >>> list(split_iter(['hi', 'hello', None, '', 'sup', False], falsy_sep))
      [['hi', 'hello'], [], ['sup'], []]
  
      See :func:`split` for a list-returning version.
      """
      if not is_iterable(src):
          raise TypeError("expected an iterable")
  
      if maxsplit is not None:
          maxsplit = int(maxsplit)
          if maxsplit == 0:
              yield [src]
              return
  
      if callable(sep):
          sep_func = sep
      elif not is_scalar(sep):
          sep = frozenset(sep)
          sep_func = lambda x: x in sep
      else:
          sep_func = lambda x: x == sep
  
      cur_group = []
      split_count = 0
      for s in src:
          if maxsplit is not None and split_count >= maxsplit:
              sep_func = lambda x: False
          if sep_func(s):
              if sep is None and not cur_group:
                  # If sep is none, str.split() "groups" separators
                  # check the str.split() docs for more info
                  continue
              split_count += 1
              yield cur_group
              cur_group = []
          else:
              cur_group.append(s)
  
      if cur_group or sep is not None:
          yield cur_group
      return
  
imports: import os
  import math
  import time
  import codecs
  import random
  import socket
  import hashlib
  import itertools
  from collections import Mapping, Sequence, Set, ItemsView
label_desc: Use image node_id 5 for calling a global function with example usage: split_iter(src, sep, maxsplit) without return types