docs: def _parse_non_entities(self):
          """create data for all non-entities in the babelfied text
          set self._all_entities with merged entity and non-entity data
          """
          def _differ(tokens):
              inner, outer = tokens
              not_same_start = inner.get('start') != outer.get('start')
              not_same_end = inner.get('end') != outer.get('end')
              return not_same_start or not_same_end
  
          def _get_dot_token():
              dot_token = dict()
              dot_token['start'] = (len(self._text) - 1)
              dot_token['end'] = dot_token['start']
              dot_token['text'] = '.'
              dot_token['isEntity'] = False
              return dot_token
  
          if self._text.endswith('.'):
              text = self._text[:-1]
              add_dot_token = True
          else:
              text = self._text
              add_dot_token = False
  
          index = 0
          all_tokens = list()
          for token in text.split():
  
              comma_token = False
              if token.endswith(','):
                  comma_token = True
                  token = token[:-1]
  
              start = index
              end = (start + len(token))
              index += (len(token) + 1)
  
              all_tokens.append({
                  'start': start,
                  'end': end - 1,
                  'text': self._text[start: end],
                  'isEntity': False,
              })
  
              if comma_token:
                  all_tokens.append({
                      'start': index,
                      'end': index,
                      'text': ',',
                      'isEntity': False,
                  })
                  index += 1
  
          token_tuples = list(product(all_tokens, self.entities))
          redundant = [
              tokens[0] for tokens in token_tuples if not _differ(tokens)]
          non_entity_tokens = [
              item for item in all_tokens if item not in redundant]
  
          if add_dot_token:
              non_entity_tokens.append(_get_dot_token())
  
          self._all_entities = sorted(
              self._entities + non_entity_tokens, key=itemgetter('start'))