docs: def text(self, cls='current', retaintokenisation=False, previousdelimiter="",strict=False, correctionhandling=CorrectionHandling.CURRENT, normalize_spaces=False):
          """Get the text associated with this element (of the specified class)
  
          The text will be constructed from child-elements whereever possible, as they are more specific.
          If no text can be obtained from the children and the element has itself text associated with
          it, then that will be used.
  
          Parameters:
              cls (str): The class of the text content to obtain, defaults to ``current``.
              retaintokenisation (bool): If set, the space attribute on words will be ignored, otherwise it will be adhered to and text will be detokenised as much as possible. Defaults to ``False``.
              previousdelimiter (str): Can be set to a delimiter that was last outputed, useful when chaining calls to :meth:`text`. Defaults to an empty string.
              strict (bool):  Set this iif you are strictly interested in the text explicitly associated with the element, without recursing into children. Defaults to ``False``.
              correctionhandling: Specifies what text to retrieve when corrections are encountered. The default is ``CorrectionHandling.CURRENT``, which will retrieve the corrected/current text. You can set this to ``CorrectionHandling.ORIGINAL`` if you want the text prior to correction, and ``CorrectionHandling.EITHER`` if you don't care.
              normalize_spaces (bool): Return the text with multiple spaces, linebreaks, tabs normalized to single spaces
  
          Example::
  
              word.text()
  
          Returns:
              The text of the element (``unicode`` instance in Python 2, ``str`` in Python 3)
  
          Raises:
              :class:`NoSuchText`: if no text is found at all.
          """
  
          if strict:
              return self.textcontent(cls, correctionhandling).text(normalize_spaces=normalize_spaces)
  
          if self.TEXTCONTAINER:
              s = ""
              for e in self:
                  if isstring(e):
                      s += e
                  elif e.PRINTABLE:
                      if s: s += e.TEXTDELIMITER #for AbstractMarkup, will usually be ""
                      s += e.text()
              if normalize_spaces:
                  return norm_spaces(s)
              else:
                  return s
          elif not self.PRINTABLE: #only printable elements can hold text
              raise NoSuchText
          else:
              #Get text from children first
              delimiter = ""
              s = ""
              for e in self:
                  #was: e.PRINTABLE and not isinstance(e, TextContent) and not isinstance(e, String):
                  if isinstance(e, (AbstractStructureElement, Correction, AbstractSpanAnnotation)):   #AbstractSpanAnnotation is needed when requesting text() on nested span annotations
                      try:
                          s += e.text(cls,retaintokenisation, delimiter,False,correctionhandling)
  
                          #delimiter will be buffered and only printed upon next iteration, this prevents the delimiter being outputted at the end of a sequence and to be compounded with other delimiters
                          delimiter = e.gettextdelimiter(retaintokenisation)
                      except NoSuchText:
                          #No text, that's okay, just continue
                          continue
  
              if not s and self.hastext(cls, correctionhandling):
                  s = self.textcontent(cls, correctionhandling).text()
  
              if s and previousdelimiter:
                  s = previousdelimiter + s
              if s:
                  if normalize_spaces:
                      return norm_spaces(s)
                  else:
                      return s
              else:
                  #No text found at all :`(
                  raise NoSuchText