robotframework 6.1rc1__zip → 7.0__zip

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/control.py

@@ -13,49 +13,90 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-import sys
-from typing import Any, cast, Sequence, TypeVar, TYPE_CHECKING
-if sys.version_info >= (3, 8):
-    from typing import Literal
+import warnings
+from collections import OrderedDict
+from typing import Any, cast, Mapping, Literal, Sequence, TypeVar, TYPE_CHECKING
 
 from robot.utils import setter
 
-from .body import Body, BodyItem, BodyItemParent, BaseBranches
-from .keyword import Keywords
+from .body import Body, BodyItem, BodyItemParent, BaseBranches, BaseIterations
 from .modelobject import DataDict
 from .visitor import SuiteVisitor
 
 if TYPE_CHECKING:
     from robot.model import Keyword, Message
 
+
 IT = TypeVar('IT', bound='IfBranch|TryBranch')
+FW = TypeVar('FW', bound='ForIteration|WhileIteration')
+
+
+class Branches(BaseBranches['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+                            'Continue', 'Break', 'Message', 'Error', IT]):
+    __slots__ = ()
+
+
+class Iterations(BaseIterations['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
+                                'Continue', 'Break', 'Message', 'Error', FW]):
+    __slots__ = ()
+
+
+class ForIteration(BodyItem):
+    """Represents one FOR loop iteration."""
+    type = BodyItem.ITERATION
+    body_class = Body
+    repr_args = ('assign',)
+    __slots__ = ['assign', 'message', 'status', '_start_time', '_end_time',
+                 '_elapsed_time']
+
+    def __init__(self, assign: 'Mapping[str, str]|None' = None,
+                 parent: BodyItemParent = None):
+        self.assign = OrderedDict(assign or ())
+        self.parent = parent
+        self.body = ()
 
+    @property
+    def variables(self) -> 'Mapping[str, str]':    # TODO: Remove in RF 8.0.
+        """Deprecated since Robot Framework 7.0. Use :attr:`assign` instead."""
+        warnings.warn("'ForIteration.variables' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'ForIteration.assign' instead.")
+        return self.assign
+
+    @setter
+    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
+        return self.body_class(self, body)
 
-class Branches(BaseBranches['Keyword', 'For', 'While', 'If', 'Try', 'Return', 'Continue',
-                            'Break', 'Message', 'Error', IT]):
-    pass
+    def visit(self, visitor: SuiteVisitor):
+        visitor.visit_for_iteration(self)
+
+    @property
+    def _log_name(self):
+        return ', '.join(f'{name} = {value}' for name, value in self.assign.items())
+
+    def to_dict(self) -> DataDict:
+        return {
+            'type': self.type,
+            'assign': dict(self.assign),
+            'body': self.body.to_dicts()
+        }
 
 
 @Body.register
 class For(BodyItem):
-    """Represents ``FOR`` loops.
-
-    :attr:`flavor` specifies the flavor, and it can be ``IN``, ``IN RANGE``,
-    ``IN ENUMERATE`` or ``IN ZIP``.
-    """
+    """Represents ``FOR`` loops."""
     type = BodyItem.FOR
     body_class = Body
-    repr_args = ('variables', 'flavor', 'values', 'start', 'mode', 'fill')
-    __slots__ = ['variables', 'flavor', 'values', 'start', 'mode', 'fill']
+    repr_args = ('assign', 'flavor', 'values', 'start', 'mode', 'fill')
+    __slots__ = ['assign', 'flavor', 'values', 'start', 'mode', 'fill']
 
-    def __init__(self, variables: Sequence[str] = (),
-                 flavor: "Literal['IN', 'IN RANGE', 'IN ENUMERATE', 'IN ZIP']" = 'IN',
+    def __init__(self, assign: Sequence[str] = (),
+                 flavor: Literal['IN', 'IN RANGE', 'IN ENUMERATE', 'IN ZIP'] = 'IN',
                  values: Sequence[str] = (),
                  start: 'str|None' = None,
                  mode: 'str|None' = None,
                  fill: 'str|None' = None,
                  parent: BodyItemParent = None):
-        self.variables = tuple(variables)
+        self.assign = tuple(assign)
         self.flavor = flavor
         self.values = tuple(values)
         self.start = start
@@ -64,37 +105,29 @@ class For(BodyItem):
         self.parent = parent
         self.body = ()
 
+    @property
+    def variables(self) -> 'tuple[str, ...]':    # TODO: Remove in RF 8.0.
+        """Deprecated since Robot Framework 7.0. Use :attr:`assign` instead."""
+        warnings.warn("'For.variables' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'For.assign' instead.")
+        return self.assign
+
+    @variables.setter
+    def variables(self, assign: 'tuple[str, ...]'):
+        warnings.warn("'For.variables' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'For.assign' instead.")
+        self.assign = assign
+
     @setter
     def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
         return self.body_class(self, body)
 
-    @property
-    def keywords(self):
-        """Deprecated since Robot Framework 4.0. Use :attr:`body` instead."""
-        return Keywords(self, self.body)
-
-    @keywords.setter
-    def keywords(self, keywords):
-        Keywords.raise_deprecation_error()
-
     def visit(self, visitor: SuiteVisitor):
         visitor.visit_for(self)
 
-    def __str__(self):
-        parts = ['FOR', *self.variables, self.flavor, *self.values]
-        for name, value in [('start', self.start),
-                            ('mode', self.mode),
-                            ('fill', self.fill)]:
-            if value is not None:
-                parts.append(f'{name}={value}')
-        return '    '.join(parts)
-
-    def _include_in_repr(self, name: str, value: Any) -> bool:
-        return name not in ('start', 'mode', 'fill') or value is not None
-
     def to_dict(self) -> DataDict:
         data = {'type': self.type,
-                'variables': self.variables,
+                'assign': self.assign,
                 'flavor': self.flavor,
                 'values': self.values}
         for name, value in [('start', self.start),
@@ -105,6 +138,42 @@ class For(BodyItem):
         data['body'] = self.body.to_dicts()
         return data
 
+    def __str__(self):
+        parts = ['FOR', *self.assign, self.flavor, *self.values]
+        for name, value in [('start', self.start),
+                            ('mode', self.mode),
+                            ('fill', self.fill)]:
+            if value is not None:
+                parts.append(f'{name}={value}')
+        return '    '.join(parts)
+
+    def _include_in_repr(self, name: str, value: Any) -> bool:
+        return value is not None or name in ('assign', 'flavor', 'values')
+
+
+class WhileIteration(BodyItem):
+    """Represents one WHILE loop iteration."""
+    type = BodyItem.ITERATION
+    body_class = Body
+    __slots__ = ()
+
+    def __init__(self, parent: BodyItemParent = None):
+        self.parent = parent
+        self.body = ()
+
+    @setter
+    def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
+        return self.body_class(self, body)
+
+    def visit(self, visitor: SuiteVisitor):
+        visitor.visit_while_iteration(self)
+
+    def to_dict(self) -> DataDict:
+        return {
+            'type': self.type,
+            'body': self.body.to_dicts()
+        }
+
 
 @Body.register
 class While(BodyItem):
@@ -133,18 +202,6 @@ class While(BodyItem):
     def visit(self, visitor: SuiteVisitor):
         visitor.visit_while(self)
 
-    def __str__(self) -> str:
-        parts = ['WHILE']
-        if self.condition is not None:
-            parts.append(self.condition)
-        if self.limit is not None:
-            parts.append(f'limit={self.limit}')
-        if self.on_limit is not None:
-            parts.append(f'limit={self.on_limit}')
-        if self.on_limit_message is not None:
-            parts.append(f'on_limit_message={self.on_limit_message}')
-        return '    '.join(parts)
-
     def _include_in_repr(self, name: str, value: Any) -> bool:
         return name == 'condition' or value is not None
 
@@ -152,12 +209,25 @@ class While(BodyItem):
         data: DataDict = {'type': self.type}
         for name, value in [('condition', self.condition),
                             ('limit', self.limit),
+                            ('on_limit', self.on_limit),
                             ('on_limit_message', self.on_limit_message)]:
             if value is not None:
                 data[name] = value
         data['body'] = self.body.to_dicts()
         return data
 
+    def __str__(self) -> str:
+        parts = ['WHILE']
+        if self.condition is not None:
+            parts.append(self.condition)
+        if self.limit is not None:
+            parts.append(f'limit={self.limit}')
+        if self.on_limit is not None:
+            parts.append(f'on_limit={self.on_limit}')
+        if self.on_limit_message is not None:
+            parts.append(f'on_limit_message={self.on_limit_message}')
+        return '    '.join(parts)
+
 
 class IfBranch(BodyItem):
     """Represents individual ``IF``, ``ELSE IF`` or ``ELSE`` branch."""
@@ -186,6 +256,16 @@ class IfBranch(BodyItem):
             return self._get_id(self.parent)
         return self._get_id(self.parent.parent)
 
+    def visit(self, visitor: SuiteVisitor):
+        visitor.visit_if_branch(self)
+
+    def to_dict(self) -> DataDict:
+        data = {'type': self.type}
+        if self.condition:
+            data['condition'] = self.condition
+        data['body'] = self.body.to_dicts()
+        return data
+
     def __str__(self) -> str:
         if self.type == self.IF:
             return f'IF    {self.condition}'
@@ -193,17 +273,6 @@ class IfBranch(BodyItem):
             return f'ELSE IF    {self.condition}'
         return 'ELSE'
 
-    def visit(self, visitor: SuiteVisitor):
-        visitor.visit_if_branch(self)
-
-    def to_dict(self) -> DataDict:
-        data = {'type': self.type,
-                'condition': self.condition,
-                'body': self.body.to_dicts()}
-        if self.type == self.ELSE:
-            data.pop('condition')
-        return data
-
 
 @Body.register
 class If(BodyItem):
@@ -237,23 +306,36 @@ class If(BodyItem):
 class TryBranch(BodyItem):
     """Represents individual ``TRY``, ``EXCEPT``, ``ELSE`` or ``FINALLY`` branch."""
     body_class = Body
-    repr_args = ('type', 'patterns', 'pattern_type', 'variable')
-    __slots__ = ['type', 'patterns', 'pattern_type', 'variable']
+    repr_args = ('type', 'patterns', 'pattern_type', 'assign')
+    __slots__ = ['type', 'patterns', 'pattern_type', 'assign']
 
     def __init__(self, type: str = BodyItem.TRY,
                  patterns: Sequence[str] = (),
                  pattern_type: 'str|None' = None,
-                 variable: 'str|None' = None,
+                 assign: 'str|None' = None,
                  parent: BodyItemParent = None):
-        if (patterns or pattern_type or variable) and type != BodyItem.EXCEPT:
-            raise TypeError(f"'{type}' branches do not accept patterns or variables.")
+        if (patterns or pattern_type or assign) and type != BodyItem.EXCEPT:
+            raise TypeError(f"'{type}' branches do not accept patterns or assignment.")
         self.type = type
         self.patterns = tuple(patterns)
         self.pattern_type = pattern_type
-        self.variable = variable
+        self.assign = assign
         self.parent = parent
         self.body = ()
 
+    @property
+    def variable(self) -> 'str|None':    # TODO: Remove in RF 8.0.
+        """Deprecated since Robot Framework 7.0. Use :attr:`assign` instead."""
+        warnings.warn("'TryBranch.variable' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'TryBranch.assign' instead.")
+        return self.assign
+
+    @variable.setter
+    def variable(self, assign: 'str|None'):
+        warnings.warn("'TryBranch.variable' is deprecated and will be removed in "
+                      "Robot Framework 8.0. Use 'TryBranch.assign' instead.")
+        self.assign = assign
+
     @setter
     def body(self, body: 'Sequence[BodyItem|DataDict]') -> Body:
         return self.body_class(self, body)
@@ -267,19 +349,6 @@ class TryBranch(BodyItem):
             return self._get_id(self.parent)
         return self._get_id(self.parent.parent)
 
-    def __str__(self) -> str:
-        if self.type != BodyItem.EXCEPT:
-            return self.type
-        parts = ['EXCEPT', *self.patterns]
-        if self.pattern_type:
-            parts.append(f'type={self.pattern_type}')
-        if self.variable:
-            parts.extend(['AS', self.variable])
-        return '    '.join(parts)
-
-    def _include_in_repr(self, name: str, value: Any) -> bool:
-        return bool(value)
-
     def visit(self, visitor: SuiteVisitor):
         visitor.visit_try_branch(self)
 
@@ -289,11 +358,24 @@ class TryBranch(BodyItem):
             data['patterns'] = self.patterns
             if self.pattern_type:
                 data['pattern_type'] = self.pattern_type
-            if self.variable:
-                data['variable'] = self.variable
+            if self.assign:
+                data['assign'] = self.assign
         data['body'] = self.body.to_dicts()
         return data
 
+    def __str__(self) -> str:
+        if self.type != BodyItem.EXCEPT:
+            return self.type
+        parts = ['EXCEPT', *self.patterns]
+        if self.pattern_type:
+            parts.append(f'type={self.pattern_type}')
+        if self.assign:
+            parts.extend(['AS', self.assign])
+        return '    '.join(parts)
+
+    def _include_in_repr(self, name: str, value: Any) -> bool:
+        return bool(value)
+
 
 @Body.register
 class Try(BodyItem):
@@ -330,7 +412,7 @@ class Try(BodyItem):
         return None
 
     @property
-    def finally_branch(self):
+    def finally_branch(self) -> 'TryBranch|None':
         if self.body and self.body[-1].type == BodyItem.FINALLY:
             return cast(TryBranch, self.body[-1])
         return None
@@ -348,6 +430,49 @@ class Try(BodyItem):
                 'body': self.body.to_dicts()}
 
 
+@Body.register
+class Var(BodyItem):
+    """Represents ``VAR``."""
+    type = BodyItem.VAR
+    repr_args = ('name', 'value', 'scope', 'separator')
+    __slots__ = ['name', 'value', 'scope', 'separator']
+
+    def __init__(self, name: str = '',
+                 value: 'str|Sequence[str]' = (),
+                 scope: 'str|None' = None,
+                 separator: 'str|None' = None,
+                 parent: BodyItemParent = None):
+        self.name = name
+        self.value = (value,) if isinstance(value, str) else tuple(value)
+        self.scope = scope
+        self.separator = separator
+        self.parent = parent
+
+    def visit(self, visitor: SuiteVisitor):
+        visitor.visit_var(self)
+
+    def to_dict(self) -> DataDict:
+        data = {'type': self.type,
+                'name': self.name,
+                'value': self.value}
+        if self.scope is not None:
+            data['scope'] = self.scope
+        if self.separator is not None:
+            data['separator'] = self.separator
+        return data
+
+    def __str__(self):
+        parts = ['VAR', self.name, *self.value]
+        if self.separator is not None:
+            parts.append(f'separator={self.separator}')
+        if self.scope is not None:
+            parts.append(f'scope={self.scope}')
+        return '    '.join(parts)
+
+    def _include_in_repr(self, name: str, value: Any) -> bool:
+        return value is not None or name in ('name', 'value')
+
+
 @Body.register
 class Return(BodyItem):
     """Represents ``RETURN``."""
@@ -364,8 +489,16 @@ class Return(BodyItem):
         visitor.visit_return(self)
 
     def to_dict(self) -> DataDict:
-        return {'type': self.type,
-                'values': self.values}
+        data = {'type': self.type}
+        if self.values:
+            data['values'] = self.values
+        return data
+
+    def __str__(self):
+        return '    '.join(['RETURN', *self.values])
+
+    def _include_in_repr(self, name: str, value: Any) -> bool:
+        return bool(value)
 
 
 @Body.register
@@ -383,6 +516,9 @@ class Continue(BodyItem):
     def to_dict(self) -> DataDict:
         return {'type': self.type}
 
+    def __str__(self):
+        return 'CONTINUE'
+
 
 @Body.register
 class Break(BodyItem):
@@ -399,6 +535,9 @@ class Break(BodyItem):
     def to_dict(self) -> DataDict:
         return {'type': self.type}
 
+    def __str__(self):
+        return 'BREAK'
+
 
 @Body.register
 class Error(BodyItem):
@@ -421,3 +560,6 @@ class Error(BodyItem):
     def to_dict(self) -> DataDict:
         return {'type': self.type,
                 'values': self.values}
+
+    def __str__(self):
+        return '    '.join(['ERROR', *self.values])

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/filter.py

@@ -18,7 +18,7 @@ from typing import Sequence, TYPE_CHECKING
 from robot.utils import setter
 
 from .tags import TagPatterns
-from .namepatterns import SuiteNamePatterns, TestNamePatterns
+from .namepatterns import NamePatterns
 from .visitor import SuiteVisitor
 
 if TYPE_CHECKING:
@@ -46,8 +46,8 @@ class EmptySuiteRemover(SuiteVisitor):
 class Filter(EmptySuiteRemover):
 
     def __init__(self,
-                 include_suites: 'SuiteNamePatterns|Sequence[str]|None' = None,
-                 include_tests: 'TestNamePatterns|Sequence[str]|None' = None,
+                 include_suites: 'NamePatterns|Sequence[str]|None' = None,
+                 include_tests: 'NamePatterns|Sequence[str]|None' = None,
                  include_tags: 'TagPatterns|Sequence[str]|None' = None,
                  exclude_tags: 'TagPatterns|Sequence[str]|None' = None):
         super().__init__()
@@ -57,12 +57,12 @@ class Filter(EmptySuiteRemover):
         self.exclude_tags = exclude_tags
 
     @setter
-    def include_suites(self, suites) -> 'SuiteNamePatterns|None':
-        return self._patterns_or_none(suites, SuiteNamePatterns)
+    def include_suites(self, suites) -> 'NamePatterns|None':
+        return self._patterns_or_none(suites, NamePatterns)
 
     @setter
-    def include_tests(self, tests) -> 'TestNamePatterns|None':
-        return self._patterns_or_none(tests, TestNamePatterns)
+    def include_tests(self, tests) -> 'NamePatterns|None':
+        return self._patterns_or_none(tests, NamePatterns)
 
     @setter
     def include_tags(self, tags) -> 'TagPatterns|None':
@@ -80,27 +80,33 @@ class Filter(EmptySuiteRemover):
     def start_suite(self, suite: 'TestSuite'):
         if not self:
             return False
-        if hasattr(suite, 'starttime'):
-            suite.starttime = suite.endtime = None
+        if hasattr(suite, 'start_time'):
+            suite.start_time = suite.end_time = suite.elapsed_time = None
         if self.include_suites is not None:
-            if self.include_suites.match(suite.name, suite.longname):
-                suite.visit(Filter(include_tests=self.include_tests,
-                                   include_tags=self.include_tags,
-                                   exclude_tags=self.exclude_tags))
-                return False
-            suite.tests = []
-            return True
-        if self.include_tests is not None:
-            suite.tests = [t for t in suite.tests
-                           if self.include_tests.match(t.name, t.longname)]
-        if self.include_tags is not None:
-            suite.tests = [t for t in suite.tests
-                           if self.include_tags.match(t.tags)]
-        if self.exclude_tags is not None:
-            suite.tests = [t for t in suite.tests
-                           if not self.exclude_tags.match(t.tags)]
+            return self._filter_based_on_suite_name(suite)
+        suite.tests = [t for t in suite.tests if self._test_included(t)]
         return bool(suite.suites)
 
+    def _filter_based_on_suite_name(self, suite: 'TestSuite') -> bool:
+        if self.include_suites.match(suite.name, suite.full_name):
+            suite.visit(Filter(include_tests=self.include_tests,
+                               include_tags=self.include_tags,
+                               exclude_tags=self.exclude_tags))
+            return False
+        suite.tests = []
+        return True
+
+    def _test_included(self, test: 'TestCase') -> bool:
+        tests, include, exclude \
+                = self.include_tests, self.include_tags, self.exclude_tags
+        if exclude is not None and exclude.match(test.tags):
+            return False
+        if include is not None and include.match(test.tags):
+            return True
+        if tests is not None and tests.match(test.name, test.full_name):
+            return True
+        return include is None and tests is None
+
     def __bool__(self) -> bool:
         return bool(self.include_suites is not None or
                     self.include_tests is not None or

{robotframework-6.1rc1 → robotframework-7.0}/src/robot/model/itemlist.py

@@ -108,14 +108,14 @@ class ItemList(MutableSequence[T]):
             index += 1
 
     @overload
-    def __getitem__(self, index: int) -> T:
+    def __getitem__(self, index: int, /) -> T:
         ...
 
     @overload
-    def __getitem__(self: Self, index: slice) -> Self:
+    def __getitem__(self: Self, index: slice, /) -> Self:
         ...
 
-    def __getitem__(self, index):
+    def __getitem__(self: Self, index: 'int|slice', /) -> 'T|Self':
         if isinstance(index, slice):
             return self._create_new_from(self._items[index])
         return self._items[index]
@@ -129,23 +129,24 @@ class ItemList(MutableSequence[T]):
         return new
 
     @overload
-    def __setitem__(self, index: int, item: 'T|DataDict'):
+    def __setitem__(self, index: int, item: 'T|DataDict', /):
         ...
 
     @overload
-    def __setitem__(self, index: slice, item: 'Iterable[T|DataDict]'):
+    def __setitem__(self, index: slice, items: 'Iterable[T|DataDict]', /):
         ...
 
-    def __setitem__(self, index, item):
+    def __setitem__(self, index: 'int|slice',
+                    item: 'T|DataDict|Iterable[T|DataDict]', /):
         if isinstance(index, slice):
             self._items[index] = [self._check_type_and_set_attrs(i) for i in item]
         else:
             self._items[index] = self._check_type_and_set_attrs(item)
 
-    def __delitem__(self, index: 'int|slice'):
+    def __delitem__(self, index: 'int|slice', /):
         del self._items[index]
 
-    def __contains__(self, item: object) -> bool:
+    def __contains__(self, item: Any, /) -> bool:
         return item in self._items
 
     def __len__(self) -> int:

robotframework-7.0/src/robot/model/keyword.py

@@ -0,0 +1,77 @@
+#  Copyright 2008-2015 Nokia Networks
+#  Copyright 2016-     Robot Framework Foundation
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from typing import Any, Dict, List, Sequence, Tuple, TYPE_CHECKING, Union
+
+from .body import Body, BodyItem, BodyItemParent
+from .modelobject import DataDict
+
+if TYPE_CHECKING:
+    from .visitor import SuiteVisitor
+
+
+Arguments = Union[Sequence[Union[Any, Tuple[Any], Tuple[str, Any]]],
+                  Tuple[List[Any], Dict[str, Any]]]
+
+
+@Body.register
+class Keyword(BodyItem):
+    """Base model for a single keyword.
+
+    Extended by :class:`robot.running.model.Keyword` and
+    :class:`robot.result.model.Keyword`.
+
+    Arguments from normal data are always strings, but other types are possible in
+    programmatic usage. See the docstrings of the extending classes for more details.
+    """
+    repr_args = ('name', 'args', 'assign')
+    __slots__ = ['name', 'args', 'assign', 'type']
+
+    def __init__(self, name: 'str|None' = '',
+                 args: Arguments = (),
+                 assign: Sequence[str] = (),
+                 type: str = BodyItem.KEYWORD,
+                 parent: BodyItemParent = None):
+        self.name = name
+        self.args = tuple(args)
+        self.assign = tuple(assign)
+        self.type = type
+        self.parent = parent
+
+    @property
+    def id(self) -> 'str|None':
+        if not self:
+            return None
+        return super().id
+
+    def visit(self, visitor: 'SuiteVisitor'):
+        """:mod:`Visitor interface <robot.model.visitor>` entry-point."""
+        if self:
+            visitor.visit_keyword(self)
+
+    def __bool__(self) -> bool:
+        return self.name is not None
+
+    def __str__(self) -> str:
+        parts = list(self.assign) + [self.name] + list(self.args)
+        return '    '.join(str(p) for p in parts)
+
+    def to_dict(self) -> DataDict:
+        data: DataDict = {'name': self.name}
+        if self.args:
+            data['args'] = self.args
+        if self.assign:
+            data['assign'] = self.assign
+        return data