Skip to content

librarykeyword

DynamicKeyword

Bases: LibraryKeyword

Represents a keyword in a dynamic library.

Source code in src/robot/running/librarykeyword.py 
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
class DynamicKeyword(LibraryKeyword):
    """Represents a keyword in a dynamic library."""
    owner: 'DynamicLibrary'
    __slots__ = ['run_keyword', '_orig_name', '__source_info']

    def __init__(self, owner: 'DynamicLibrary',
                 name: str = '',
                 args: 'ArgumentSpec|None' = None,
                 doc: str = '',
                 tags: 'Tags|Sequence[str]' = (),
                 resolve_args_until: 'int|None' = None,
                 parent: 'BodyItemParent|None' = None,
                 error: 'str|None' = None):
        # TODO: It would probably be better not to convert name we got from
        # `get_keyword_names`. That would have some backwards incompatibility
        # effects, but we can consider it in RF 8.0.
        super().__init__(owner, printable_name(name, code_style=True), args, doc,
                         tags, resolve_args_until, parent, error)
        self._orig_name = name
        self.__source_info = None

    @property
    def method(self) -> Callable[..., Any]:
        """Dynamic ``run_keyword`` method."""
        return RunKeyword(self.owner.instance, self._orig_name,
                          self.owner.supports_named_args)

    @property
    def source(self) -> 'Path|None':
        return self._source_info[0] or super().source

    @property
    def lineno(self) -> 'int|None':
        return self._source_info[1]

    @property
    def _source_info(self) -> 'tuple[Path|None, int]':
        if not self.__source_info:
            get_keyword_source = GetKeywordSource(self.owner.instance)
            try:
                source = get_keyword_source(self._orig_name)
            except DataError as err:
                source = None
                self.owner.report_error(f"Getting source information for keyword "
                                        f"'{self.name}' failed: {err}", err.details)
            if source and ':' in source and source.rsplit(':', 1)[1].isdigit():
                source, lineno = source.rsplit(':', 1)
                lineno = int(lineno)
            else:
                lineno = None
            self.__source_info = Path(normpath(source)) if source else None, lineno
        return self.__source_info

    @classmethod
    def from_name(cls, name: str, owner: 'DynamicLibrary') -> 'DynamicKeyword':
        return DynamicKeywordCreator(name, owner).create()

    def resolve_arguments(self, args: 'Sequence[str|Any]',
                          named_args: 'Mapping[str, Any]|None' = None,
                          variables=None,
                          languages: 'LanguagesLike' = None) -> 'tuple[list, list]':
        positional, named = super().resolve_arguments(args, named_args, variables,
                                                      languages)
        if not self.owner.supports_named_args:
            positional, named = self.args.map(positional, named)
        return positional, named

    def copy(self, **attributes) -> 'DynamicKeyword':
        return DynamicKeyword(self.owner, self._orig_name, self.args, self._doc,
                              self.tags, self._resolve_args_until, self.parent,
                              self.error).config(**attributes)

method: Callable[..., Any] property

Dynamic run_keyword method.

params: ArgumentSpec property

Keyword parameter information.

This is a forward compatible alias for :attr:args.

args(spec)

Information about accepted arguments.

It would be more correct to use term parameter instead of argument in this context, and this attribute may be renamed accordingly in the future. A forward compatible :attr:params attribute exists already now.

Source code in src/robot/running/keywordimplementation.py 
81
82
83
84
85
86
87
88
89
90
91
92
93
@setter
def args(self, spec: 'ArgumentSpec|None') -> ArgumentSpec:
    """Information about accepted arguments.

    It would be more correct to use term *parameter* instead of
    *argument* in this context, and this attribute may be renamed
    accordingly in the future. A forward compatible :attr:`params`
    attribute exists already now.
    """
    if spec is None:
        spec = ArgumentSpec()
    spec.name = lambda: self.full_name
    return spec

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 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
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

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 
167
168
169
170
171
172
173
174
175
176
177
178
179
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 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@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 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@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)

matches(name)

Returns true if name matches the keyword name.

With normal keywords matching is a case, space and underscore insensitive string comparison. With keywords accepting embedded arguments, matching is done against the name.

Source code in src/robot/running/keywordimplementation.py 
135
136
137
138
139
140
141
142
143
144
def matches(self, name: str) -> bool:
    """Returns true if ``name`` matches the keyword name.

    With normal keywords matching is a case, space and underscore insensitive
    string comparison. With keywords accepting embedded arguments, matching
    is done against the name.
    """
    if self.embedded:
        return self.embedded.match(name) is not None
    return eq(self.name, name, ignore='_')

to_dict()

Serialize this object into a dictionary.

The object can be later restored by using the :meth:from_dict method.

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 
74
75
76
77
78
79
80
81
82
def to_dict(self) -> DataDict:
    """Serialize this object into a dictionary.

    The object can be later restored by using the :meth:`from_dict` method.

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

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 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
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)

LibraryInit

Bases: LibraryKeyword

Represents a library initializer.

:attr:positional and :attr:named contain arguments used for initializing the library.

Source code in src/robot/running/librarykeyword.py 
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
class LibraryInit(LibraryKeyword):
    """Represents a library initializer.

    :attr:`positional` and :attr:`named` contain arguments used for initializing
    the library.
    """

    def __init__(self, owner: 'TestLibrary',
                 name: str = '',
                 args: 'ArgumentSpec|None' = None,
                 doc: str = '',
                 tags: 'Tags|Sequence[str]' = (),
                 positional: 'list|None' = None,
                 named: 'dict|None' = None):
        super().__init__(owner, name, args, doc, tags)
        self.positional = positional or []
        self.named = named or {}

    @property
    def doc(self) -> str:
        from .testlibraries import DynamicLibrary
        if isinstance(self.owner, DynamicLibrary):
            doc = GetKeywordDocumentation(self.owner.instance)('__init__')
            if doc:
                return doc
        return self._doc

    @doc.setter
    def doc(self, doc: str):
        self._doc = doc

    @property
    def method(self) -> 'Callable[..., None]|None':
        """Initializer method.

        ``None`` with module based libraries and when class based libraries
        do not have ``__init__``.
        """
        return getattr(self.owner.instance, '__init__', None)

    @classmethod
    def from_class(cls, klass) -> 'LibraryInit':
        method = getattr(klass, '__init__', None)
        return LibraryInitCreator(method).create()

    @classmethod
    def null(cls) -> 'LibraryInit':
        return LibraryInitCreator(None).create()

    def copy(self, **attributes) -> 'LibraryInit':
        return LibraryInit(self.owner, self.name, self.args, self._doc, self.tags,
                           self.positional, self.named).config(**attributes)

method: Callable[..., None] | None property

Initializer method.

None with module based libraries and when class based libraries do not have __init__.

params: ArgumentSpec property

Keyword parameter information.

This is a forward compatible alias for :attr:args.

args(spec)

Information about accepted arguments.

It would be more correct to use term parameter instead of argument in this context, and this attribute may be renamed accordingly in the future. A forward compatible :attr:params attribute exists already now.

Source code in src/robot/running/keywordimplementation.py 
81
82
83
84
85
86
87
88
89
90
91
92
93
@setter
def args(self, spec: 'ArgumentSpec|None') -> ArgumentSpec:
    """Information about accepted arguments.

    It would be more correct to use term *parameter* instead of
    *argument* in this context, and this attribute may be renamed
    accordingly in the future. A forward compatible :attr:`params`
    attribute exists already now.
    """
    if spec is None:
        spec = ArgumentSpec()
    spec.name = lambda: self.full_name
    return spec

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 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
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

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 
167
168
169
170
171
172
173
174
175
176
177
178
179
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 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@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 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@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)

matches(name)

Returns true if name matches the keyword name.

With normal keywords matching is a case, space and underscore insensitive string comparison. With keywords accepting embedded arguments, matching is done against the name.

Source code in src/robot/running/keywordimplementation.py 
135
136
137
138
139
140
141
142
143
144
def matches(self, name: str) -> bool:
    """Returns true if ``name`` matches the keyword name.

    With normal keywords matching is a case, space and underscore insensitive
    string comparison. With keywords accepting embedded arguments, matching
    is done against the name.
    """
    if self.embedded:
        return self.embedded.match(name) is not None
    return eq(self.name, name, ignore='_')

to_dict()

Serialize this object into a dictionary.

The object can be later restored by using the :meth:from_dict method.

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 
74
75
76
77
78
79
80
81
82
def to_dict(self) -> DataDict:
    """Serialize this object into a dictionary.

    The object can be later restored by using the :meth:`from_dict` method.

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

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 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
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)

LibraryKeyword

Bases: KeywordImplementation

Base class for different library keywords.

Source code in src/robot/running/librarykeyword.py 
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
class LibraryKeyword(KeywordImplementation):
    """Base class for different library keywords."""
    type = KeywordImplementation.LIBRARY_KEYWORD
    owner: 'TestLibrary'
    __slots__ = ['_resolve_args_until']

    def __init__(self, owner: 'TestLibrary',
                 name: str = '',
                 args: 'ArgumentSpec|None' = None,
                 doc: str = '',
                 tags: 'Tags|Sequence[str]' = (),
                 resolve_args_until: 'int|None' = None,
                 parent: 'BodyItemParent|None' = None,
                 error: 'str|None' = None):
        super().__init__(name, args, doc, tags, owner=owner, parent=parent, error=error)
        self._resolve_args_until = resolve_args_until

    @property
    def method(self) -> Callable[..., Any]:
        raise NotImplementedError

    @property
    def lineno(self) -> 'int|None':
        method = self.method
        try:
            lines, start_lineno = inspect.getsourcelines(inspect.unwrap(method))
        except (TypeError, OSError, IOError):
            return None
        for increment, line in enumerate(lines):
            if line.strip().startswith('def '):
                return start_lineno + increment
        return start_lineno

    def create_runner(self, name: 'str|None',
                      languages: 'LanguagesLike' = None) -> LibraryKeywordRunner:
        if self.embedded:
            return EmbeddedArgumentsRunner(self, name)
        if self._resolve_args_until is not None:
            dry_run = RUN_KW_REGISTER.get_dry_run(self.owner.real_name, self.name)
            return RunKeywordRunner(self, execute_in_dry_run=dry_run)
        return LibraryKeywordRunner(self, languages=languages)

    def resolve_arguments(self, args: 'Sequence[str|Any]',
                          named_args: 'Mapping[str, Any]|None' = None,
                          variables=None,
                          languages: 'LanguagesLike' = None) -> 'tuple[list, list]':
        resolve_args_until = self._resolve_args_until
        positional, named = self.args.resolve(args, named_args, variables,
                                              self.owner.converters,
                                              resolve_named=resolve_args_until is None,
                                              resolve_args_until=resolve_args_until,
                                              languages=languages)
        if self.embedded:
            self.embedded.validate(positional)
        return positional, named

    def bind(self: Self, data: Keyword) -> Self:
        return self.copy(parent=data.parent)

    def copy(self: Self, **attributes) -> Self:
        raise NotImplementedError

params: ArgumentSpec property

Keyword parameter information.

This is a forward compatible alias for :attr:args.

args(spec)

Information about accepted arguments.

It would be more correct to use term parameter instead of argument in this context, and this attribute may be renamed accordingly in the future. A forward compatible :attr:params attribute exists already now.

Source code in src/robot/running/keywordimplementation.py 
81
82
83
84
85
86
87
88
89
90
91
92
93
@setter
def args(self, spec: 'ArgumentSpec|None') -> ArgumentSpec:
    """Information about accepted arguments.

    It would be more correct to use term *parameter* instead of
    *argument* in this context, and this attribute may be renamed
    accordingly in the future. A forward compatible :attr:`params`
    attribute exists already now.
    """
    if spec is None:
        spec = ArgumentSpec()
    spec.name = lambda: self.full_name
    return spec

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 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
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

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 
167
168
169
170
171
172
173
174
175
176
177
178
179
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 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@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 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@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)

matches(name)

Returns true if name matches the keyword name.

With normal keywords matching is a case, space and underscore insensitive string comparison. With keywords accepting embedded arguments, matching is done against the name.

Source code in src/robot/running/keywordimplementation.py 
135
136
137
138
139
140
141
142
143
144
def matches(self, name: str) -> bool:
    """Returns true if ``name`` matches the keyword name.

    With normal keywords matching is a case, space and underscore insensitive
    string comparison. With keywords accepting embedded arguments, matching
    is done against the name.
    """
    if self.embedded:
        return self.embedded.match(name) is not None
    return eq(self.name, name, ignore='_')

to_dict()

Serialize this object into a dictionary.

The object can be later restored by using the :meth:from_dict method.

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 
74
75
76
77
78
79
80
81
82
def to_dict(self) -> DataDict:
    """Serialize this object into a dictionary.

    The object can be later restored by using the :meth:`from_dict` method.

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

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 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
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)

StaticKeyword

Bases: LibraryKeyword

Represents a keyword in a static library.

Source code in src/robot/running/librarykeyword.py 
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
class StaticKeyword(LibraryKeyword):
    """Represents a keyword in a static library."""
    __slots__ = ['method_name']

    def __init__(self, method_name: str,
                 owner: 'TestLibrary',
                 name: str = '',
                 args: 'ArgumentSpec|None' = None,
                 doc: str = '',
                 tags: 'Tags|Sequence[str]' = (),
                 resolve_args_until: 'int|None' = None,
                 parent: 'BodyItemParent|None' = None,
                 error: 'str|None' = None):
        super().__init__(owner, name, args, doc, tags, resolve_args_until, parent, error)
        self.method_name = method_name

    @property
    def method(self) -> Callable[..., Any]:
        """Keyword method."""
        return getattr(self.owner.instance, self.method_name)

    @property
    def source(self) -> 'Path|None':
        # `getsourcefile` can return None and raise TypeError.
        try:
            if self.method is None:
                raise TypeError
            source = inspect.getsourcefile(inspect.unwrap(self.method))
        except TypeError:
            source = None
        return Path(normpath(source)) if source else super().source

    @classmethod
    def from_name(cls, name: str, owner: 'TestLibrary') -> 'StaticKeyword':
        return StaticKeywordCreator(name, owner).create(method_name=name)

    def copy(self, **attributes) -> 'StaticKeyword':
        return StaticKeyword(self.method_name, self.owner, self.name, self.args,
                             self._doc, self.tags, self._resolve_args_until,
                             self.parent, self.error).config(**attributes)

method: Callable[..., Any] property

Keyword method.

params: ArgumentSpec property

Keyword parameter information.

This is a forward compatible alias for :attr:args.

args(spec)

Information about accepted arguments.

It would be more correct to use term parameter instead of argument in this context, and this attribute may be renamed accordingly in the future. A forward compatible :attr:params attribute exists already now.

Source code in src/robot/running/keywordimplementation.py 
81
82
83
84
85
86
87
88
89
90
91
92
93
@setter
def args(self, spec: 'ArgumentSpec|None') -> ArgumentSpec:
    """Information about accepted arguments.

    It would be more correct to use term *parameter* instead of
    *argument* in this context, and this attribute may be renamed
    accordingly in the future. A forward compatible :attr:`params`
    attribute exists already now.
    """
    if spec is None:
        spec = ArgumentSpec()
    spec.name = lambda: self.full_name
    return spec

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 
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
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

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 
167
168
169
170
171
172
173
174
175
176
177
178
179
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 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@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 
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@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)

matches(name)

Returns true if name matches the keyword name.

With normal keywords matching is a case, space and underscore insensitive string comparison. With keywords accepting embedded arguments, matching is done against the name.

Source code in src/robot/running/keywordimplementation.py 
135
136
137
138
139
140
141
142
143
144
def matches(self, name: str) -> bool:
    """Returns true if ``name`` matches the keyword name.

    With normal keywords matching is a case, space and underscore insensitive
    string comparison. With keywords accepting embedded arguments, matching
    is done against the name.
    """
    if self.embedded:
        return self.embedded.match(name) is not None
    return eq(self.name, name, ignore='_')

to_dict()

Serialize this object into a dictionary.

The object can be later restored by using the :meth:from_dict method.

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 
74
75
76
77
78
79
80
81
82
def to_dict(self) -> DataDict:
    """Serialize this object into a dictionary.

    The object can be later restored by using the :meth:`from_dict` method.

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

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 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
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)