robotframework 6.1rc1__zip → 7.0a1__zip

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/reporting/jsmodelbuilders.py

@@ -13,17 +13,19 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+import re
+
 from robot.output import LEVELS
+from robot.result import Error, Keyword, Message, Return
 
 from .jsbuildingcontext import JsBuildingContext
 from .jsexecutionresult import JsExecutionResult
 
-
 STATUSES = {'FAIL': 0, 'PASS': 1, 'SKIP': 2, 'NOT RUN': 3}
 KEYWORD_TYPES = {'KEYWORD': 0, 'SETUP': 1, 'TEARDOWN': 2,
                  'FOR': 3, 'ITERATION': 4, 'IF': 5, 'ELSE IF': 6, 'ELSE': 7,
-                 'RETURN': 8, 'TRY': 9, 'EXCEPT': 10, 'FINALLY': 11, 'WHILE': 12,
-                 'CONTINUE': 13, 'BREAK': 14, 'ERROR': 15}
+                 'RETURN': 8, 'VAR': 9, 'TRY': 10, 'EXCEPT': 11, 'FINALLY': 12,
+                 'WHILE': 13, 'CONTINUE': 14, 'BREAK': 15, 'ERROR': 16}
 
 
 class JsModelBuilder:
@@ -47,49 +49,61 @@ class JsModelBuilder:
         )
 
 
-class _Builder:
+class Builder:
+    robot_note = re.compile('<span class="robot-note">(.*)</span>')
 
-    def __init__(self, context):
+    def __init__(self, context: JsBuildingContext):
         self._context = context
         self._string = self._context.string
         self._html = self._context.html
         self._timestamp = self._context.timestamp
 
-    def _get_status(self, item):
+    def _get_status(self, item, note_only=False):
         model = (STATUSES[item.status],
-                 self._timestamp(item.starttime),
-                 item.elapsedtime)
-        msg = getattr(item, 'message', '')
+                 self._timestamp(item.start_time),
+                 round(item.elapsed_time.total_seconds() * 1000))
+        msg = item.message
         if not msg:
             return model
-        elif msg.startswith('*HTML*'):
-            msg = self._string(msg[6:].lstrip(), escape=False)
+        if note_only:
+            if msg.startswith('*HTML*'):
+                match = self.robot_note.search(msg)
+                if match:
+                    index = self._string(match.group(1))
+                    return model + (index,)
+            return model
+        if msg.startswith('*HTML*'):
+            index = self._string(msg[6:].lstrip(), escape=False)
         else:
-            msg = self._string(msg)
-        return model + (msg,)
+            index = self._string(msg)
+        return model + (index,)
 
-    def _build_keywords(self, steps, split=False):
+    def _build_body(self, body, split=False):
         splitting = self._context.start_splitting_if_needed(split)
-        # tuple([<listcomp>>]) is faster than tuple(<genex>) with short lists.
-        model = tuple([self._build_keyword(step) for step in steps])
+        # tuple([<listcomp>]) is faster than tuple(<genex>) with short lists.
+        model = tuple([self._build_body_item(item) for item in body])
         return model if not splitting else self._context.end_splitting(model)
 
-    def _build_keyword(self, step):
+    def _build_body_item(self, item):
         raise NotImplementedError
 
 
-class SuiteBuilder(_Builder):
+class SuiteBuilder(Builder):
 
     def __init__(self, context):
-        _Builder.__init__(self, context)
+        super().__init__(context)
         self._build_suite = self.build
         self._build_test = TestBuilder(context).build
-        self._build_keyword = KeywordBuilder(context).build
+        self._build_body_item = BodyItemBuilder(context).build
 
     def build(self, suite):
         with self._context.prune_input(suite.tests, suite.suites):
             stats = self._get_statistics(suite)  # Must be done before pruning
-            kws = [kw for kw in (suite.setup, suite.teardown) if kw]
+            fixture = []
+            if suite.has_setup:
+                fixture.append(suite.setup)
+            if suite.has_teardown:
+                fixture.append(suite.teardown)
             return (self._string(suite.name, attr=True),
                     self._string(suite.source),
                     self._context.relative_source(suite.source),
@@ -98,7 +112,7 @@ class SuiteBuilder(_Builder):
                     self._get_status(suite),
                     tuple(self._build_suite(s) for s in suite.suites),
                     tuple(self._build_test(t) for t in suite.tests),
-                    tuple(self._build_keyword(k, split=True) for k in kws),
+                    tuple(self._build_body_item(kw, split=True) for kw in fixture),
                     stats)
 
     def _yield_metadata(self, suite):
@@ -111,63 +125,76 @@ class SuiteBuilder(_Builder):
         return (stats.total, stats.passed, stats.failed, stats.skipped)
 
 
-class TestBuilder(_Builder):
+class TestBuilder(Builder):
 
     def __init__(self, context):
-        _Builder.__init__(self, context)
-        self._build_keyword = KeywordBuilder(context).build
+        super().__init__(context)
+        self._build_body_item = BodyItemBuilder(context).build
 
     def build(self, test):
-        kws = self._get_keywords(test)
+        body = self._get_body_items(test)
         with self._context.prune_input(test.body):
             return (self._string(test.name, attr=True),
                     self._string(test.timeout),
                     self._html(test.doc),
                     tuple(self._string(t) for t in test.tags),
                     self._get_status(test),
-                    self._build_keywords(kws, split=True))
+                    self._build_body(body, split=True))
 
-    def _get_keywords(self, test):
-        kws = []
-        if test.setup:
-            kws.append(test.setup)
-        kws.extend(test.body.flatten())
-        if test.teardown:
-            kws.append(test.teardown)
-        return kws
+    def _get_body_items(self, test):
+        body = test.body.flatten()
+        if test.has_setup:
+            body.insert(0, test.setup)
+        if test.has_teardown:
+            body.append(test.teardown)
+        return body
 
 
-class KeywordBuilder(_Builder):
+class BodyItemBuilder(Builder):
 
     def __init__(self, context):
-        _Builder.__init__(self, context)
-        self._build_keyword = self.build
+        super().__init__(context)
+        self._build_body_item = self.build
         self._build_message = MessageBuilder(context).build
 
     def build(self, item, split=False):
-        if item.type == item.MESSAGE:
+        if isinstance(item, Message):
             return self._build_message(item)
-        return self.build_keyword(item, split)
-
-    def build_keyword(self, kw, split=False):
+        with self._context.prune_input(item.body):
+            if isinstance (item, Keyword):
+                return self._build_keyword(item, split)
+            if isinstance(item, (Return, Error)):
+                return self._build(item, args='    '.join(item.values), split=split)
+            return self._build(item, item._log_name, split=split)
+
+    def _build_keyword(self, kw: Keyword, split):
         self._context.check_expansion(kw)
-        items = kw.body.flatten()
-        if getattr(kw, 'has_teardown', False):
-            items.append(kw.teardown)
-        with self._context.prune_input(kw.body):
-            return (KEYWORD_TYPES[kw.type],
-                    self._string(kw.kwname, attr=True),
-                    self._string(kw.libname, attr=True),
-                    self._string(kw.timeout),
-                    self._html(kw.doc),
-                    self._string(', '.join(kw.args)),
-                    self._string(', '.join(kw.assign)),
-                    self._string(', '.join(kw.tags)),
-                    self._get_status(kw),
-                    self._build_keywords(items, split))
-
-
-class MessageBuilder(_Builder):
+        body = kw.body.flatten()
+        if kw.has_setup:
+            body.insert(0, kw.setup)
+        if kw.has_teardown:
+            body.append(kw.teardown)
+        return self._build(kw, kw.name, kw.owner, kw.timeout, kw.doc,
+                           '    '.join(kw.args), '    '.join(kw.assign),
+                           ', '.join(kw.tags), body, split=split)
+
+    def _build(self, item, name='', owner='', timeout='', doc='', args='', assign='',
+               tags='', body=None, split=False):
+        if body is None:
+            body = item.body.flatten()
+        return (KEYWORD_TYPES[item.type],
+                self._string(name, attr=True),
+                self._string(owner, attr=True),
+                self._string(timeout),
+                self._html(doc),
+                self._string(args),
+                self._string(assign),
+                self._string(tags),
+                self._get_status(item, note_only=True),
+                self._build_body(body, split))
+
+
+class MessageBuilder(Builder):
 
     def build(self, msg):
         if msg.level in ('WARN', 'ERROR'):
@@ -196,10 +223,10 @@ class StatisticsBuilder:
                      for stat in stats)
 
 
-class ErrorsBuilder(_Builder):
+class ErrorsBuilder(Builder):
 
     def __init__(self, context):
-        _Builder.__init__(self, context)
+        super().__init__(context)
         self._build_message = ErrorMessageBuilder(context).build
 
     def build(self, errors):

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/reporting/stringcache.py

@@ -16,21 +16,22 @@
 from robot.utils import compress_text, html_format
 
 
+# TODO: can this be removed?
 class StringIndex(int):
     pass
 
 
 class StringCache:
+    empty = StringIndex(0)
     _compress_threshold = 80
     _use_compressed_threshold = 1.1
-    _zero_index = StringIndex(0)
 
     def __init__(self):
-        self._cache = {('', False): self._zero_index}
+        self._cache = {('', False): self.empty}
 
     def add(self, text, html=False):
         if not text:
-            return self._zero_index
+            return self.empty
         key = (text, html)
         if key not in self._cache:
             self._cache[key] = StringIndex(len(self._cache))

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/reporting/xunitwriter.py

@@ -13,7 +13,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.result import ResultVisitor
+from robot.result import ResultVisitor, TestCase, TestSuite
 from robot.utils import XmlWriter
 
 
@@ -38,32 +38,34 @@ class XUnitFileWriter(ResultVisitor):
     def __init__(self, xml_writer):
         self._writer = xml_writer
 
-    def start_suite(self, suite):
+    def start_suite(self, suite: TestSuite):
         stats = suite.statistics  # Accessing property only once.
         attrs = {'name': suite.name,
-                 'tests': f'{stats.total}',
+                 'tests': str(stats.total),
                  'errors': '0',
-                 'failures': f'{stats.failed}',
-                 'skipped': f'{stats.skipped}',
-                 'time': self._time_as_seconds(suite.elapsedtime),
-                 'timestamp' : self._starttime_to_isoformat(suite.starttime)}
+                 'failures': str(stats.failed),
+                 'skipped': str(stats.skipped),
+                 'time': format(suite.elapsed_time.total_seconds(), '.3f'),
+                 'timestamp': suite.start_time.isoformat() if suite.start_time else None}
         self._writer.start('testsuite', attrs)
 
-    def end_suite(self, suite):
+    def end_suite(self, suite: TestSuite):
         if suite.metadata or suite.doc:
             self._writer.start('properties')
             if suite.doc:
-                self._writer.element('property', attrs={'name': 'Documentation', 'value': suite.doc})
+                self._writer.element('property', attrs={'name': 'Documentation',
+                                                        'value': suite.doc})
             for meta_name, meta_value in suite.metadata.items():
-                self._writer.element('property', attrs={'name': meta_name, 'value': meta_value})
+                self._writer.element('property', attrs={'name': meta_name,
+                                                        'value': meta_value})
             self._writer.end('properties')
         self._writer.end('testsuite')
 
-    def visit_test(self, test):
+    def visit_test(self, test: TestCase):
         self._writer.start('testcase',
-                           {'classname': test.parent.longname,
+                           {'classname': test.parent.full_name,
                             'name': test.name,
-                            'time': self._time_as_seconds(test.elapsedtime)})
+                            'time': format(test.elapsed_time.total_seconds(), '.3f')})
         if test.failed:
             self._writer.element('failure', attrs={'message': test.message,
                                                    'type': 'AssertionError'})
@@ -72,9 +74,6 @@ class XUnitFileWriter(ResultVisitor):
                                                    'type': 'SkipExecution'})
         self._writer.end('testcase')
 
-    def _time_as_seconds(self, millis):
-        return format(millis / 1000, '.3f')
-
     def visit_keyword(self, kw):
         pass
 
@@ -86,8 +85,3 @@ class XUnitFileWriter(ResultVisitor):
 
     def end_result(self, result):
         self._writer.close()
-
-    def _starttime_to_isoformat(self, stime):
-        if not stime:
-            return None
-        return f'{stime[:4]}-{stime[4:6]}-{stime[6:8]}T{stime[9:22]}000'

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/result/__init__.py

@@ -38,7 +38,8 @@ __ http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#
 """
 
 from .executionresult import Result
-from .model import (Break, Continue, Error, For, ForIteration, If, IfBranch, Keyword, Message,
-                    Return, TestCase, TestSuite, Try, TryBranch, While, WhileIteration)
+from .model import (Break, Continue, Error, For, ForIteration, If, IfBranch, Keyword,
+                    Message, Return, TestCase, TestSuite, Try, TryBranch, Var, While,
+                    WhileIteration)
 from .resultbuilder import ExecutionResult, ExecutionResultBuilder
 from .visitor import ResultVisitor

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/result/configurer.py

@@ -14,7 +14,7 @@
 #  limitations under the License.
 
 from robot import model
-from robot.utils import is_string, secs_to_timestamp, timestamp_to_secs
+from robot.utils import is_string, parse_timestamp
 
 
 class SuiteConfigurer(model.SuiteConfigurer):
@@ -32,11 +32,11 @@ class SuiteConfigurer(model.SuiteConfigurer):
 
     def __init__(self, remove_keywords=None, log_level=None, start_time=None,
                  end_time=None, **base_config):
-        model.SuiteConfigurer.__init__(self, **base_config)
+        super().__init__(**base_config)
         self.remove_keywords = self._get_remove_keywords(remove_keywords)
         self.log_level = log_level
-        self.start_time = self._get_time(start_time)
-        self.end_time = self._get_time(end_time)
+        self.start_time = self._to_datetime(start_time)
+        self.end_time = self._to_datetime(end_time)
 
     def _get_remove_keywords(self, value):
         if value is None:
@@ -45,14 +45,13 @@ class SuiteConfigurer(model.SuiteConfigurer):
             return [value]
         return value
 
-    def _get_time(self, timestamp):
+    def _to_datetime(self, timestamp):
         if not timestamp:
             return None
         try:
-            secs = timestamp_to_secs(timestamp, seps=' :.-_')
+            return parse_timestamp(timestamp)
         except ValueError:
             return None
-        return secs_to_timestamp(secs, millis=True)
 
     def visit_suite(self, suite):
         model.SuiteConfigurer.visit_suite(self, suite)
@@ -66,6 +65,10 @@ class SuiteConfigurer(model.SuiteConfigurer):
 
     def _set_times(self, suite):
         if self.start_time:
-            suite.starttime = self.start_time
+            suite.end_time = suite.end_time    # Preserve original value.
+            suite.elapsed_time = None          # Force re-calculation.
+            suite.start_time = self.start_time
         if self.end_time:
-            suite.endtime = self.end_time
+            suite.start_time = suite.start_time
+            suite.elapsed_time = None
+            suite.end_time = self.end_time

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/result/flattenkeywordmatcher.py

@@ -15,7 +15,7 @@
 
 from robot.errors import DataError
 from robot.model import TagPatterns
-from robot.utils import MultiMatcher, is_list_like
+from robot.utils import MultiMatcher
 
 
 def validate_flatten_keyword(options):
@@ -34,7 +34,7 @@ def validate_flatten_keyword(options):
 class FlattenByTypeMatcher:
 
     def __init__(self, flatten):
-        if not is_list_like(flatten):
+        if isinstance(flatten, str):
             flatten = [flatten]
         flatten = [f.lower() for f in flatten]
         self.types = set()
@@ -55,13 +55,13 @@ class FlattenByTypeMatcher:
 class FlattenByNameMatcher:
 
     def __init__(self, flatten):
-        if not is_list_like(flatten):
+        if isinstance(flatten, str):
             flatten = [flatten]
         names = [n[5:] for n in flatten if n[:5].lower() == 'name:']
         self._matcher = MultiMatcher(names)
 
-    def match(self, kwname, libname=None):
-        name = '%s.%s' % (libname, kwname) if libname else kwname
+    def match(self, name, owner=None):
+        name = f'{owner}.{name}' if owner else name
         return self._matcher.match(name)
 
     def __bool__(self):
@@ -71,13 +71,13 @@ class FlattenByNameMatcher:
 class FlattenByTagMatcher:
 
     def __init__(self, flatten):
-        if not is_list_like(flatten):
+        if isinstance(flatten, str):
             flatten = [flatten]
         patterns = [p[4:] for p in flatten if p[:4].lower() == 'tag:']
         self._matcher = TagPatterns(patterns)
 
-    def match(self, kwtags):
-        return self._matcher.match(kwtags)
+    def match(self, tags):
+        return self._matcher.match(tags)
 
     def __bool__(self):
         return bool(self._matcher)

{robotframework-6.1rc1 → robotframework-7.0a1}/src/robot/result/keywordremover.py

@@ -13,37 +13,40 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from abc import ABC
+
 from robot.errors import DataError
 from robot.model import SuiteVisitor, TagPattern
-from robot.utils import Matcher, plural_or_not
-
-
-def KeywordRemover(how):
-    upper = how.upper()
-    if upper.startswith('NAME:'):
-        return ByNameKeywordRemover(pattern=how[5:])
-    if upper.startswith('TAG:'):
-        return ByTagKeywordRemover(pattern=how[4:])
-    try:
-        return {'ALL': AllKeywordsRemover,
-                'PASSED': PassedKeywordRemover,
-                'FOR': ForLoopItemsRemover,
-                'WHILE': WhileLoopItemsRemover,
-                'WUKS': WaitUntilKeywordSucceedsRemover}[upper]()
-    except KeyError:
-        raise DataError(f"Expected 'ALL', 'PASSED', 'NAME:<pattern>', 'TAG:<pattern>', "
-                        f"'FOR' or 'WUKS', got '{how}'.")
+from robot.utils import html_escape, Matcher, plural_or_not
 
 
-class _KeywordRemover(SuiteVisitor):
-    _message = 'Keyword data removed using --RemoveKeywords option.'
+class KeywordRemover(SuiteVisitor, ABC):
+    message = 'Content removed using the --remove-keywords option.'
 
     def __init__(self):
-        self._removal_message = RemovalMessage(self._message)
+        self.removal_message = RemovalMessage(self.message)
+
+    @classmethod
+    def from_config(cls, conf):
+        upper = conf.upper()
+        if upper.startswith('NAME:'):
+            return ByNameKeywordRemover(pattern=conf[5:])
+        if upper.startswith('TAG:'):
+            return ByTagKeywordRemover(pattern=conf[4:])
+        try:
+            return {'ALL': AllKeywordsRemover,
+                    'PASSED': PassedKeywordRemover,
+                    'FOR': ForLoopItemsRemover,
+                    'WHILE': WhileLoopItemsRemover,
+                    'WUKS': WaitUntilKeywordSucceedsRemover}[upper]()
+        except KeyError:
+            raise DataError(f"Expected 'ALL', 'PASSED', 'NAME:<pattern>', "
+                            f"'TAG:<pattern>', 'FOR' or 'WUKS', got '{conf}'.")
 
     def _clear_content(self, item):
-        item.body.clear()
-        self._removal_message.set(item)
+        if item.body:
+            item.body.clear()
+            self.removal_message.set_to(item)
 
     def _failed_or_warning_or_error(self, item):
         return not item.passed or self._warning_or_error(item)
@@ -54,19 +57,25 @@ class _KeywordRemover(SuiteVisitor):
         return finder.found
 
 
-class AllKeywordsRemover(_KeywordRemover):
+class AllKeywordsRemover(KeywordRemover):
 
-    def visit_keyword(self, keyword):
-        self._clear_content(keyword)
+    def start_body_item(self, item):
+        self._clear_content(item)
 
-    def visit_for(self, for_):
-        self._clear_content(for_)
+    def start_if(self, item):
+        pass
 
-    def visit_if_branch(self, branch):
-        self._clear_content(branch)
+    def start_if_branch(self, item):
+        self._clear_content(item)
 
+    def start_try(self, item):
+        pass
+
+    def start_try_branch(self, item):
+        self._clear_content(item)
 
-class PassedKeywordRemover(_KeywordRemover):
+
+class PassedKeywordRemover(KeywordRemover):
 
     def start_suite(self, suite):
         if not suite.statistics.failed:
@@ -76,28 +85,28 @@ class PassedKeywordRemover(_KeywordRemover):
 
     def visit_test(self, test):
         if not self._failed_or_warning_or_error(test):
-            for keyword in test.body:
-                self._clear_content(keyword)
+            for item in test.body:
+                self._clear_content(item)
 
     def visit_keyword(self, keyword):
         pass
 
 
-class ByNameKeywordRemover(_KeywordRemover):
+class ByNameKeywordRemover(KeywordRemover):
 
     def __init__(self, pattern):
-        _KeywordRemover.__init__(self)
+        super().__init__()
         self._matcher = Matcher(pattern, ignore='_')
 
     def start_keyword(self, kw):
-        if self._matcher.match(kw.name) and not self._warning_or_error(kw):
+        if self._matcher.match(kw.full_name) and not self._warning_or_error(kw):
             self._clear_content(kw)
 
 
-class ByTagKeywordRemover(_KeywordRemover):
+class ByTagKeywordRemover(KeywordRemover):
 
     def __init__(self, pattern):
-        _KeywordRemover.__init__(self)
+        super().__init__()
         self._pattern = TagPattern.from_string(pattern)
 
     def start_keyword(self, kw):
@@ -105,13 +114,13 @@ class ByTagKeywordRemover(_KeywordRemover):
             self._clear_content(kw)
 
 
-class _LoopItemsRemover(_KeywordRemover):
-    _message = '%d passing step%s removed using --RemoveKeywords option.'
+class LoopItemsRemover(KeywordRemover, ABC):
+    message = '{count} passing item{s} removed using the --remove-keywords option.'
 
     def _remove_from_loop(self, loop):
         before = len(loop.body)
         self._remove_keywords(loop.body)
-        self._removal_message.set_if_removed(loop, before)
+        self.removal_message.set_to_if_removed(loop, before)
 
     def _remove_keywords(self, body):
         iterations = body.filter(messages=False)
@@ -120,26 +129,26 @@ class _LoopItemsRemover(_KeywordRemover):
                 body.remove(it)
 
 
-class ForLoopItemsRemover(_LoopItemsRemover):
+class ForLoopItemsRemover(LoopItemsRemover):
 
     def start_for(self, for_):
         self._remove_from_loop(for_)
 
 
-class WhileLoopItemsRemover(_LoopItemsRemover):
+class WhileLoopItemsRemover(LoopItemsRemover):
 
     def start_while(self, while_):
         self._remove_from_loop(while_)
 
 
-class WaitUntilKeywordSucceedsRemover(_KeywordRemover):
-    _message = '%d failing step%s removed using --RemoveKeywords option.'
+class WaitUntilKeywordSucceedsRemover(KeywordRemover):
+    message = '{count} failing item{s} removed using the --remove-keywords option.'
 
     def start_keyword(self, kw):
-        if kw.libname == 'BuiltIn' and kw.kwname == 'Wait Until Keyword Succeeds':
+        if kw.owner == 'BuiltIn' and kw.name == 'Wait Until Keyword Succeeds':
             before = len(kw.body)
             self._remove_keywords(kw.body)
-            self._removal_message.set_if_removed(kw, before)
+            self.removal_message.set_to_if_removed(kw, before)
 
     def _remove_keywords(self, body):
         keywords = body.filter(messages=False)
@@ -172,12 +181,20 @@ class WarningAndErrorFinder(SuiteVisitor):
 class RemovalMessage:
 
     def __init__(self, message):
-        self._message = message
+        self.message = message
 
-    def set_if_removed(self, kw, len_before):
-        removed = len_before - len(kw.body)
+    def set_to_if_removed(self, item, len_before):
+        removed = len_before - len(item.body)
         if removed:
-            self.set(kw, self._message % (removed, plural_or_not(removed)))
-
-    def set(self, kw, message=None):
-        kw.doc = ('%s\n\n_%s_' % (kw.doc, message or self._message)).strip()
+            message = self.message.format(count=removed, s=plural_or_not(removed))
+            self.set_to(item, message)
+
+    def set_to(self, item, message=None):
+        if not item.message:
+            start = ''
+        elif item.message.startswith('*HTML*'):
+            start = item.message[6:].strip() + '<hr>'
+        else:
+            start = html_escape(item.message) + '<hr>'
+        message = message or self.message
+        item.message = f'*HTML* {start}<span class="robot-note">{message}</span>'