body

BaseBody

Bases: ItemList[BodyItem], Generic[KW, F, W, I, T, V, R, C, B, M, E]

Base class for Body and Branches objects.

Source code in src/robot/model/body.py

class BaseBody(ItemList[BodyItem], Generic[KW, F, W, I, T, V, R, C, B, M, E]):
    """Base class for Body and Branches objects."""
    __slots__ = []
    # Set using 'BaseBody.register' when these classes are created.
    keyword_class: Type[KW] = KnownAtRuntime
    for_class: Type[F] = KnownAtRuntime
    while_class: Type[W] = KnownAtRuntime
    if_class: Type[I] = KnownAtRuntime
    try_class: Type[T] = KnownAtRuntime
    var_class: Type[V] = KnownAtRuntime
    return_class: Type[R] = KnownAtRuntime
    continue_class: Type[C] = KnownAtRuntime
    break_class: Type[B] = KnownAtRuntime
    message_class: Type[M] = KnownAtRuntime
    error_class: Type[E] = KnownAtRuntime

    def __init__(self, parent: BodyItemParent = None,
                 items: 'Iterable[BodyItem|DataDict]' = ()):
        super().__init__(BodyItem, {'parent': parent}, items)

    def _item_from_dict(self, data: DataDict) -> BodyItem:
        item_type = data.get('type', None)
        if item_type is None:
            item_class = self.keyword_class
        elif item_type == BodyItem.IF_ELSE_ROOT:
            item_class = self.if_class
        elif item_type == BodyItem.TRY_EXCEPT_ROOT:
            item_class = self.try_class
        else:
            item_class = getattr(self, item_type.lower() + '_class')
        item_class = cast(Type[BodyItem], item_class)
        return item_class.from_dict(data)

    @classmethod
    def register(cls, item_class: Type[BI]) -> Type[BI]:
        name_parts = re.findall('([A-Z][a-z]+)', item_class.__name__) + ['class']
        name = '_'.join(name_parts).lower()
        if not hasattr(cls, name):
            raise TypeError(f"Cannot register '{name}'.")
        setattr(cls, name, item_class)
        return item_class

    @property
    def create(self):
        raise AttributeError(
            f"'{full_name(self)}' object has no attribute 'create'. "
            f"Use item specific methods like 'create_keyword' instead."
        )

    def _create(self, cls: 'Type[BI]', name: str, args: 'tuple[Any, ...]',
                kwargs: 'dict[str, Any]') -> BI:
        if cls is KnownAtRuntime:
            raise TypeError(f"'{full_name(self)}' object does not support '{name}'.")
        return self.append(cls(*args, **kwargs))  # type: ignore

    @copy_signature(keyword_class)
    def create_keyword(self, *args, **kwargs) -> keyword_class:
        return self._create(self.keyword_class, 'create_keyword', args, kwargs)

    @copy_signature(for_class)
    def create_for(self, *args, **kwargs) -> for_class:
        return self._create(self.for_class, 'create_for', args, kwargs)

    @copy_signature(if_class)
    def create_if(self, *args, **kwargs) -> if_class:
        return self._create(self.if_class, 'create_if', args, kwargs)

    @copy_signature(try_class)
    def create_try(self, *args, **kwargs) -> try_class:
        return self._create(self.try_class, 'create_try', args, kwargs)

    @copy_signature(while_class)
    def create_while(self, *args, **kwargs) -> while_class:
        return self._create(self.while_class, 'create_while', args, kwargs)

    @copy_signature(var_class)
    def create_var(self, *args, **kwargs) -> var_class:
        return self._create(self.var_class, 'create_var', args, kwargs)

    @copy_signature(return_class)
    def create_return(self, *args, **kwargs) -> return_class:
        return self._create(self.return_class, 'create_return', args, kwargs)

    @copy_signature(continue_class)
    def create_continue(self, *args, **kwargs) -> continue_class:
        return self._create(self.continue_class, 'create_continue', args, kwargs)

    @copy_signature(break_class)
    def create_break(self, *args, **kwargs) -> break_class:
        return self._create(self.break_class, 'create_break', args, kwargs)

    @copy_signature(message_class)
    def create_message(self, *args, **kwargs) -> message_class:
        return self._create(self.message_class, 'create_message', args, kwargs)

    @copy_signature(error_class)
    def create_error(self, *args, **kwargs) -> error_class:
        return self._create(self.error_class, 'create_error', args, kwargs)

    def filter(self, keywords: 'bool|None' = None, messages: 'bool|None' = None,
               predicate: 'Callable[[T], bool]|None' = None):
        """Filter body items based on type and/or custom predicate.

        To include or exclude items based on types, give matching arguments
        ``True`` or ``False`` values. For example, to include only keywords,
        use ``body.filter(keywords=True)`` and to exclude messages use
        ``body.filter(messages=False)``. Including and excluding by types
        at the same time is not supported and filtering my ``messages``
        is supported only if the ``Body`` object actually supports messages.

        Custom ``predicate`` is a callable getting each body item as an argument
        that must return ``True/False`` depending on should the item be included
        or not.

        Selected items are returned as a list and the original body is not modified.

        It was earlier possible to filter also based on FOR and IF types.
        That support was removed in RF 5.0 because it was not considered useful
        in general and because adding support for all new control structures
        would have required extra work. To exclude all control structures, use
        ``body.filter(keywords=True, messages=True)`` and to only include them
        use ``body.filter(keywords=False``, messages=False)``. For more detailed
        filtering it is possible to use ``predicate``.
        """
        if messages is not None and self.message_class is KnownAtRuntime:
            raise TypeError(f"'{full_name(self)}' object does not support "
                            f"filtering by 'messages'.")
        return self._filter([(self.keyword_class, keywords),
                             (self.message_class, messages)], predicate)

    def _filter(self, types, predicate):
        include = tuple(cls for cls, activated in types if activated is True and cls)
        exclude = tuple(cls for cls, activated in types if activated is False and cls)
        if include and exclude:
            raise ValueError('Items cannot be both included and excluded by type.')
        items = list(self)
        if include:
            items = [item for item in items if isinstance(item, include)]
        if exclude:
            items = [item for item in items if not isinstance(item, exclude)]
        if predicate:
            items = [item for item in items if predicate(item)]
        return items

    def flatten(self) -> 'list[BodyItem]':
        """Return steps so that IF and TRY structures are flattened.

        Basically the IF/ELSE and TRY/EXCEPT root elements are replaced
        with their branches. This is how they are shown in log files.
        """
        roots = BodyItem.IF_ELSE_ROOT, BodyItem.TRY_EXCEPT_ROOT
        steps = []
        for item in self:
            if item.type in roots:
                item = cast('Try|If', item)
                steps.extend(item.body)
            else:
                steps.append(item)
        return steps

filter(keywords=None, messages=None, predicate=None)

Filter body items based on type and/or custom predicate.

To include or exclude items based on types, give matching arguments True or False values. For example, to include only keywords, use body.filter(keywords=True) and to exclude messages use body.filter(messages=False). Including and excluding by types at the same time is not supported and filtering my messages is supported only if the Body object actually supports messages.

Custom predicate is a callable getting each body item as an argument that must return True/False depending on should the item be included or not.

Selected items are returned as a list and the original body is not modified.

It was earlier possible to filter also based on FOR and IF types. That support was removed in RF 5.0 because it was not considered useful in general and because adding support for all new control structures would have required extra work. To exclude all control structures, use body.filter(keywords=True, messages=True) and to only include them use body.filter(keywords=False, messages=False). For more detailed filtering it is possible to usepredicate``.

Source code in src/robot/model/body.py

def filter(self, keywords: 'bool|None' = None, messages: 'bool|None' = None,
           predicate: 'Callable[[T], bool]|None' = None):
    """Filter body items based on type and/or custom predicate.

    To include or exclude items based on types, give matching arguments
    ``True`` or ``False`` values. For example, to include only keywords,
    use ``body.filter(keywords=True)`` and to exclude messages use
    ``body.filter(messages=False)``. Including and excluding by types
    at the same time is not supported and filtering my ``messages``
    is supported only if the ``Body`` object actually supports messages.

    Custom ``predicate`` is a callable getting each body item as an argument
    that must return ``True/False`` depending on should the item be included
    or not.

    Selected items are returned as a list and the original body is not modified.

    It was earlier possible to filter also based on FOR and IF types.
    That support was removed in RF 5.0 because it was not considered useful
    in general and because adding support for all new control structures
    would have required extra work. To exclude all control structures, use
    ``body.filter(keywords=True, messages=True)`` and to only include them
    use ``body.filter(keywords=False``, messages=False)``. For more detailed
    filtering it is possible to use ``predicate``.
    """
    if messages is not None and self.message_class is KnownAtRuntime:
        raise TypeError(f"'{full_name(self)}' object does not support "
                        f"filtering by 'messages'.")
    return self._filter([(self.keyword_class, keywords),
                         (self.message_class, messages)], predicate)

flatten()

Return steps so that IF and TRY structures are flattened.

Basically the IF/ELSE and TRY/EXCEPT root elements are replaced with their branches. This is how they are shown in log files.

Source code in src/robot/model/body.py

def flatten(self) -> 'list[BodyItem]':
    """Return steps so that IF and TRY structures are flattened.

    Basically the IF/ELSE and TRY/EXCEPT root elements are replaced
    with their branches. This is how they are shown in log files.
    """
    roots = BodyItem.IF_ELSE_ROOT, BodyItem.TRY_EXCEPT_ROOT
    steps = []
    for item in self:
        if item.type in roots:
            item = cast('Try|If', item)
            steps.extend(item.body)
        else:
            steps.append(item)
    return steps

to_dicts()

Return list of items converted to dictionaries.

Items are converted to dictionaries using the to_dict method, if they have it, or the built-in vars().

New in Robot Framework 6.1.

Source code in src/robot/model/itemlist.py

def to_dicts(self) -> 'list[DataDict]':
    """Return list of items converted to dictionaries.

    Items are converted to dictionaries using the ``to_dict`` method, if
    they have it, or the built-in ``vars()``.

    New in Robot Framework 6.1.
    """
    if not hasattr(self._item_class, 'to_dict'):
        return [vars(item) for item in self]
    return [item.to_dict() for item in self]    # type: ignore

BaseBranches

Bases: BaseBody[KW, F, W, I, T, V, R, C, B, M, E], BranchType[IT]

A list-like object representing IF and TRY branches.

Source code in src/robot/model/body.py

class BaseBranches(BaseBody[KW, F, W, I, T, V, R, C, B, M, E], BranchType[IT]):
    """A list-like object representing IF and TRY branches."""
    __slots__ = ['branch_class']
    branch_type: Type[IT] = KnownAtRuntime

    def __init__(self, branch_class: Type[IT],
                 parent: BodyItemParent = None,
                 items: 'Iterable[IT|DataDict]' = ()):
        self.branch_class = branch_class
        super().__init__(parent, items)

    def _item_from_dict(self, data: DataDict) -> IT:
        return self.branch_class.from_dict(data)

    @copy_signature(branch_type)
    def create_branch(self, *args, **kwargs) -> IT:
        return self._create(self.branch_class, 'create_branch', args, kwargs)

filter(keywords=None, messages=None, predicate=None)

Filter body items based on type and/or custom predicate.

To include or exclude items based on types, give matching arguments True or False values. For example, to include only keywords, use body.filter(keywords=True) and to exclude messages use body.filter(messages=False). Including and excluding by types at the same time is not supported and filtering my messages is supported only if the Body object actually supports messages.

Custom predicate is a callable getting each body item as an argument that must return True/False depending on should the item be included or not.

Selected items are returned as a list and the original body is not modified.

It was earlier possible to filter also based on FOR and IF types. That support was removed in RF 5.0 because it was not considered useful in general and because adding support for all new control structures would have required extra work. To exclude all control structures, use body.filter(keywords=True, messages=True) and to only include them use body.filter(keywords=False, messages=False). For more detailed filtering it is possible to usepredicate``.

Source code in src/robot/model/body.py

def filter(self, keywords: 'bool|None' = None, messages: 'bool|None' = None,
           predicate: 'Callable[[T], bool]|None' = None):
    """Filter body items based on type and/or custom predicate.

    To include or exclude items based on types, give matching arguments
    ``True`` or ``False`` values. For example, to include only keywords,
    use ``body.filter(keywords=True)`` and to exclude messages use
    ``body.filter(messages=False)``. Including and excluding by types
    at the same time is not supported and filtering my ``messages``
    is supported only if the ``Body`` object actually supports messages.

    Custom ``predicate`` is a callable getting each body item as an argument
    that must return ``True/False`` depending on should the item be included
    or not.

    Selected items are returned as a list and the original body is not modified.

    It was earlier possible to filter also based on FOR and IF types.
    That support was removed in RF 5.0 because it was not considered useful
    in general and because adding support for all new control structures
    would have required extra work. To exclude all control structures, use
    ``body.filter(keywords=True, messages=True)`` and to only include them
    use ``body.filter(keywords=False``, messages=False)``. For more detailed
    filtering it is possible to use ``predicate``.
    """
    if messages is not None and self.message_class is KnownAtRuntime:
        raise TypeError(f"'{full_name(self)}' object does not support "
                        f"filtering by 'messages'.")
    return self._filter([(self.keyword_class, keywords),
                         (self.message_class, messages)], predicate)

flatten()

Return steps so that IF and TRY structures are flattened.

Basically the IF/ELSE and TRY/EXCEPT root elements are replaced with their branches. This is how they are shown in log files.

Source code in src/robot/model/body.py

def flatten(self) -> 'list[BodyItem]':
    """Return steps so that IF and TRY structures are flattened.

    Basically the IF/ELSE and TRY/EXCEPT root elements are replaced
    with their branches. This is how they are shown in log files.
    """
    roots = BodyItem.IF_ELSE_ROOT, BodyItem.TRY_EXCEPT_ROOT
    steps = []
    for item in self:
        if item.type in roots:
            item = cast('Try|If', item)
            steps.extend(item.body)
        else:
            steps.append(item)
    return steps

to_dicts()

Return list of items converted to dictionaries.

Items are converted to dictionaries using the to_dict method, if they have it, or the built-in vars().

New in Robot Framework 6.1.

Source code in src/robot/model/itemlist.py

def to_dicts(self) -> 'list[DataDict]':
    """Return list of items converted to dictionaries.

    Items are converted to dictionaries using the ``to_dict`` method, if
    they have it, or the built-in ``vars()``.

    New in Robot Framework 6.1.
    """
    if not hasattr(self._item_class, 'to_dict'):
        return [vars(item) for item in self]
    return [item.to_dict() for item in self]    # type: ignore

Body

Bases: BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return', 'Continue', 'Break', 'Message', 'Error']

A list-like object representing a body of a test, keyword, etc.

Body contains the keywords and other structures such as FOR loops.

Source code in src/robot/model/body.py

class Body(BaseBody['Keyword', 'For', 'While', 'If', 'Try', 'Var', 'Return',
                    'Continue', 'Break', 'Message', 'Error']):
    """A list-like object representing a body of a test, keyword, etc.

    Body contains the keywords and other structures such as FOR loops.
    """
    pass

filter(keywords=None, messages=None, predicate=None)

Filter body items based on type and/or custom predicate.

To include or exclude items based on types, give matching arguments True or False values. For example, to include only keywords, use body.filter(keywords=True) and to exclude messages use body.filter(messages=False). Including and excluding by types at the same time is not supported and filtering my messages is supported only if the Body object actually supports messages.

Custom predicate is a callable getting each body item as an argument that must return True/False depending on should the item be included or not.

Selected items are returned as a list and the original body is not modified.

It was earlier possible to filter also based on FOR and IF types. That support was removed in RF 5.0 because it was not considered useful in general and because adding support for all new control structures would have required extra work. To exclude all control structures, use body.filter(keywords=True, messages=True) and to only include them use body.filter(keywords=False, messages=False). For more detailed filtering it is possible to usepredicate``.

Source code in src/robot/model/body.py

def filter(self, keywords: 'bool|None' = None, messages: 'bool|None' = None,
           predicate: 'Callable[[T], bool]|None' = None):
    """Filter body items based on type and/or custom predicate.

    To include or exclude items based on types, give matching arguments
    ``True`` or ``False`` values. For example, to include only keywords,
    use ``body.filter(keywords=True)`` and to exclude messages use
    ``body.filter(messages=False)``. Including and excluding by types
    at the same time is not supported and filtering my ``messages``
    is supported only if the ``Body`` object actually supports messages.

    Custom ``predicate`` is a callable getting each body item as an argument
    that must return ``True/False`` depending on should the item be included
    or not.

    Selected items are returned as a list and the original body is not modified.

    It was earlier possible to filter also based on FOR and IF types.
    That support was removed in RF 5.0 because it was not considered useful
    in general and because adding support for all new control structures
    would have required extra work. To exclude all control structures, use
    ``body.filter(keywords=True, messages=True)`` and to only include them
    use ``body.filter(keywords=False``, messages=False)``. For more detailed
    filtering it is possible to use ``predicate``.
    """
    if messages is not None and self.message_class is KnownAtRuntime:
        raise TypeError(f"'{full_name(self)}' object does not support "
                        f"filtering by 'messages'.")
    return self._filter([(self.keyword_class, keywords),
                         (self.message_class, messages)], predicate)

flatten()

Return steps so that IF and TRY structures are flattened.

Basically the IF/ELSE and TRY/EXCEPT root elements are replaced with their branches. This is how they are shown in log files.

Source code in src/robot/model/body.py

def flatten(self) -> 'list[BodyItem]':
    """Return steps so that IF and TRY structures are flattened.

    Basically the IF/ELSE and TRY/EXCEPT root elements are replaced
    with their branches. This is how they are shown in log files.
    """
    roots = BodyItem.IF_ELSE_ROOT, BodyItem.TRY_EXCEPT_ROOT
    steps = []
    for item in self:
        if item.type in roots:
            item = cast('Try|If', item)
            steps.extend(item.body)
        else:
            steps.append(item)
    return steps

to_dicts()

Return list of items converted to dictionaries.

Items are converted to dictionaries using the to_dict method, if they have it, or the built-in vars().

New in Robot Framework 6.1.

Source code in src/robot/model/itemlist.py

def to_dicts(self) -> 'list[DataDict]':
    """Return list of items converted to dictionaries.

    Items are converted to dictionaries using the ``to_dict`` method, if
    they have it, or the built-in ``vars()``.

    New in Robot Framework 6.1.
    """
    if not hasattr(self._item_class, 'to_dict'):
        return [vars(item) for item in self]
    return [item.to_dict() for item in self]    # type: ignore

BodyItem

Bases: ModelObject

Source code in src/robot/model/body.py

class BodyItem(ModelObject):
    KEYWORD = 'KEYWORD'
    SETUP = 'SETUP'
    TEARDOWN = 'TEARDOWN'
    FOR = 'FOR'
    ITERATION = 'ITERATION'
    IF_ELSE_ROOT = 'IF/ELSE ROOT'
    IF = 'IF'
    ELSE_IF = 'ELSE IF'
    ELSE = 'ELSE'
    TRY_EXCEPT_ROOT = 'TRY/EXCEPT ROOT'
    TRY = 'TRY'
    EXCEPT = 'EXCEPT'
    FINALLY = 'FINALLY'
    WHILE = 'WHILE'
    VAR = 'VAR'
    RETURN = 'RETURN'
    CONTINUE = 'CONTINUE'
    BREAK = 'BREAK'
    ERROR = 'ERROR'
    MESSAGE = 'MESSAGE'
    KEYWORD_TYPES = (KEYWORD, SETUP, TEARDOWN)
    type = None
    __slots__ = ['parent']

    @property
    def id(self) -> 'str|None':
        """Item id in format like ``s1-t3-k1``.

        See :attr:`TestSuite.id <robot.model.testsuite.TestSuite.id>` for
        more information.

        ``id`` is ``None`` only in these special cases:

        - Keyword uses a placeholder for ``setup`` or ``teardown`` when
          a ``setup`` or ``teardown`` is not actually used.
        - With :class:`~robot.model.control.If` and :class:`~robot.model.control.Try`
          instances representing IF/TRY structure roots.
        """
        return self._get_id(self.parent)

    def _get_id(self, parent: 'BodyItemParent|ResourceFile') -> str:
        if not parent:
            return 'k1'
        # This algorithm must match the id creation algorithm in the JavaScript side
        # or linking to warnings and errors won't work.
        steps = []
        if getattr(parent, 'has_setup', False):
            steps.append(parent.setup)          # type: ignore - Use Protocol with RF 7.
        if hasattr(parent, 'body'):
            steps.extend(step for step in
                         parent.body.flatten()  # type: ignore - Use Protocol with RF 7.
                         if step.type != self.MESSAGE)
        if getattr(parent, 'has_teardown', False):
            steps.append(parent.teardown)       # type: ignore - Use Protocol with RF 7.
        index = steps.index(self) if self in steps else len(steps)
        parent_id = getattr(parent, 'id', None)
        return f'{parent_id}-k{index + 1}' if parent_id else f'k{index + 1}'

    def to_dict(self) -> DataDict:
        raise NotImplementedError

id: str | None property

Item id in format like s1-t3-k1.

See :attr:TestSuite.id <robot.model.testsuite.TestSuite.id> for more information.

id is None only in these special cases:

• Keyword uses a placeholder for setup or teardown when a setup or teardown is not actually used.
• With :class:~robot.model.control.If and :class:~robot.model.control.Try instances representing IF/TRY structure roots.

config(**attributes)

Configure model object with given attributes.

obj.config(name='Example', doc='Something') is equivalent to setting obj.name = 'Example' and obj.doc = 'Something'.

New in Robot Framework 4.0.

Source code in src/robot/model/modelobject.py

def config(self: T, **attributes) -> T:
    """Configure model object with given attributes.

    ``obj.config(name='Example', doc='Something')`` is equivalent to setting
    ``obj.name = 'Example'`` and ``obj.doc = 'Something'``.

    New in Robot Framework 4.0.
    """
    for name, value in attributes.items():
        try:
            orig = getattr(self, name)
        except AttributeError:
            raise AttributeError(f"'{full_name(self)}' object does not have "
                                 f"attribute '{name}'")
        # Preserve tuples. Main motivation is converting lists with `from_json`.
        if isinstance(orig, tuple) and not isinstance(value, tuple):
            try:
                value = tuple(value)
            except TypeError:
                raise TypeError(f"'{full_name(self)}' object attribute '{name}' "
                                f"is 'tuple', got '{type_name(value)}'.")
        try:
            setattr(self, name, value)
        except AttributeError as err:
            # Ignore error setting attribute if the object already has it.
            # Avoids problems with `from_dict` with body items having
            # un-settable `type` attribute that is needed in dict data.
            if value != orig:
                raise AttributeError(f"Setting attribute '{name}' failed: {err}")
    return self

copy(**attributes)

Return a shallow copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.copy(name='New name').

See also :meth:deepcopy. The difference between copy and deepcopy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py

def copy(self: T, **attributes) -> T:
    """Return a shallow copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.copy(name='New name')``.

    See also :meth:`deepcopy`. The difference between ``copy`` and
    ``deepcopy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.copy(self).config(**attributes)

deepcopy(**attributes)

Return a deep copy of this object.

:param attributes: Attributes to be set to the returned copy. For example, obj.deepcopy(name='New name').

See also :meth:copy. The difference between deepcopy and copy is the same as with the methods having same names in the copy__ module.

__ https://docs.python.org/3/library/copy.html

Source code in src/robot/model/modelobject.py

def deepcopy(self: T, **attributes) -> T:
    """Return a deep copy of this object.

    :param attributes: Attributes to be set to the returned copy.
        For example, ``obj.deepcopy(name='New name')``.

    See also :meth:`copy`. The difference between ``deepcopy`` and
    ``copy`` is the same as with the methods having same names in
    the copy__ module.

    __ https://docs.python.org/3/library/copy.html
    """
    return copy.deepcopy(self).config(**attributes)

from_dict(data) classmethod

Create this object based on data in a dictionary.

Data can be got from the :meth:to_dict method or created externally.

With robot.running model objects new in Robot Framework 6.1, with robot.result new in Robot Framework 7.0.

Source code in src/robot/model/modelobject.py

@classmethod
def from_dict(cls: Type[T], data: DataDict) -> T:
    """Create this object based on data in a dictionary.

    Data can be got from the :meth:`to_dict` method or created externally.

    With ``robot.running`` model objects new in Robot Framework 6.1,
    with ``robot.result`` new in Robot Framework 7.0.
    """
    try:
        return cls().config(**data)
    except (AttributeError, TypeError) as err:
        raise DataError(f"Creating '{full_name(cls)}' object from dictionary "
                        f"failed: {err}")

from_json(source) classmethod

Create this object based on JSON data.

The data is given as the source parameter. It can be:

• a string (or bytes) containing the data directly,
• an open file object where to read the data from, or
• a path (pathlib.Path or string) to a UTF-8 encoded file to read.

The JSON data is first converted to a Python dictionary and the object created using the :meth:from_dict method.

Notice that the source is considered to be JSON data if it is a string and contains {. If you need to use { in a file system path, pass it in as a pathlib.Path instance.

With robot.running model objects new in Robot Framework 6.1, with robot.result new in Robot Framework 7.0.

Source code in src/robot/model/modelobject.py

@classmethod
def from_json(cls: Type[T], source: 'str|bytes|TextIO|Path') -> T:
    """Create this object based on JSON data.

    The data is given as the ``source`` parameter. It can be:

    - a string (or bytes) containing the data directly,
    - an open file object where to read the data from, or
    - a path (``pathlib.Path`` or string) to a UTF-8 encoded file to read.

    The JSON data is first converted to a Python dictionary and the object
    created using the :meth:`from_dict` method.

    Notice that the ``source`` is considered to be JSON data if it is
    a string and contains ``{``. If you need to use ``{`` in a file system
    path, pass it in as a ``pathlib.Path`` instance.

    With ``robot.running`` model objects new in Robot Framework 6.1,
    with ``robot.result`` new in Robot Framework 7.0.
    """
    try:
        data = JsonLoader().load(source)
    except (TypeError, ValueError) as err:
        raise DataError(f'Loading JSON data failed: {err}')
    return cls.from_dict(data)

to_json(file=None, *, ensure_ascii=False, indent=0, separators=(',', ':'))

Serialize this object into JSON.

The object is first converted to a Python dictionary using the :meth:to_dict method and then the dictionary is converted to JSON.

The file parameter controls what to do with the resulting JSON data. It can be:

• None (default) to return the data as a string,
• an open file object where to write the data to, or
• a path (pathlib.Path or string) to a file where to write the data using UTF-8 encoding.

JSON formatting can be configured using optional parameters that are passed directly to the underlying json__ module. Notice that the defaults differ from what json uses.

With robot.running model objects new in Robot Framework 6.1, with robot.result new in Robot Framework 7.0.

__ https://docs.python.org/3/library/json.html

Source code in src/robot/model/modelobject.py

def to_json(self, file: 'None|TextIO|Path|str' = None, *,
            ensure_ascii: bool = False, indent: int = 0,
            separators: 'tuple[str, str]' = (',', ':')) -> 'str|None':
    """Serialize this object into JSON.

    The object is first converted to a Python dictionary using the
    :meth:`to_dict` method and then the dictionary is converted to JSON.

    The ``file`` parameter controls what to do with the resulting JSON data.
    It can be:

    - ``None`` (default) to return the data as a string,
    - an open file object where to write the data to, or
    - a path (``pathlib.Path`` or string) to a file where to write
      the data using UTF-8 encoding.

    JSON formatting can be configured using optional parameters that
    are passed directly to the underlying json__ module. Notice that
    the defaults differ from what ``json`` uses.

    With ``robot.running`` model objects new in Robot Framework 6.1,
    with ``robot.result`` new in Robot Framework 7.0.

    __ https://docs.python.org/3/library/json.html
    """
    return JsonDumper(ensure_ascii=ensure_ascii, indent=indent,
                      separators=separators).dump(self.to_dict(), file)