Render a MessageElement queue as plain text.

        :returns: Plain text representation of the message.
        :rtype: str
429182
def to_text(self):
        
        message = ''
        last_was_text = False
        for m in self.message:
            if last_was_text and not isinstance(m, Text):
                message += '\n'

            message += m.to_text()

            if isinstance(m, Text):
                last_was_text = True
            else:
                message += '\n'
                last_was_text = False
        return message
387796
def to_text(self):
        
        if self.text is None:
            return

        level = '*' * self.level
        return '%s%s\n' % (level, self.text)
305405
def get(self, *args, **kwargs):
        
        if not mqueue.qsize():
            return None
        message_data, content_type, content_encoding = mqueue.get()
        return self.Message(backend=self, body=message_data,
                       content_type=content_type,
                       content_encoding=content_encoding)
659482
def to_text(self):
        

        table = ''
        if self.caption is not None:
            table += '%s</caption>\n' % self.caption
        table += '\n'
        for row in self.rows:
            table += row.to_text()
        return table
644336
def rendered_text(self):
        
        if len(self._plain_images) <= 0:
            self._convert_images()

        if self._animation is None:
            index = self._index
            self._index += 1
            if self._index >= len(self._plain_images):
                self._index = 0
        else:
            index = self._animation()
        return (self._plain_images[index],
                self._colour_map[index])
43319
def to_text(self):
        
        if self.text is None:
            return
        else:
            text = ''
            for t in self.text:
                text += t.to_text() + ' '
            return ' '.join(text.split())
1173858
def text(self) -> str:
        
        return self.export(output=Mimetypes.PLAINTEXT, exclude=self.default_exclude)
168907
def text(self, clean=True):
        
        if clean:
            return utils.normalise_whitespace(''.join(self).replace('\n', ' '))
        else:
            return ''.join(self)
807668
def render_as_text(self, limit=None):
        """"""
        lines = traceback.format_exception(self.exc_type, self.exc_value,
                                           self.frames[0], limit=limit)
        return ''.join(lines).rstrip()
1327002
public final void renderMessageString() {
        Object[] coreFields = event.getFieldsToLog();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < coreFields.length + xFields.length; ++i) {
            if (i > 0) {
                sb.append(fieldSeperator);
            }
            Object field = i < coreFields.length ? coreFields[i] : xFields[i - coreFields.length];
            renderObject(sb, field);

        }
        messageString = sb.toString();

    }
1236924
def render(self):
        """"""
        template = self.get_template()
        return template.render(
            messages=self._messages,
            metrics=self.metrics,
            report=self)
144066
def text(self):
        
        params = ', '.join(x.text for x in self.params)
        return '{0} ({1})'.format(self.proto_text, params)
5113
def to_text(self):
        
        if self.items is None:
            return
        else:
            text = ''
            for item in self.items:
                text += ' - %s\n' % item.to_text()

            return text
1076481
def plaintext(self):
        
        text = self.text
        text = self.OVERRIDE_SEQUENCE.sub("", text)
        text = text.replace(r"\h", " ")
        text = text.replace(r"\n", "\n")
        text = text.replace(r"\N", "\n")
        return text
488290
def message(self):
        
        return '\n'.join(
            [self.from_email, str(self.to), self.subject, self.body])
476582
def extract_from_plain(msg_body):
    """"""
    stripped_text = msg_body

    delimiter = get_delimiter(msg_body)
    msg_body = preprocess(msg_body, delimiter)
    # don't process too long messages
    lines = msg_body.splitlines()[:MAX_LINES_COUNT]
    markers = mark_message_lines(lines)
    lines = process_marked_lines(lines, markers)

    # concatenate lines, change links back, strip and return
    msg_body = delimiter.join(lines)
    msg_body = postprocess(msg_body)
    return msg_body
589795
def text(self):
        
        if self.out:
            self.out.close()  # pragma: nocover
        return self.fp.getvalue()