Robot Framework API documentation¶

This documentation describes the public API of Robot Framework. Installation, basic usage and wealth of other topics are covered by the Robot Framework User Guide.

Main API entry points are documented here, but the lower level implementation details are not always that well documented. If the documentation is insufficient, it is possible to view the source code by clicking [source] link in the documentation. In case viewing the source is not helpful either, questions may be sent to the robotframework-users mailing list.

Entry points¶

Command line entry points are implemented as Python modules and they also provide programmatic APIs. Following entry points exist:

robot.run entry point for executing tests.

robot.rebot entry point for post-processing outputs (Rebot).

robot.libdoc entry point for Libdoc tool.

robot.testdoc entry point for Testdoc tool.

robot.tidy entry point for Tidy tool.

See built-in tool documentation for more details about Rebot, Libdoc, Testdoc, and Tidy tools.

Java entry points¶

The Robot Framework Jar distribution contains also a Java API, in the form of the org.robotframework.RobotFramework class.

Public API¶

robot.api package exposes the public APIs of Robot Framework.

Unless stated otherwise, the APIs exposed in this package are considered stable, and thus safe to use when building external tools on top of Robot Framework. Notice that all parsing APIs were rewritten in Robot Framework 3.2.

Currently exposed APIs are:

logger module for libraries’ logging purposes.
deco module with decorators libraries can utilize.
exceptions module containing exceptions that libraries can utilize for reporting failures and other events. These exceptions can be imported also directly via robot.api like from robot.api import SkipExecution.
parsing module exposing the parsing APIs. This module is new in Robot Framework 4.0. Various parsing related functions and classes were exposed directly via robot.api already in Robot Framework 3.2, but they are effectively deprecated and will be removed in the future.
TestSuite class for creating executable test suites programmatically and TestSuiteBuilder class for creating such suites based on existing test data on the file system.
SuiteVisitor abstract class for processing testdata before execution. This can be used as a base for implementing a pre-run modifier that is taken into use with --prerunmodifier commandline option.
ExecutionResult() factory method for reading execution results from XML output files and ResultVisitor abstract class to ease further processing the results. ResultVisitor can also be used as a base for pre-Rebot modifier that is taken into use with --prerebotmodifier commandline option.
ResultWriter class for writing reports, logs, XML outputs, and XUnit files. Can write results based on XML outputs on the file system, as well as based on the result objects returned by the ExecutionResult() or an executed TestSuite.

All of the above names can be imported like:

from robot.api import ApiName

See documentations of the individual APIs for more details.

Tip

APIs related to the command line entry points are exposed directly via the robot root package.

All packages¶

All robot packages are listed below. Typically you should not need to import anything from them directly, but the above public APIs may return objects implemented in them.

robot package¶

The root of the Robot Framework package.

The command line entry points provided by the framework are exposed for programmatic usage as follows:

run(): Function to run tests.

run_cli(): Function to run tests with command line argument processing.

rebot(): Function to post-process outputs.

rebot_cli(): Function to post-process outputs with command line argument processing.

libdoc: Module for library documentation generation.

testdoc: Module for test case documentation generation.

tidy: Module for test data clean-up and format change.

All the functions above can be imported like from robot import run. Functions and classes provided by the modules need to be imported like from robot.libdoc import libdoc_cli.

The functions and modules listed above are considered stable. Other modules in this package are for for internal usage and may change without prior notice.

Tip

More public APIs are exposed by the robot.api package.

robot.run(*tests, **options)[source]¶

Programmatic entry point for running tests.

Parameters:	tests – Paths to test case files/directories to be executed similarly as when running the `robot` command on the command line. options – Options to configure and control execution. Accepted options are mostly same as normal command line options to the `robot` command. Option names match command line option long names without hyphens so that, for example, `--name` becomes `name`.

Most options that can be given from the command line work. An exception is that options --pythonpath, --argumentfile, --help and --version are not supported.

Options that can be given on the command line multiple times can be passed as lists. For example, include=['tag1', 'tag2'] is equivalent to --include tag1 --include tag2. If such options are used only once, they can be given also as a single string like include='tag'.

Options that accept no value can be given as Booleans. For example, dryrun=True is same as using the --dryrun option.

Options that accept string NONE as a special value can also be used with Python None. For example, using log=None is equivalent to --log NONE.

listener, prerunmodifier and prerebotmodifier options allow passing values as Python objects in addition to module names these command line options support. For example, run('tests', listener=MyListener()).

To capture the standard output and error streams, pass an open file or file-like object as special keyword arguments stdout and stderr, respectively.

A return code is returned similarly as when running on the command line. Zero means that tests were executed and no critical test failed, values up to 250 denote the number of failed critical tests, and values between 251-255 are for other statuses documented in the Robot Framework User Guide.

Example:

from robot import run

run('path/to/tests.robot')
run('tests.robot', include=['tag1', 'tag2'], splitlog=True)
with open('stdout.txt', 'w') as stdout:
    run('t1.robot', 't2.robot', name='Example', log=None, stdout=stdout)

Equivalent command line usage:

robot path/to/tests.robot
robot --include tag1 --include tag2 --splitlog tests.robot
robot --name Example --log NONE t1.robot t2.robot > stdout.txt

robot.run_cli(arguments=None, exit=True)[source]¶

Command line execution entry point for running tests.

Parameters:	arguments – Command line options and arguments as a list of strings. Starting from RF 3.1, defaults to `sys.argv[1:]` if not given. exit – If `True`, call `sys.exit` with the return code denoting execution status, otherwise just return the rc.

Entry point used when running tests from the command line, but can also be used by custom scripts that execute tests. Especially useful if the script itself needs to accept same arguments as accepted by Robot Framework, because the script can just pass them forward directly along with the possible default values it sets itself.

Example:

from robot import run_cli

# Run tests and return the return code.
rc = run_cli(['--name', 'Example', 'tests.robot'], exit=False)

# Run tests and exit to the system automatically.
run_cli(['--name', 'Example', 'tests.robot'])

See also the run() function that allows setting options as keyword arguments like name="Example" and generally has a richer API for programmatic test execution.

robot.rebot(*outputs, **options)[source]¶

Programmatic entry point for post-processing outputs.

Parameters:	outputs – Paths to Robot Framework output files similarly as when running the `rebot` command on the command line. options – Options to configure processing outputs. Accepted options are mostly same as normal command line options to the `rebot` command. Option names match command line option long names without hyphens so that, for example, `--name` becomes `name`.

The semantics related to passing options are exactly the same as with the run() function. See its documentation for more details.

Examples:

from robot import rebot

rebot('path/to/output.xml')
with open('stdout.txt', 'w') as stdout:
    rebot('o1.xml', 'o2.xml', name='Example', log=None, stdout=stdout)

Equivalent command line usage:

rebot path/to/output.xml
rebot --name Example --log NONE o1.xml o2.xml > stdout.txt

robot.rebot_cli(arguments=None, exit=True)[source]¶

Command line execution entry point for post-processing outputs.

Parameters:	arguments – Command line options and arguments as a list of strings. Starting from RF 3.1, defaults to `sys.argv[1:]` if not given. exit – If `True`, call `sys.exit` with the return code denoting execution status, otherwise just return the rc.

Entry point used when post-processing outputs from the command line, but can also be used by custom scripts. Especially useful if the script itself needs to accept same arguments as accepted by Rebot, because the script can just pass them forward directly along with the possible default values it sets itself.

Example:

from robot import rebot_cli

rebot_cli(['--name', 'Example', '--log', 'NONE', 'o1.xml', 'o2.xml'])

See also the rebot() function that allows setting options as keyword arguments like name="Example" and generally has a richer API for programmatic Rebot execution.

Subpackages¶

robot.api package¶

robot.api package exposes the public APIs of Robot Framework.

Unless stated otherwise, the APIs exposed in this package are considered stable, and thus safe to use when building external tools on top of Robot Framework. Notice that all parsing APIs were rewritten in Robot Framework 3.2.

Currently exposed APIs are:

logger module for libraries’ logging purposes.
deco module with decorators libraries can utilize.
exceptions module containing exceptions that libraries can utilize for reporting failures and other events. These exceptions can be imported also directly via robot.api like from robot.api import SkipExecution.
parsing module exposing the parsing APIs. This module is new in Robot Framework 4.0. Various parsing related functions and classes were exposed directly via robot.api already in Robot Framework 3.2, but they are effectively deprecated and will be removed in the future.
TestSuite class for creating executable test suites programmatically and TestSuiteBuilder class for creating such suites based on existing test data on the file system.
SuiteVisitor abstract class for processing testdata before execution. This can be used as a base for implementing a pre-run modifier that is taken into use with --prerunmodifier commandline option.
ExecutionResult() factory method for reading execution results from XML output files and ResultVisitor abstract class to ease further processing the results. ResultVisitor can also be used as a base for pre-Rebot modifier that is taken into use with --prerebotmodifier commandline option.
ResultWriter class for writing reports, logs, XML outputs, and XUnit files. Can write results based on XML outputs on the file system, as well as based on the result objects returned by the ExecutionResult() or an executed TestSuite.

All of the above names can be imported like:

from robot.api import ApiName

See documentations of the individual APIs for more details.

Tip

APIs related to the command line entry points are exposed directly via the robot root package.

Submodules¶

robot.api.deco module¶

robot.api.deco.not_keyword(func)[source]¶

Decorator to disable exposing functions or methods as keywords.

Examples:

@not_keyword
def not_exposed_as_keyword():
    # ...

def exposed_as_keyword():
    # ...

Alternatively the automatic keyword discovery can be disabled with the library() decorator or by setting the ROBOT_AUTO_KEYWORDS attribute to a false value.

New in Robot Framework 3.2.

robot.api.deco.keyword(name=None, tags=(), types=())[source]¶

Decorator to set custom name, tags and argument types to keywords.

This decorator creates robot_name, robot_tags and robot_types attributes on the decorated keyword function or method based on the provided arguments. Robot Framework checks them to determine the keyword’s name, tags, and argument types, respectively.

Name must be given as a string, tags as a list of strings, and types either as a dictionary mapping argument names to types or as a list of types mapped to arguments based on position. It is OK to specify types only to some arguments, and setting types to None disables type conversion altogether.

If the automatic keyword discovery has been disabled with the library() decorator or by setting the ROBOT_AUTO_KEYWORDS attribute to a false value, this decorator is needed to mark functions or methods keywords.

Examples:

@keyword
def example():
    # ...

@keyword('Login as user "${user}" with password "${password}"',
         tags=['custom name', 'embedded arguments', 'tags'])
def login(user, password):
    # ...

@keyword(types={'length': int, 'case_insensitive': bool})
def types_as_dict(length, case_insensitive):
    # ...

@keyword(types=[int, bool])
def types_as_list(length, case_insensitive):
    # ...

@keyword(types=None])
def no_conversion(length, case_insensitive=False):
    # ...

robot.api.deco.library(scope=None, version=None, doc_format=None, listener=None, auto_keywords=False)[source]¶

Class decorator to control keyword discovery and other library settings.

By default disables automatic keyword detection by setting class attribute ROBOT_AUTO_KEYWORDS = False to the decorated library. In that mode only methods decorated explicitly with the keyword() decorator become keywords. If that is not desired, automatic keyword discovery can be enabled by using auto_keywords=True.

Arguments scope, version, doc_format and listener set the library scope, version, documentation format and listener by using class attributes ROBOT_LIBRARY_SCOPE, ROBOT_LIBRARY_VERSION, ROBOT_LIBRARY_DOC_FORMAT and ROBOT_LIBRARY_LISTENER, respectively. These attributes are only set if the related arguments are given and they override possible existing attributes in the decorated class.

Examples:

@library
class KeywordDiscovery:

    @keyword
    def do_something(self):
        # ...

    def not_keyword(self):
        # ...


@library(scope='GLOBAL', version='3.2')
class LibraryConfiguration:
    # ...

The @library decorator is new in Robot Framework 3.2.

robot.api.exceptions module¶

Exceptions that libraries can use for communicating failures and other events.

These exceptions can be imported also via the top level robot.api package like from robot.api import SkipExecution.

This module and all exceptions are new in Robot Framework 4.0.

exception robot.api.exceptions.Failure(message, html=False)[source]¶

Bases: exceptions.AssertionError

Report failed validation.

There is no practical difference in using this exception compared to using the standard AssertionError. The main benefits are HTML support and that the name of this exception is consistent with other exceptions in this module.

Parameters:	message – Exception message. html – When `True`, message is considered to be HTML and not escaped.

ROBOT_SUPPRESS_NAME = True¶

args¶

message¶

exception robot.api.exceptions.ContinuableFailure(message, html=False)[source]¶

Bases: robot.api.exceptions.Failure

Report failed validation but allow continuing execution.

Parameters:	message – Exception message. html – When `True`, message is considered to be HTML and not escaped.

ROBOT_CONTINUE_ON_FAILURE = True¶

ROBOT_SUPPRESS_NAME = True¶

args¶

message¶

exception robot.api.exceptions.Error(message, html=False)[source]¶

Bases: exceptions.RuntimeError

Report error in execution.

Failures related to the system not behaving as expected should typically be reported using the Failure exception or the standard AssertionError. This exception can be used, for example, if the keyword is used incorrectly.

There is no practical difference in using this exception compared to using the standard RuntimeError. The main benefits are HTML support and that the name of this exception is consistent with other exceptions in this module.

Parameters:	message – Exception message. html – When `True`, message is considered to be HTML and not escaped.

ROBOT_SUPPRESS_NAME = True¶

args¶

message¶

exception robot.api.exceptions.FatalError(message, html=False)[source]¶

Bases: robot.api.exceptions.Error

Report error that stops the whole execution.

Parameters:	message – Exception message. html – When `True`, message is considered to be HTML and not escaped.

ROBOT_EXIT_ON_FAILURE = True¶

ROBOT_SUPPRESS_NAME = False¶

args¶

message¶

exception robot.api.exceptions.SkipExecution(message, html=False)[source]¶

Bases: exceptions.Exception

Mark the executed test or task skipped.

Parameters:	message – Exception message. html – When `True`, message is considered to be HTML and not escaped.

ROBOT_SKIP_EXECUTION = True¶

ROBOT_SUPPRESS_NAME = True¶

args¶

message¶

robot.api.logger module¶

Public logging API for test libraries.

This module provides a public API for writing messages to the log file and the console. Test libraries can use this API like:

logger.info('My message')

instead of logging through the standard output like:

print('*INFO* My message')

In addition to a programmatic interface being cleaner to use, this API has a benefit that the log messages have accurate timestamps.

If the logging methods are used when Robot Framework is not running, the messages are redirected to the standard Python logging module using logger named RobotFramework.

Log levels¶

It is possible to log messages using levels TRACE, DEBUG, INFO, WARN and ERROR either using the write() function or, more commonly, with the log level specific trace(), debug(), info(), warn(), error() functions.

By default the trace and debug messages are not logged but that can be changed with the --loglevel command line option. Warnings and errors are automatically written also to the console and to the Test Execution Errors section in the log file.

Logging HTML¶

All methods that are used for writing messages to the log file have an optional html argument. If a message to be logged is supposed to be shown as HTML, this argument should be set to True. Alternatively, write() accepts a pseudo log level HTML.

Example¶

from robot.api import logger

def my_keyword(arg):
    logger.debug('Got argument %s.' % arg)
    do_something()
    logger.info('<i>This</i> is a boring example.', html=True)

robot.api.logger.write(msg, level='INFO', html=False)[source]¶

Writes the message to the log file using the given level.

Valid log levels are TRACE, DEBUG, INFO (default), WARN, and ERROR. Additionally it is possible to use HTML pseudo log level that logs the message as HTML using the INFO level.

Instead of using this method, it is generally better to use the level specific methods such as info and debug that have separate html argument to control the message format.

robot.api.logger.trace(msg, html=False)[source]¶: Writes the message to the log file using the TRACE level.

robot.api.logger.debug(msg, html=False)[source]¶: Writes the message to the log file using the DEBUG level.

robot.api.logger.info(msg, html=False, also_console=False)[source]¶

Writes the message to the log file using the INFO level.

If also_console argument is set to True, the message is written both to the log file and to the console.

robot.api.logger.warn(msg, html=False)[source]¶: Writes the message to the log file using the WARN level.

robot.api.logger.error(msg, html=False)[source]¶: Writes the message to the log file using the ERROR level.

robot.api.logger.console(msg, newline=True, stream='stdout')[source]¶

Writes the message to the console.

If the newline argument is True, a newline character is automatically added to the message.

By default the message is written to the standard output stream. Using the standard error stream is possibly by giving the stream argument value 'stderr'.

robot.api.parsing module¶

Public API for parsing, inspecting and modifying test data.

Exposed API¶

The publicly exposed parsing entry points are the following:

get_tokens(), get_resource_tokens(), and get_init_tokens() functions for parsing data to tokens.
Token class that contains all token types as class attributes.
get_model(), get_resource_model(), and get_init_model() functions for parsing data to model represented as an abstract syntax tree (AST).
Model objects used by the AST model.
ModelVisitor to ease inspecting model and modifying data.
ModelTransformer for adding and removing nodes.

Note

This module is new in Robot Framework 4.0. In Robot Framework 3.2 functions for getting tokens and model as well as the Token class were exposed directly via the robot.api package, but other parts of the parsing API were not publicly exposed. All code targeting Robot Framework 4.0 or newer should use this module because parsing related functions and classes will be removed from robot.api in the future.

Note

Parsing was totally rewritten in Robot Framework 3.2 and external tools using the parsing APIs need to be updated. Depending on the use case, it may be possible to use the higher level TestSuiteBuilder() instead.

Parsing data to tokens¶

Data can be parsed to tokens by using get_tokens(), get_resource_tokens() or get_init_tokens() functions depending on whether the data represent a test case (or task) file, a resource file, or a suite initialization file. In practice the difference between these functions is what settings and sections are valid.

Typically the data is easier to inspect and modify by using the higher level model discussed in the next section, but in some cases having just the tokens can be enough. Tokens returned by the aforementioned functions are Token instances and they have the token type, value, and position easily available as their attributes. Tokens also have useful string representation used by the example below:

from robot.api.parsing import get_tokens

path = 'example.robot'

for token in get_tokens(path):
    print(repr(token))

If the example.robot used by the above example would contain

*** Test Cases ***
Example
    Keyword    argument

Second example
    Keyword    xxx

*** Keywords ***
Keyword
    [Arguments]    ${arg}
    Log    ${arg}

then the beginning of the output got when running the earlier code would look like this:

Token(TESTCASE_HEADER, '*** Test Cases ***', 1, 0)
Token(EOL, '\n', 1, 18)
Token(EOS, '', 1, 19)
Token(TESTCASE_NAME, 'Example', 2, 0)
Token(EOL, '\n', 2, 7)
Token(EOS, '', 2, 8)
Token(SEPARATOR, '    ', 3, 0)
Token(KEYWORD, 'Keyword', 3, 4)
Token(SEPARATOR, '    ', 3, 11)
Token(ARGUMENT, 'argument', 3, 15)
Token(EOL, '\n', 3, 23)
Token(EOS, '', 3, 24)
Token(EOL, '\n', 4, 0)
Token(EOS, '', 4, 1)

The output shows the token type, value, line number and column offset. When finding tokens by their type, the constants in the Token class such as Token.TESTCASE_NAME and Token.EOL should be used instead the values of these constants like 'TESTCASE NAME' and 'EOL'. These values have changed slightly in Robot Framework 4.0 and they may change in the future as well.

The EOL tokens denote end of a line and they include the newline character and possible trailing spaces. The EOS tokens denote end of a logical statement. Typically a single line forms a statement, but when the ... syntax is used for continuation, a statement spans multiple lines. In special cases a single line can also contain multiple statements.

Errors caused by unrecognized data such as non-existing section or setting names are handled during the tokenizing phase. Such errors are reported using tokens that have ERROR type and the actual error message in their error attribute. Syntax errors such as empty FOR loops are only handled when building the higher level model discussed below.

See the documentation of get_tokens() for details about different ways how to specify the data to be parsed, how to control should all tokens or only data tokens be returned, and should variables in keyword arguments and elsewhere be tokenized or not.

Parsing data to model¶

Data can be parsed to a higher level model by using get_model(), get_resource_model(), or get_init_model() functions depending on the type of the parsed file same way as when parsing data to tokens.

The model is represented as an abstract syntax tree (AST) implemented on top of Python’s standard ast.AST class. To see how the model looks like, it is possible to use the ast.dump() function or the third-party astpretty module:

import ast
import astpretty
from robot.api.parsing import get_model

model = get_model('example.robot')
print(ast.dump(model, include_attributes=True))
print('-' * 72)
astpretty.pprint(model)

Running this code with the example.robot file from the previous section would produce so much output that it is not included here. If you are going to work with Robot Framework’s AST, you are recommended to try that on your own.

Model objects¶

The model is build from nodes that are based ast.AST and further categorized to blocks and statements. Blocks can contain other blocks and statements as child nodes whereas statements only have tokens containing the actual data as Token instances. Both statements and blocks expose their position information via lineno, col_offset, end_lineno and end_col_offset attributes and some nodes have also other special attributes available.

Blocks:

Statements:

Inspecting model¶

The easiest way to inspect what data a model contains is implementing ModelVisitor and creating visit_NodeName to visit nodes with name NodeName as needed. The following example illustrates how to find what tests a certain test case file contains:

from robot.api.parsing import get_model, ModelVisitor


class TestNamePrinter(ModelVisitor):

    def visit_File(self, node):
        print(f"File '{node.source}' has following tests:")
        # Call `generic_visit` to visit also child nodes.
        self.generic_visit(node)

    def visit_TestCaseName(self, node):
        print(f"- {node.name} (on line {node.lineno})")


model = get_model('example.robot')
printer = TestNamePrinter()
printer.visit(model)

When the above code is run using the earlier example.robot, the output is this:

File 'example.robot' has following tests:
- Example (on line 2)
- Second example (on line 5)

Handling errors in model¶

All nodes in the model have errors attribute that contains possible errors the node has. These errors include syntax errors such as empty FOR loops or IF without a condition as well as errors caused by unrecognized data such as non-existing section or setting names.

Unrecognized data is handled already during the tokenizing phase. In the model such data is represented as Error nodes and their errors attribute contain error information got from the underlying ERROR tokens. Syntax errors do not create Error nodes, but instead the model has normal nodes such as If with errors in their errors attribute.

A simple way to go through the model and see are there errors is using the ModelVisitor discussed in the previous section:

class ErrorReporter(ModelVisitor):

    # Implement `generic_visit` to visit all nodes.
    def generic_visit(self, node):
        if node.errors:
            print(f'Error on line {node.lineno}:')
            for error in node.errors:
                print(f'- {error}')
        ModelVisitor.generic_visit(self, node)

Modifying data¶

Existing data the model contains can be modified simply by modifying values of the underlying tokens. If changes need to be saved, that is as easy as calling the save() method of the root model object. When just modifying token values, it is possible to still use ModelVisitor discussed in the above section. The next section discusses adding or removing nodes and then ModelTransformer should be used instead.

Modifications to tokens obviously require finding the tokens to be modified. The first step is finding nodes containing the tokens by implementing needed visit_NodeName methods. Then the exact token or tokens can be found using nodes’ get_token() or get_tokens() methods. If only token values are needed, get_value() or get_values() can be used as a shortcut. First finding nodes and then the right tokens is illustrated by this keyword renaming example:

from robot.api.parsing import get_model, ModelVisitor, Token


class KeywordRenamer(ModelVisitor):

    def __init__(self, old_name, new_name):
        self.old_name = self.normalize(old_name)
        self.new_name = new_name

    def normalize(self, name):
        return name.lower().replace(' ', '').replace('_', '')

    def visit_KeywordName(self, node):
        '''Rename keyword definitions.'''
        if self.normalize(node.name) == self.old_name:
            token = node.get_token(Token.KEYWORD_NAME)
            token.value = self.new_name

    def visit_KeywordCall(self, node):
        '''Rename keyword usages.'''
        if self.normalize(node.keyword) == self.old_name:
            token = node.get_token(Token.KEYWORD)
            token.value = self.new_name


model = get_model('example.robot')
renamer = KeywordRenamer('Keyword', 'New Name')
renamer.visit(model)
model.save()

If you run the above example using the earlier example.robot, you can see that the Keyword keyword has been renamed to New Name. Notice that a real keyword renamer needed to take into account also keywords used with setups, teardowns and templates.

When token values are changed, column offset of the other tokens on same line are likely to be wrong. This does not affect saving the model or other typical usages, but if it is a problem then the caller needs to updated offsets separately.

Adding and removing nodes¶

Bigger changes to the model are somewhat more complicated than just modifying existing token values. When doing this kind of changes, ModelTransformer should be used instead of ModelVisitor that was discussed in the previous sections.

Removing nodes is relative easy and is accomplished by returning None from visit_NodeName methods. Remember to return the original node, or possibly a replacement node, from all of these methods when you do not want a node to be removed.

Adding nodes requires constructing needed Model objects and adding them to the model. The following example demonstrates both removing and adding nodes. If you run it against the earlier example.robot, you see that the first test gets a new keyword, the second test is removed, and settings section with documentation is added.

from robot.api.parsing import (
    get_model, Documentation, EmptyLine, KeywordCall,
    ModelTransformer, SettingSection, SectionHeader, Token
)


class TestModifier(ModelTransformer):

    def visit_TestCase(self, node):
        # The matched `TestCase` node is a block with `header` and
        # `body` attributes. `header` is a statement with familiar
        # `get_token` and `get_value` methods for getting certain
        # tokens or their value.
        name = node.header.get_value(Token.TESTCASE_NAME)
        # Returning `None` drops the node altogether i.e. removes
        # this test.
        if name == 'Second example':
            return None
        # Construct new keyword call statement from tokens. See `visit_File`
        # below for an example creating statements using `from_params`.
        new_keyword = KeywordCall([
            Token(Token.SEPARATOR, '    '),
            Token(Token.KEYWORD, 'New Keyword'),
            Token(Token.SEPARATOR, '    '),
            Token(Token.ARGUMENT, 'xxx'),
            Token(Token.EOL)
        ])
        # Add the keyword call to test as the second item.
        node.body.insert(1, new_keyword)
        # No need to call `generic_visit` because we are not
        # modifying child nodes. The node itself must to be
        # returned to avoid dropping it.
        return node

    def visit_File(self, node):
        # Create settings section with documentation. Needed header and body
        # statements are created using `from_params` method. This is typically
        # more convenient than creating statements based on tokens like above.
        settings = SettingSection(
            header=SectionHeader.from_params(Token.SETTING_HEADER),
            body=[
                Documentation.from_params('This is a really\npowerful API!'),
                EmptyLine.from_params()
            ]
        )
        # Add settings to the beginning of the file.
        node.sections.insert(0, settings)
        # Call `generic_visit` to visit also child nodes.
        return self.generic_visit(node)


model = get_model('example.robot')
TestModifier().visit(model)
model.save('modified.robot')

Executing model¶

It is possible to convert a parsed and possibly modified model into an executable TestSuite structure by using its from_model() class method. In this case the get_model() function should be given the curdir argument to get possible ${CURDIR} variable resolved correctly.

from robot.api import TestSuite
from robot.api.parsing import get_model

model = get_model('example.robot', curdir='/home/robot/example')
# modify model as needed
suite = TestSuite.from_model(model)
suite.run()

For more details about executing the created TestSuite object, see the documentation of its run() method. Notice also that if you do not need to modify the parsed model, it is easier to get the executable suite by using the from_file_system() class method.

robot.conf package¶

Implements settings for both test execution and output processing.

This package implements RobotSettings and RebotSettings classes used internally by the framework. There should be no need to use these classes externally.

This package can be considered relatively stable. Aforementioned classes are likely to be rewritten at some point to be more convenient to use. Instantiating them is not likely to change, though.

Submodules¶

robot.conf.gatherfailed module¶

class robot.conf.gatherfailed.GatherFailedTests[source]¶

Bases: robot.model.visitor.SuiteVisitor

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(kw)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

class robot.conf.gatherfailed.GatherFailedSuites[source]¶

Bases: robot.model.visitor.SuiteVisitor

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(kw)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

robot.conf.gatherfailed.gather_failed_tests(output)[source]¶

robot.conf.gatherfailed.gather_failed_suites(output)[source]¶

robot.conf.settings module¶

class robot.conf.settings.RobotSettings(options=None, **extra_options)[source]¶

Bases: robot.conf.settings._BaseSettings

get_rebot_settings()[source]¶

listeners¶

debug_file¶

suite_config¶

randomize_seed¶

randomize_suites¶

randomize_tests¶

dry_run¶

exit_on_failure¶

exit_on_error¶

skipped_tags¶

skip_on_failure¶

skip_teardown_on_exit¶

console_output_config¶

console_type¶

console_width¶

console_markers¶

max_error_lines¶

pre_run_modifiers¶

run_empty_suite¶

variables¶

variable_files¶

extension¶

console_colors¶

critical_tags¶

flatten_keywords¶

log¶

log_level¶

output¶

output_directory¶

pre_rebot_modifiers¶

remove_keywords¶

report¶

rpa¶

split_log¶

statistics_config¶

status_rc¶

xunit¶

class robot.conf.settings.RebotSettings(options=None, **extra_options)[source]¶

Bases: robot.conf.settings._BaseSettings

suite_config¶

log_config¶

report_config¶

merge¶

console_output_config¶

console_colors¶

critical_tags¶

flatten_keywords¶

log¶

log_level¶

output¶

output_directory¶

pre_rebot_modifiers¶

process_empty_suite¶

remove_keywords¶

report¶

rpa¶

split_log¶

statistics_config¶

status_rc¶

xunit¶

expand_keywords¶

robot.htmldata package¶

Package for writing output files in HTML format.

This package is considered stable but it is not part of the public API.

Submodules¶

robot.htmldata.htmlfilewriter module¶

class robot.htmldata.htmlfilewriter.HtmlFileWriter(output, model_writer)[source]¶

Bases: object

write(template)[source]¶

class robot.htmldata.htmlfilewriter.ModelWriter[source]¶

Bases: robot.htmldata.htmlfilewriter._Writer

handles(line)¶

write(line)¶

class robot.htmldata.htmlfilewriter.LineWriter(output)[source]¶

Bases: robot.htmldata.htmlfilewriter._Writer

handles(line)[source]¶

write(line)[source]¶

class robot.htmldata.htmlfilewriter.GeneratorWriter(html_writer)[source]¶

Bases: robot.htmldata.htmlfilewriter._Writer

write(line)[source]¶

handles(line)¶

class robot.htmldata.htmlfilewriter.JsFileWriter(html_writer, base_dir)[source]¶

Bases: robot.htmldata.htmlfilewriter._InliningWriter

write(line)[source]¶

handles(line)¶

class robot.htmldata.htmlfilewriter.CssFileWriter(html_writer, base_dir)[source]¶

Bases: robot.htmldata.htmlfilewriter._InliningWriter

write(line)[source]¶

handles(line)¶

robot.htmldata.jartemplate module¶

robot.htmldata.jsonwriter module¶

class robot.htmldata.jsonwriter.JsonWriter(output, separator='')[source]¶

Bases: object

write_json(prefix, data, postfix=';\n', mapping=None, separator=True)[source]¶

write(string, postfix=';\n', separator=True)[source]¶

class robot.htmldata.jsonwriter.JsonDumper(output)[source]¶

Bases: object

dump(data, mapping=None)[source]¶

class robot.htmldata.jsonwriter.StringDumper(jsondumper)[source]¶

Bases: robot.htmldata.jsonwriter._Dumper

dump(data, mapping)[source]¶

handles(data, mapping)¶

class robot.htmldata.jsonwriter.IntegerDumper(jsondumper)[source]¶

Bases: robot.htmldata.jsonwriter._Dumper

dump(data, mapping)[source]¶

handles(data, mapping)¶

class robot.htmldata.jsonwriter.DictDumper(jsondumper)[source]¶

Bases: robot.htmldata.jsonwriter._Dumper

dump(data, mapping)[source]¶

handles(data, mapping)¶

class robot.htmldata.jsonwriter.TupleListDumper(jsondumper)[source]¶

Bases: robot.htmldata.jsonwriter._Dumper

dump(data, mapping)[source]¶

handles(data, mapping)¶

class robot.htmldata.jsonwriter.MappingDumper(jsondumper)[source]¶

Bases: robot.htmldata.jsonwriter._Dumper

handles(data, mapping)[source]¶

dump(data, mapping)[source]¶

class robot.htmldata.jsonwriter.NoneDumper(jsondumper)[source]¶

Bases: robot.htmldata.jsonwriter._Dumper

handles(data, mapping)[source]¶

dump(data, mapping)[source]¶

robot.htmldata.normaltemplate module¶

class robot.htmldata.normaltemplate.HtmlTemplate(filename)[source]¶: Bases: object

robot.htmldata.template module¶

robot.libdocpkg package¶

Implements the Libdoc tool.

The command line entry point and programmatic interface for Libdoc are provided by the separate robot.libdoc module.

This package is considered stable but it is not part of the public API.

Submodules¶

robot.libdocpkg.builder module¶

robot.libdocpkg.builder.JavaDocBuilder()[source]¶

robot.libdocpkg.builder.LibraryDocumentation(library_or_resource, name=None, version=None, doc_format=None)[source]¶

robot.libdocpkg.builder.DocumentationBuilder(library_or_resource)[source]¶

Create a documentation builder for the specified library or resource.

The argument can be a path to a library, a resource file or to a spec file generated by Libdoc earlier. If the argument does not point to an existing file, it is expected to be the name of the library to be imported. If a resource file is to be imported from PYTHONPATH, then ResourceDocBuilder must be used explicitly instead.

robot.libdocpkg.consoleviewer module¶

class robot.libdocpkg.consoleviewer.ConsoleViewer(libdoc)[source]¶

Bases: object

classmethod handles(command)[source]¶

classmethod validate_command(command, args)[source]¶

view(command, *args)[source]¶

list(*patterns)[source]¶

show(*names)[source]¶

version()[source]¶

class robot.libdocpkg.consoleviewer.KeywordMatcher(libdoc)[source]¶

Bases: object

search(patterns)[source]¶

robot.libdocpkg.datatypes module¶

class robot.libdocpkg.datatypes.EnumType[source]¶: Bases: object

class robot.libdocpkg.datatypes.DataTypeCatalog[source]¶

Bases: object

enums¶

typed_dicts¶

update(types)[source]¶

to_dictionary()[source]¶

class robot.libdocpkg.datatypes.TypedDictDoc(name='', doc='', items=None, type='TypedDict')[source]¶

Bases: robot.utils.sortable.Sortable

classmethod from_TypedDict(typed_dict)[source]¶

to_dictionary()[source]¶

class robot.libdocpkg.datatypes.EnumDoc(name='', doc='', members=None, type='Enum')[source]¶

Bases: robot.utils.sortable.Sortable

classmethod from_Enum(enum_type)[source]¶

to_dictionary()[source]¶

robot.libdocpkg.htmlutils module¶

class robot.libdocpkg.htmlutils.DocFormatter(keywords, data_types, introduction, doc_format='ROBOT')[source]¶

Bases: object

html(doc, intro=False)[source]¶

class robot.libdocpkg.htmlutils.DocToHtml(doc_format)[source]¶: Bases: object

class robot.libdocpkg.htmlutils.HtmlToText[source]¶

Bases: object

html_tags = {'b': '*', 'code': '``', 'div.*?': '', 'em': '_', 'i': '_', 'strong': '*'}¶

html_chars = {'&': '&', ''': "'", '>': '>', '<': '<', '"': '"', '<br */?>': '\n'}¶

get_shortdoc_from_html(doc)[source]¶

html_to_plain_text(doc)[source]¶

robot.libdocpkg.htmlwriter module¶

class robot.libdocpkg.htmlwriter.LibdocHtmlWriter[source]¶

Bases: object

write(libdoc, output)[source]¶

class robot.libdocpkg.htmlwriter.LibdocModelWriter(output, libdoc)[source]¶

Bases: robot.htmldata.htmlfilewriter.ModelWriter

write(line)[source]¶

handles(line)¶

robot.libdocpkg.java9builder module¶

robot.libdocpkg.javabuilder module¶

class robot.libdocpkg.javabuilder.JavaDocBuilder[source]¶

Bases: object

build(path)[source]¶

robot.libdocpkg.javabuilder.ClassDoc(path)[source]¶

Process the given Java source file and return ClassDoc instance.

Processing is done using com.sun.tools.javadoc APIs. Returned object implements com.sun.javadoc.ClassDoc interface: http://docs.oracle.com/javase/7/docs/jdk/api/javadoc/doclet/

robot.libdocpkg.jsonbuilder module¶

class robot.libdocpkg.jsonbuilder.JsonDocBuilder[source]¶

Bases: object

build(path)[source]¶

build_from_dict(spec)[source]¶

robot.libdocpkg.jsonwriter module¶

class robot.libdocpkg.jsonwriter.LibdocJsonWriter[source]¶

Bases: object

write(libdoc, outfile)[source]¶

robot.libdocpkg.model module¶

class robot.libdocpkg.model.LibraryDoc(name='', doc='', version='', type='LIBRARY', scope='TEST', doc_format='ROBOT', source=None, lineno=-1)[source]¶

Bases: object

doc¶

doc_format¶

inits¶

keywords¶

all_tags¶

save(output=None, format='HTML')[source]¶

convert_docs_to_html()[source]¶

to_dictionary()[source]¶

to_json(indent=None)[source]¶

class robot.libdocpkg.model.KeywordDoc(name='', args=(), doc='', shortdoc='', tags=(), source=None, lineno=-1, parent=None)[source]¶

Bases: robot.utils.sortable.Sortable

shortdoc¶

deprecated¶

generate_shortdoc()[source]¶

to_dictionary()[source]¶

robot.libdocpkg.output module¶

class robot.libdocpkg.output.LibdocOutput(output_path, format)[source]¶: Bases: object

robot.libdocpkg.robotbuilder module¶

class robot.libdocpkg.robotbuilder.LibraryDocBuilder[source]¶

Bases: object

build(library)[source]¶

class robot.libdocpkg.robotbuilder.ResourceDocBuilder[source]¶

Bases: object

build(path)[source]¶

class robot.libdocpkg.robotbuilder.KeywordDocBuilder(resource=False)[source]¶

Bases: object

build_keywords(lib)[source]¶

build_keyword(kw)[source]¶

robot.libdocpkg.specbuilder module¶

class robot.libdocpkg.specbuilder.SpecDocBuilder[source]¶

Bases: object

build(path)[source]¶

robot.libdocpkg.writer module¶

robot.libdocpkg.writer.LibdocWriter(format=None)[source]¶

robot.libdocpkg.xmlwriter module¶

class robot.libdocpkg.xmlwriter.LibdocXmlWriter[source]¶

Bases: object

write(libdoc, outfile)[source]¶

robot.libraries package¶

Package hosting Robot Framework standard test libraries.

Libraries are mainly used externally in the test data, but they can be also used by custom test libraries if there is a need. Especially the BuiltIn library is often useful when there is a need to interact with the framework.

Because libraries are documented using Robot Framework’s own documentation syntax, the generated API docs are not that well formed. It is thus better to find the generated library documentations, for example, via the http://robotframework.org web site.

Submodules¶

robot.libraries.BuiltIn module¶

robot.libraries.BuiltIn.run_keyword_variant(resolve)[source]¶

class robot.libraries.BuiltIn.BuiltIn[source]¶

Bases: robot.libraries.BuiltIn._Verify, robot.libraries.BuiltIn._Converter, robot.libraries.BuiltIn._Variables, robot.libraries.BuiltIn._RunKeyword, robot.libraries.BuiltIn._Control, robot.libraries.BuiltIn._Misc

An always available standard library with often needed keywords.

BuiltIn is Robot Framework’s standard library that provides a set of generic keywords needed often. It is imported automatically and thus always available. The provided keywords can be used, for example, for verifications (e.g. Should Be Equal, Should Contain), conversions (e.g. Convert To Integer) and for various other purposes (e.g. Log, Sleep, Run Keyword If, Set Global Variable).

== Table of contents ==

%TOC%

= HTML error messages =

Many of the keywords accept an optional error message to use if the keyword fails, and it is possible to use HTML in these messages by prefixing them with *HTML*. See Fail keyword for a usage example. Notice that using HTML in messages is not limited to BuiltIn library but works with any error message.

= Evaluating expressions =

Many keywords, such as Evaluate, Run Keyword If and Should Be True, accept an expression that is evaluated in Python.

== Evaluation namespace ==

Expressions are evaluated using Python’s [http://docs.python.org/library/functions.html#eval|eval] function so that all Python built-ins like len() and int() are available. In addition to that, all unrecognized variables are considered to be modules that are automatically imported. It is possible to use all available Python modules, including the standard modules and the installed third party modules.

Evaluate also allows configuring the execution namespace with a custom namespace and with custom modules to be imported. The latter functionality is useful in special cases where the automatic module import does not work such as when using nested modules like rootmod.submod or list comprehensions. See the documentation of the Evaluate keyword for mode details.

NOTE: Automatic module import is a new feature in Robot Framework 3.2. Earlier modules needed to be explicitly taken into use when using the Evaluate keyword and other keywords only had access to sys and os modules.

== Using variables ==

When a variable is used in the expressing using the normal ${variable} syntax, its value is replaced before the expression is evaluated. This means that the value used in the expression will be the string representation of the variable value, not the variable value itself. This is not a problem with numbers and other objects that have a string representation that can be evaluated directly, but with other objects the behavior depends on the string representation. Most importantly, strings must always be quoted, and if they can contain newlines, they must be triple quoted.

Actual variables values are also available in the evaluation namespace. They can be accessed using special variable syntax without the curly braces like $variable. These variables should never be quoted.

Using the $variable syntax slows down expression evaluation a little. This should not typically matter, but should be taken into account if complex expressions are evaluated often and there are strict time constrains.

Notice that instead of creating complicated expressions, it is often better to move the logic into a test library. That eases maintenance and can also enhance execution speed.

= Boolean arguments =

Some keywords accept arguments that are handled as Boolean values true or false. If such an argument is given as a string, it is considered false if it is an empty string or equal to FALSE, NONE, NO, OFF or 0, case-insensitively. Keywords verifying something that allow dropping actual and expected values from the possible error message also consider string no values to be false. Other strings are considered true unless the keyword documentation explicitly states otherwise, and other argument types are tested using the same [http://docs.python.org/library/stdtypes.html#truth|rules as in Python].

True examples:

False examples:

= Pattern matching =

Many keywords accepts arguments as either glob or regular expression patterns.

== Glob patterns ==

Some keywords, for example Should Match, support so called [http://en.wikipedia.org/wiki/Glob_(programming)|glob patterns] where:

Unlike with glob patterns normally, path separator characters / and \ and the newline character \n are matches by the above wildcards.

== Regular expressions ==

Some keywords, for example Should Match Regexp, support [http://en.wikipedia.org/wiki/Regular_expression|regular expressions] that are more powerful but also more complicated that glob patterns. The regular expression support is implemented using Python’s [http://docs.python.org/library/re.html|re module] and its documentation should be consulted for more information about the syntax.

Because the backslash character (\) is an escape character in Robot Framework test data, possible backslash characters in regular expressions need to be escaped with another backslash like \\d\\w+. Strings that may contain special characters but should be handled as literal strings, can be escaped with the Regexp Escape keyword.

= Multiline string comparison =

Should Be Equal and Should Be Equal As Strings report the failures using [http://en.wikipedia.org/wiki/Diff_utility#Unified_format|unified diff format] if both strings have more than two lines.

Results in the following error message:

= String representations =

Several keywords log values explicitly (e.g. Log) or implicitly (e.g. Should Be Equal when there are failures). By default keywords log values using “human readable” string representation, which means that strings like Hello and numbers like 42 are logged as-is. Most of the time this is the desired behavior, but there are some problems as well:

It is not possible to see difference between different objects that have same string representation like string 42 and integer 42. Should Be Equal and some other keywords add the type information to the error message in these cases, though.
Non-printable characters such as the null byte are not visible.
Trailing whitespace is not visible.
Different newlines (\r\n on Windows, \n elsewhere) cannot be separated from each others.
There are several Unicode characters that are different but look the same. One example is the Latin a (\u0061) and the Cyrillic а (\u0430). Error messages like a != а are not very helpful.
Some Unicode characters can be represented using [https://en.wikipedia.org/wiki/Unicode_equivalence|different forms]. For example, ä can be represented either as a single code point \u00e4 or using two code points \u0061 and \u0308 combined together. Such forms are considered canonically equivalent, but strings containing them are not considered equal when compared in Python. Error messages like ä != ä are not that helpful either.
Containers such as lists and dictionaries are formatted into a single line making it hard to see individual items they contain.

To overcome the above problems, some keywords such as Log and Should Be Equal have an optional formatter argument that can be used to configure the string representation. The supported values are str (default), repr, and ascii that work similarly as [https://docs.python.org/library/functions.html|Python built-in functions] with same names. More detailed semantics are explained below.

== str ==

Use the “human readable” string representation. Equivalent to using str() in Python 3 and unicode() in Python 2. This is the default.

== repr ==

Use the “machine readable” string representation. Similar to using repr() in Python, which means that strings like Hello are logged like 'Hello', newlines and non-printable characters are escaped like \n and \x00, and so on. Non-ASCII characters are shown as-is like ä in Python 3 and in escaped format like \xe4 in Python 2. Use ascii to always get the escaped format.

There are also some enhancements compared to the standard repr(): - Bigger lists, dictionaries and other containers are pretty-printed so

that there is one item per row.

On Python 2 the u prefix is omitted with Unicode strings and the b prefix is added to byte strings.

== ascii ==

Same as using ascii() in Python 3 or repr() in Python 2 where ascii() does not exist. Similar to using repr explained above but with the following differences:

On Python 3 non-ASCII characters are escaped like \xe4 instead of showing them as-is like ä. This makes it easier to see differences between Unicode characters that look the same but are not equal. This is how repr() works in Python 2.
On Python 2 just uses the standard repr() meaning that Unicode strings get the u prefix and no b prefix is added to byte strings.
Containers are not pretty-printed.

ROBOT_LIBRARY_SCOPE = 'GLOBAL'¶

ROBOT_LIBRARY_VERSION = '4.1.2'¶

call_method(object, method_name, *args, **kwargs)¶

Calls the named method of the given object with the provided arguments.

The possible return value from the method is returned and can be assigned to a variable. Keyword fails both if the object does not have a method with the given name or if executing the method raises an exception.

Possible equal signs in arguments must be escaped with a backslash like \=.

catenate(*items)¶

Catenates the given items together and returns the resulted string.

By default, items are catenated with spaces, but if the first item contains the string SEPARATOR=<sep>, the separator <sep> is used instead. Items are converted into strings when necessary.

comment(*messages)¶

Displays the given messages in the log file as keyword arguments.

This keyword does nothing with the arguments it receives, but as they are visible in the log, this keyword can be used to display simple messages. Given arguments are ignored so thoroughly that they can even contain non-existing variables. If you are interested about variable values, you can use the Log or Log Many keywords.

continue_for_loop()¶

Skips the current for loop iteration and continues from the next.

Skips the remaining keywords in the current for loop iteration and continues from the next one. Can be used directly in a for loop or in a keyword that the loop uses.

See Continue For Loop If to conditionally continue a for loop without using Run Keyword If or other wrapper keywords.

continue_for_loop_if(condition)¶

Skips the current for loop iteration if the condition is true.

A wrapper for Continue For Loop to continue a for loop based on the given condition. The condition is evaluated using the same semantics as with Should Be True keyword.

convert_to_binary(item, base=None, prefix=None, length=None)¶

Converts the given item to a binary string.

The item, with an optional base, is first converted to an integer using Convert To Integer internally. After that it is converted to a binary number (base 2) represented as a string such as 1011.

The returned value can contain an optional prefix and can be required to be of minimum length (excluding the prefix and a possible minus sign). If the value is initially shorter than the required length, it is padded with zeros.

See also Convert To Integer, Convert To Octal and Convert To Hex.

convert_to_boolean(item)¶

Converts the given item to Boolean true or false.

Handles strings True and False (case-insensitive) as expected, otherwise returns item’s [http://docs.python.org/library/stdtypes.html#truth|truth value] using Python’s bool() method.

convert_to_bytes(input, input_type='text')¶

Converts the given input to bytes according to the input_type.

Valid input types are listed below:

text: Converts text to bytes character by character. All characters with ordinal below 256 can be used and are converted to bytes with same values. Many characters are easiest to represent using escapes like \x00 or \xff. Supports both Unicode strings and bytes.
int: Converts integers separated by spaces to bytes. Similarly as with Convert To Integer, it is possible to use binary, octal, or hex values by prefixing the values with 0b, 0o, or 0x, respectively.
hex: Converts hexadecimal values to bytes. Single byte is always two characters long (e.g. 01 or FF). Spaces are ignored and can be used freely as a visual separator.
bin: Converts binary values to bytes. Single byte is always eight characters long (e.g. 00001010). Spaces are ignored and can be used freely as a visual separator.

In addition to giving the input as a string, it is possible to use lists or other iterables containing individual characters or numbers. In that case numbers do not need to be padded to certain length and they cannot contain extra spaces.

Use Encode String To Bytes in String library if you need to convert text to bytes using a certain encoding.

convert_to_hex(item, base=None, prefix=None, length=None, lowercase=False)¶

Converts the given item to a hexadecimal string.

The item, with an optional base, is first converted to an integer using Convert To Integer internally. After that it is converted to a hexadecimal number (base 16) represented as a string such as FF0A.

The returned value can contain an optional prefix and can be required to be of minimum length (excluding the prefix and a possible minus sign). If the value is initially shorter than the required length, it is padded with zeros.

By default the value is returned as an upper case string, but the lowercase argument a true value (see Boolean arguments) turns the value (but not the given prefix) to lower case.

See also Convert To Integer, Convert To Binary and Convert To Octal.

convert_to_integer(item, base=None)¶

Converts the given item to an integer number.

If the given item is a string, it is by default expected to be an integer in base 10. There are two ways to convert from other bases:

Give base explicitly to the keyword as base argument.
Prefix the given string with the base so that 0b means binary (base 2), 0o means octal (base 8), and 0x means hex (base 16). The prefix is considered only when base argument is not given and may itself be prefixed with a plus or minus sign.

The syntax is case-insensitive and possible spaces are ignored.

See also Convert To Number, Convert To Binary, Convert To Octal, Convert To Hex, and Convert To Bytes.

convert_to_number(item, precision=None)¶

Converts the given item to a floating point number.

If the optional precision is positive or zero, the returned number is rounded to that number of decimal digits. Negative precision means that the number is rounded to the closest multiple of 10 to the power of the absolute precision. If a number is equally close to a certain precision, it is always rounded away from zero.

Notice that machines generally cannot store floating point numbers accurately. This may cause surprises with these numbers in general and also when they are rounded. For more information see, for example, these resources:

If you want to avoid possible problems with floating point numbers, you can implement custom keywords using Python’s [http://docs.python.org/library/decimal.html|decimal] or [http://docs.python.org/library/fractions.html|fractions] modules.

If you need an integer number, use Convert To Integer instead.

convert_to_octal(item, base=None, prefix=None, length=None)¶

Converts the given item to an octal string.

The item, with an optional base, is first converted to an integer using Convert To Integer internally. After that it is converted to an octal number (base 8) represented as a string such as 775.

The returned value can contain an optional prefix and can be required to be of minimum length (excluding the prefix and a possible minus sign). If the value is initially shorter than the required length, it is padded with zeros.

See also Convert To Integer, Convert To Binary and Convert To Hex.

convert_to_string(item)¶

Converts the given item to a Unicode string.

Strings are also [http://www.macchiato.com/unicode/nfc-faq| NFC normalized].

Use Encode String To Bytes and Decode Bytes To String keywords in String library if you need to convert between Unicode and byte strings using different encodings. Use Convert To Bytes if you just want to create byte strings.

create_dictionary(*items)¶

Creates and returns a dictionary based on the given items.

Items are typically given using the key=value syntax same way as &{dictionary} variables are created in the Variable table. Both keys and values can contain variables, and possible equal sign in key can be escaped with a backslash like escaped\=key=value. It is also possible to get items from existing dictionaries by simply using them like &{dict}.

Alternatively items can be specified so that keys and values are given separately. This and the key=value syntax can even be combined, but separately given items must be first. If same key is used multiple times, the last value has precedence.

The returned dictionary is ordered, and values with strings as keys can also be accessed using a convenient dot-access syntax like ${dict.key}. Technically the returned dictionary is Robot Framework’s own DotDict instance. If there is a need, it can be converted into a regular Python dict instance by using the Convert To Dictionary keyword from the Collections library.

create_list(*items)¶

Returns a list containing given items.

The returned list can be assigned both to ${scalar} and @{list} variables.

evaluate(expression, modules=None, namespace=None)¶

Evaluates the given expression in Python and returns the result.

expression is evaluated in Python as explained in the Evaluating expressions section.

modules argument can be used to specify a comma separated list of Python modules to be imported and added to the evaluation namespace.

namespace argument can be used to pass a custom evaluation namespace as a dictionary. Possible modules are added to this namespace.

Variables used like ${variable} are replaced in the expression before evaluation. Variables are also available in the evaluation namespace and can be accessed using the special $variable syntax as explained in the Evaluating expressions section.

Starting from Robot Framework 3.2, modules used in the expression are imported automatically. There are, however, two cases where they need to be explicitly specified using the modules argument:

When nested modules like rootmod.submod are implemented so that the root module does not automatically import sub modules. This is illustrated by the selenium.webdriver example below.
When using a module in the expression part of a list comprehension. This is illustrated by the json example below.

NOTE: Prior to Robot Framework 3.2 using modules=rootmod.submod was not enough to make the root module itself available in the evaluation namespace. It needed to be taken into use explicitly like modules=rootmod, rootmod.submod.

exit_for_loop()¶

Stops executing the enclosing for loop.

Exits the enclosing for loop and continues execution after it. Can be used directly in a for loop or in a keyword that the loop uses.

See Exit For Loop If to conditionally exit a for loop without using Run Keyword If or other wrapper keywords.

exit_for_loop_if(condition)¶

Stops executing the enclosing for loop if the condition is true.

A wrapper for Exit For Loop to exit a for loop based on the given condition. The condition is evaluated using the same semantics as with Should Be True keyword.

fail(msg=None, *tags)¶

Fails the test with the given message and optionally alters its tags.

The error message is specified using the msg argument. It is possible to use HTML in the given error message, similarly as with any other keyword accepting an error message, by prefixing the error with *HTML*.

It is possible to modify tags of the current test case by passing tags after the message. Tags starting with a hyphen (e.g. -regression) are removed and others added. Tags are modified using Set Tags and Remove Tags internally, and the semantics setting and removing them are the same as with these keywords.

See Fatal Error if you need to stop the whole test execution.

fatal_error(msg=None)¶

Stops the whole test execution.

The test or suite where this keyword is used fails with the provided message, and subsequent tests fail with a canned message. Possible teardowns will nevertheless be executed.

See Fail if you only want to stop one test case unconditionally.

get_count(container, item)¶

Returns and logs how many times item is found from container.

This keyword works with Python strings and lists and all objects that either have count method or can be converted to Python lists.

get_length(item)¶

Returns and logs the length of the given item as an integer.

The item can be anything that has a length, for example, a string, a list, or a mapping. The keyword first tries to get the length with the Python function len, which calls the item’s __len__ method internally. If that fails, the keyword tries to call the item’s possible length and size methods directly. The final attempt is trying to get the value of the item’s length attribute. If all these attempts are unsuccessful, the keyword fails.

See also Length Should Be, Should Be Empty and Should Not Be Empty.

get_library_instance(name=None, all=False)¶

Returns the currently active instance of the specified test library.

This keyword makes it easy for test libraries to interact with other test libraries that have state. This is illustrated by the Python example below:

It is also possible to use this keyword in the test data and pass the returned library instance to another keyword. If a library is imported with a custom name, the name used to get the instance must be that name and not the original library name.

If the optional argument all is given a true value, then a dictionary mapping all library names to instances will be returned.

get_time(format='timestamp', time_='NOW')¶

Returns the given time in the requested format.

NOTE: DateTime library contains much more flexible keywords for getting the current date and time and for date and time handling in general.

How time is returned is determined based on the given format string as follows. Note that all checks are case-insensitive.

If format contains the word epoch, the time is returned in seconds after the UNIX epoch (1970-01-01 00:00:00 UTC). The return value is always an integer.
If format contains any of the words year, month, day, hour, min, or sec, only the selected parts are returned. The order of the returned parts is always the one in the previous sentence and the order of words in format is not significant. The parts are returned as zero-padded strings (e.g. May -> 05).
Otherwise (and by default) the time is returned as a timestamp string in the format 2006-02-24 15:08:31.

By default this keyword returns the current local time, but that can be altered using time argument as explained below. Note that all checks involving strings are case-insensitive.

If time is a number, or a string that can be converted to a number, it is interpreted as seconds since the UNIX epoch. This documentation was originally written about 1177654467 seconds after the epoch.
If time is a timestamp, that time will be used. Valid timestamp formats are YYYY-MM-DD hh:mm:ss and YYYYMMDD hhmmss.
If time is equal to NOW (default), the current local time is used.
If time is equal to UTC, the current time in [http://en.wikipedia.org/wiki/Coordinated_Universal_Time|UTC] is used.
If time is in the format like NOW - 1 day or UTC + 1 hour 30 min, the current local/UTC time plus/minus the time specified with the time string is used. The time string format is described in an appendix of Robot Framework User Guide.

UTC time is 2006-03-29 12:06:21):

get_variable_value(name, default=None)¶

Returns variable value or default if the variable does not exist.

The name of the variable can be given either as a normal variable name (e.g. ${NAME}) or in escaped format (e.g. \${NAME}). Notice that the former has some limitations explained in Set Suite Variable.

See Set Variable If for another keyword to set variables dynamically.

get_variables(no_decoration=False)¶

Returns a dictionary containing all variables in the current scope.

Variables are returned as a special dictionary that allows accessing variables in space, case, and underscore insensitive manner similarly as accessing variables in the test data. This dictionary supports all same operations as normal Python dictionaries and, for example, Collections library can be used to access or modify it. Modifying the returned dictionary has no effect on the variables available in the current scope.

By default variables are returned with ${}, @{} or &{} decoration based on variable types. Giving a true value (see Boolean arguments) to the optional argument no_decoration will return the variables without the decoration.

import_library(name, *args)¶

Imports a library with the given name and optional arguments.

This functionality allows dynamic importing of libraries while tests are running. That may be necessary, if the library itself is dynamic and not yet available when test data is processed. In a normal case, libraries should be imported using the Library setting in the Setting section.

This keyword supports importing libraries both using library names and physical paths. When paths are used, they must be given in absolute format or found from [http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#module-search-path| search path]. Forward slashes can be used as path separators in all operating systems.

It is possible to pass arguments to the imported library and also named argument syntax works if the library supports it. WITH NAME syntax can be used to give a custom name to the imported library.

import_resource(path)¶

Imports a resource file with the given path.

Resources imported with this keyword are set into the test suite scope similarly when importing them in the Setting table using the Resource setting.

The given path must be absolute or found from [http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#pythonpath-jythonpath-and-ironpythonpath| search path]. Forward slashes can be used as path separator regardless the operating system.

import_variables(path, *args)¶

Imports a variable file with the given path and optional arguments.

Variables imported with this keyword are set into the test suite scope similarly when importing them in the Setting table using the Variables setting. These variables override possible existing variables with the same names. This functionality can thus be used to import new variables, for example, for each test in a test suite.

The given path must be absolute or found from [http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#pythonpath-jythonpath-and-ironpythonpath| search path]. Forward slashes can be used as path separator regardless the operating system.

keyword_should_exist(name, msg=None)¶

Fails unless the given keyword exists in the current scope.

Fails also if there are more than one keywords with the same name. Works both with the short name (e.g. Log) and the full name (e.g. BuiltIn.Log).

The default error message can be overridden with the msg argument.

robot.libraries.Collections module¶

class robot.libraries.Collections.NotSet[source]¶: Bases: object

class robot.libraries.Collections.Collections[source]¶

Bases: robot.libraries.Collections._List, robot.libraries.Collections._Dictionary

A test library providing keywords for handling lists and dictionaries.

Collections is Robot Framework’s standard library that provides a set of keywords for handling Python lists and dictionaries. This library has keywords, for example, for modifying and getting values from lists and dictionaries (e.g. Append To List, Get From Dictionary) and for verifying their contents (e.g. Lists Should Be Equal, Dictionary Should Contain Value).

== Table of contents ==

%TOC%

= Related keywords in BuiltIn =

Following keywords in the BuiltIn library can also be used with lists and dictionaries:

= Using with list-like and dictionary-like objects =

List keywords that do not alter the given list can also be used with tuples, and to some extend also with other iterables. Convert To List can be used to convert tuples and other iterables to Python list objects.

Similarly dictionary keywords can, for most parts, be used with other mappings. Convert To Dictionary can be used if real Python dict objects are needed.

= Boolean arguments =

Some keywords accept arguments that are handled as Boolean values true or false. If such an argument is given as a string, it is considered false if it is an empty string or equal to FALSE, NONE, NO, OFF or 0, case-insensitively. Keywords verifying something that allow dropping actual and expected values from the possible error message also consider string no values to be false. Other strings are considered true regardless their value, and other argument types are tested using the same [http://docs.python.org/library/stdtypes.html#truth|rules as in Python].

True examples:

False examples:

Considering OFF and 0 false is new in Robot Framework 3.1.

= Data in examples =

List related keywords use variables in format ${Lx} in their examples. They mean lists with as many alphabetic characters as specified by x. For example, ${L1} means ['a'] and ${L3} means ['a', 'b', 'c'].

Dictionary keywords use similar ${Dx} variables. For example, ${D1} means {'a': 1} and ${D3} means {'a': 1, 'b': 2, 'c': 3}.

ROBOT_LIBRARY_SCOPE = 'GLOBAL'¶

ROBOT_LIBRARY_VERSION = '4.1.2'¶

should_contain_match(list, pattern, msg=None, case_insensitive=False, whitespace_insensitive=False)[source]¶

Fails if pattern is not found in list.

By default, pattern matching is similar to matching files in a shell and is case-sensitive and whitespace-sensitive. In the pattern syntax, * matches to anything and ? matches to any single character. You can also prepend glob= to your pattern to explicitly use this pattern matching behavior.

If you prepend regexp= to your pattern, your pattern will be used according to the Python [http://docs.python.org/library/re.html|re module] regular expression syntax. Important note: Backslashes are an escape character, and must be escaped with another backslash (e.g. regexp=\\d{6} to search for \d{6}). See BuiltIn.Should Match Regexp for more details.

If case_insensitive is given a true value (see Boolean arguments), the pattern matching will ignore case.

If whitespace_insensitive is given a true value (see Boolean arguments), the pattern matching will ignore whitespace.

Non-string values in lists are ignored when matching patterns.

Use the msg argument to override the default error message.

robot.libraries.DateTime module¶

A test library for handling date and time values.

DateTime is a Robot Framework standard library that supports creating and converting date and time values (e.g. Get Current Date, Convert Time), as well as doing simple calculations with them (e.g. Subtract Time From Date, Add Time To Time). It supports dates and times in various formats, and can also be used by other libraries programmatically.

== Table of contents ==

%TOC%

= Terminology =

In the context of this library, date and time generally have following meanings:

date: An entity with both date and time components but without any

timezone information. For example, 2014-06-11 10:07:42.
time: A time interval. For example, 1 hour 20 minutes or 01:20:00.

This terminology differs from what Python’s standard [http://docs.python.org/library/datetime.html|datetime] module uses. Basically its [http://docs.python.org/library/datetime.html#datetime-objects|datetime] and [http://docs.python.org/library/datetime.html#timedelta-objects|timedelta] objects match date and time as defined by this library.

= Date formats =

Dates can given to and received from keywords in timestamp, custom timestamp, Python datetime and epoch time formats. These formats are discussed thoroughly in subsequent sections.

Input format is determined automatically based on the given date except when using custom timestamps, in which case it needs to be given using date_format argument. Default result format is timestamp, but it can be overridden using result_format argument.

== Timestamp ==

If a date is given as a string, it is always considered to be a timestamp. If no custom formatting is given using date_format argument, the timestamp is expected to be in [http://en.wikipedia.org/wiki/ISO_8601|ISO 8601] like format YYYY-MM-DD hh:mm:ss.mil, where any non-digit character can be used as a separator or separators can be omitted altogether. Additionally, only the date part is mandatory, all possibly missing time components are considered to be zeros.

Dates can also be returned in the same YYYY-MM-DD hh:mm:ss.mil format by using timestamp value with result_format argument. This is also the default format that keywords returning dates use. Milliseconds can be excluded using exclude_millis as explained in Millisecond handling section.

== Custom timestamp ==

It is possible to use custom timestamps in both input and output. The custom format is same as accepted by Python’s [http://docs.python.org/library/datetime.html#strftime-strptime-behavior| datetime.strptime] function. For example, the default timestamp discussed in the previous section would match %Y-%m-%d %H:%M:%S.%f.

When using a custom timestamp in input, it must be specified using date_format argument. The actual input value must be a string that matches the specified format exactly. When using a custom timestamp in output, it must be given using result_format argument.

Notice that locale aware directives like %b do not work correctly with Jython on non-English locales: http://bugs.jython.org/issue2285

== Python datetime ==

Python’s standard [http://docs.python.org/library/datetime.html#datetime-objects|datetime] objects can be used both in input and output. In input they are recognized automatically, and in output it is possible to get them by giving datetime value to result_format argument.

One nice benefit with datetime objects is that they have different time components available as attributes that can be easily accessed using the extended variable syntax.

== Epoch time ==

Epoch time is the time in seconds since the [http://en.wikipedia.org/wiki/Unix_time|UNIX epoch] i.e. 00:00:00.000 (UTC) 1 January 1970. To give a date in epoch time, it must be given as a number (integer or float), not as a string. To return a date in epoch time, it is possible to use epoch value with result_format argument. Epoch time is returned as a floating point number.

Notice that epoch time itself is independent on timezones and thus same around the world at a certain time. What local time a certain epoch time matches obviously then depends on the timezone. For example, examples below were tested in Finland but verifications would fail on other timezones.

== Earliest supported date ==

The earliest date that is supported depends on the date format and to some extent on the platform:

Timestamps support year 1900 and above.
Python datetime objects support year 1 and above.
Epoch time supports 1970 and above on Windows with Python and IronPython.
On other platforms epoch time supports 1900 and above or even earlier.

= Time formats =

Similarly as dates, times can be given to and received from keywords in various different formats. Supported formats are number, time string (verbose and compact), timer string and Python timedelta.

Input format for time is always determined automatically based on the input. Result format is number by default, but it can be customised using result_format argument.

== Number ==

Time given as a number is interpreted to be seconds. It can be given either as an integer or a float, or it can be a string that can be converted to a number.

To return a time as a number, result_format argument must have value number, which is also the default. Returned number is always a float.

== Time string ==

Time strings are strings in format like 1 minute 42 seconds or 1min 42s. The basic idea of this format is having first a number and then a text specifying what time that number represents. Numbers can be either integers or floating point numbers, the whole format is case and space insensitive, and it is possible to add a minus prefix to specify negative times. The available time specifiers are:

days, day, d
hours, hour, h
minutes, minute, mins, min, m
seconds, second, secs, sec, s
milliseconds, millisecond, millis, ms

When returning a time string, it is possible to select between verbose and compact representations using result_format argument. The verbose format uses long specifiers day, hour, minute, second and millisecond, and adds s at the end when needed. The compact format uses shorter specifiers d, h, min, s and ms, and even drops the space between the number and the specifier.

== Timer string ==

Timer string is a string given in timer like format hh:mm:ss.mil. In this format both hour and millisecond parts are optional, leading and trailing zeros can be left out when they are not meaningful, and negative times can be represented by adding a minus prefix.

To return a time as timer string, result_format argument must be given value timer. Timer strings are by default returned in full hh:mm:ss.mil format, but milliseconds can be excluded using exclude_millis as explained in Millisecond handling section.

== Python timedelta ==

Python’s standard [http://docs.python.org/library/datetime.html#datetime.timedelta|timedelta] objects are also supported both in input and in output. In input they are recognized automatically, and in output it is possible to receive them by giving timedelta value to result_format argument.

= Millisecond handling =

This library handles dates and times internally using the precision of the given input. With timestamp, time string, and timer string result formats seconds are, however, rounded to millisecond accuracy. Milliseconds may also be included even if there would be none.

All keywords returning dates or times have an option to leave milliseconds out by giving a true value to exclude_millis argument. If the argument is given as a string, it is considered true unless it is empty or case-insensitively equal to false, none or no. Other argument types are tested using same [http://docs.python.org/library/stdtypes.html#truth|rules as in Python].

When milliseconds are excluded, seconds in returned dates and times are rounded to the nearest full second. With timestamp and timer string result formats, milliseconds will also be removed from the returned string altogether.

= Programmatic usage =

In addition to be used as normal library, this library is intended to provide a stable API for other libraries to use if they want to support same date and time formats as this library. All the provided keywords are available as functions that can be easily imported:

Additionally helper classes Date and Time can be used directly:

robot.libraries.DateTime.get_current_date(time_zone='local', increment=0, result_format='timestamp', exclude_millis=False)[source]¶

Returns current local or UTC time with an optional increment.

Arguments: - time_zone: Get the current time on this time zone. Currently only

local (default) and UTC are supported.

increment: Optional time increment to add to the returned date in

one of the supported time formats. Can be negative.
result_format: Format of the returned date (see date formats).
exclude_millis: When set to any true value, rounds and drops

milliseconds as explained in millisecond handling.

robot.libraries.DateTime.convert_date(date, result_format='timestamp', exclude_millis=False, date_format=None)[source]¶

Converts between supported date formats.

Arguments: - date: Date in one of the supported date formats. - result_format: Format of the returned date. - exclude_millis: When set to any true value, rounds and drops

milliseconds as explained in millisecond handling.

date_format: Specifies possible custom timestamp format.

robot.libraries.DateTime.convert_time(time, result_format='number', exclude_millis=False)[source]¶

Converts between supported time formats.

Arguments: - time: Time in one of the supported time formats. - result_format: Format of the returned time. - exclude_millis: When set to any true value, rounds and drops

milliseconds as explained in millisecond handling.

robot.libraries.DateTime.subtract_date_from_date(date1, date2, result_format='number', exclude_millis=False, date1_format=None, date2_format=None)[source]¶

Subtracts date from another date and returns time between.

Arguments: - date1: Date to subtract another date from in one of the

supported date formats.

date2: Date that is subtracted in one of the supported

date formats.
result_format: Format of the returned time (see time formats).
exclude_millis: When set to any true value, rounds and drops

milliseconds as explained in millisecond handling.
date1_format: Possible custom timestamp format of date1.
date2_format: Possible custom timestamp format of date2.

Examples:

robot.libraries.DateTime.add_time_to_date(date, time, result_format='timestamp', exclude_millis=False, date_format=None)[source]¶

Adds time to date and returns the resulting date.

Arguments: - date: Date to add time to in one of the supported

date formats.

time: Time that is added in one of the supported

time formats.
result_format: Format of the returned date.
exclude_millis: When set to any true value, rounds and drops

milliseconds as explained in millisecond handling.
date_format: Possible custom timestamp format of date.

robot.libraries.DateTime.subtract_time_from_date(date, time, result_format='timestamp', exclude_millis=False, date_format=None)[source]¶

Subtracts time from date and returns the resulting date.

Arguments: - date: Date to subtract time from in one of the supported

date formats.

time: Time that is subtracted in one of the supported

time formats.
result_format: Format of the returned date.
exclude_millis: When set to any true value, rounds and drops

milliseconds as explained in millisecond handling.
date_format: Possible custom timestamp format of date.

robot.libraries.DateTime.add_time_to_time(time1, time2, result_format='number', exclude_millis=False)[source]¶

Adds time to another time and returns the resulting time.

Arguments: - time1: First time in one of the supported time formats. - time2: Second time in one of the supported time formats. - result_format: Format of the returned time. - exclude_millis: When set to any true value, rounds and drops

milliseconds as explained in millisecond handling.

robot.libraries.DateTime.subtract_time_from_time(time1, time2, result_format='number', exclude_millis=False)[source]¶

Subtracts time from another time and returns the resulting time.

Arguments: - time1: Time to subtract another time from in one of

the supported time formats.

time2: Time to subtract in one of the supported time formats.
result_format: Format of the returned time.
exclude_millis: When set to any true value, rounds and drops

milliseconds as explained in millisecond handling.

robot.libraries.Dialogs module¶

A test library providing dialogs for interacting with users.

Dialogs is Robot Framework’s standard library that provides means for pausing the test execution and getting input from users. The dialogs are slightly different depending on whether tests are run on Python, IronPython or Jython but they provide the same functionality.

Long lines in the provided messages are wrapped automatically. If you want to wrap lines manually, you can add newlines using the \n character sequence.

The library has a known limitation that it cannot be used with timeouts on Python.

robot.libraries.Dialogs.pause_execution(message='Test execution paused. Press OK to continue.')[source]¶

Pauses test execution until user clicks Ok button.

message is the message shown in the dialog.

robot.libraries.Dialogs.execute_manual_step(message, default_error='')[source]¶

Pauses test execution until user sets the keyword status.

User can press either PASS or FAIL button. In the latter case execution fails and an additional dialog is opened for defining the error message.

message is the instruction shown in the initial dialog and default_error is the default value shown in the possible error message dialog.

robot.libraries.Dialogs.get_value_from_user(message, default_value='', hidden=False)[source]¶

Pauses test execution and asks user to input a value.

Value typed by the user, or the possible default value, is returned. Returning an empty value is fine, but pressing Cancel fails the keyword.

message is the instruction shown in the dialog and default_value is the possible default value shown in the input field.

If hidden is given a true value, the value typed by the user is hidden. hidden is considered true if it is a non-empty string not equal to false, none or no, case-insensitively. If it is not a string, its truth value is got directly using same [http://docs.python.org/library/stdtypes.html#truth|rules as in Python].

robot.libraries.Dialogs.get_selection_from_user(message, *values)[source]¶

Pauses test execution and asks user to select a value.

The selected value is returned. Pressing Cancel fails the keyword.

message is the instruction shown in the dialog and values are the options given to the user.

robot.libraries.Dialogs.get_selections_from_user(message, *values)[source]¶

Pauses test execution and asks user to select multiple values.

The selected values are returned as a list. Selecting no values is OK and in that case the returned list is empty. Pressing Cancel fails the keyword.

message is the instruction shown in the dialog and values are the options given to the user.

New in Robot Framework 3.1.

robot.libraries.Easter module¶

robot.libraries.Easter.none_shall_pass(who)[source]¶

robot.libraries.OperatingSystem module¶

class robot.libraries.OperatingSystem.OperatingSystem[source]¶

Bases: object

A test library providing keywords for OS related tasks.

OperatingSystem is Robot Framework’s standard library that enables various operating system related tasks to be performed in the system where Robot Framework is running. It can, among other things, execute commands (e.g. Run), create and remove files and directories (e.g. Create File, Remove Directory), check whether files or directories exists or contain something (e.g. File Should Exist, Directory Should Be Empty) and manipulate environment variables (e.g. Set Environment Variable).

== Table of contents ==

%TOC%

= Path separators =

Because Robot Framework uses the backslash (\) as an escape character in the test data, using a literal backslash requires duplicating it like in c:\\path\\file.txt. That can be inconvenient especially with longer Windows paths, and thus all keywords expecting paths as arguments convert forward slashes to backslashes automatically on Windows. This also means that paths like ${CURDIR}/path/file.txt are operating system independent.

Notice that the automatic path separator conversion does not work if the path is only a part of an argument like with Run and Start Process keywords. In these cases the built-in variable ${/} that contains \ or /, depending on the operating system, can be used instead.

= Pattern matching =

Some keywords allow their arguments to be specified as [http://en.wikipedia.org/wiki/Glob_(programming)|glob patterns] where:

Unless otherwise noted, matching is case-insensitive on case-insensitive operating systems such as Windows.

= Tilde expansion =

Paths beginning with ~ or ~username are expanded to the current or specified user’s home directory, respectively. The resulting path is operating system dependent, but typically e.g. ~/robot is expanded to C:\Users\<user>\robot on Windows and /home/<user>/robot on Unixes.

The ~username form does not work on Jython.

= Boolean arguments =

Some keywords accept arguments that are handled as Boolean values true or false. If such an argument is given as a string, it is considered false if it is an empty string or equal to FALSE, NONE, NO, OFF or 0, case-insensitively. Other strings are considered true regardless their value, and other argument types are tested using the same [http://docs.python.org/library/stdtypes.html#truth|rules as in Python].

True examples:

False examples:

Considering OFF` and 0 false is new in Robot Framework 3.1.

= Example =

ROBOT_LIBRARY_SCOPE = 'GLOBAL'¶

ROBOT_LIBRARY_VERSION = '4.1.2'¶

run(command)[source]¶

Runs the given command in the system and returns the output.

The execution status of the command is not checked by this keyword, and it must be done separately based on the returned output. If the execution return code is needed, either Run And Return RC or Run And Return RC And Output can be used.

The standard error stream is automatically redirected to the standard output stream by adding 2>&1 after the executed command. This automatic redirection is done only when the executed command does not contain additional output redirections. You can thus freely forward the standard error somewhere else, for example, like my_command 2>stderr.txt.

The returned output contains everything written into the standard output or error streams by the command (unless either of them is redirected explicitly). Many commands add an extra newline (\n) after the output to make it easier to read in the console. To ease processing the returned output, this possible trailing newline is stripped by this keyword.

TIP: Run Process keyword provided by the [http://robotframework.org/robotframework/latest/libraries/Process.html| Process library] supports better process configuration and is generally recommended as a replacement for this keyword.

run_and_return_rc(command)[source]¶

Runs the given command in the system and returns the return code.

The return code (RC) is returned as a positive integer in range from 0 to 255 as returned by the executed command. On some operating systems (notable Windows) original return codes can be something else, but this keyword always maps them to the 0-255 range. Since the RC is an integer, it must be checked e.g. with the keyword Should Be Equal As Integers instead of Should Be Equal (both are built-in keywords).

See Run and Run And Return RC And Output if you need to get the output of the executed command.

TIP: Run Process keyword provided by the [http://robotframework.org/robotframework/latest/libraries/Process.html| Process library] supports better process configuration and is generally recommended as a replacement for this keyword.

run_and_return_rc_and_output(command)[source]¶

Runs the given command in the system and returns the RC and output.

The return code (RC) is returned similarly as with Run And Return RC and the output similarly as with Run.

TIP: Run Process keyword provided by the [http://robotframework.org/robotframework/latest/libraries/Process.html| Process library] supports better process configuration and is generally recommended as a replacement for this keyword.

get_file(path, encoding='UTF-8', encoding_errors='strict')[source]¶

Returns the contents of a specified file.

This keyword reads the specified file and returns the contents. Line breaks in content are converted to platform independent form. See also Get Binary File.

encoding defines the encoding of the file. The default value is UTF-8, which means that UTF-8 and ASCII encoded files are read correctly. In addition to the encodings supported by the underlying Python implementation, the following special encoding values can be used:

SYSTEM: Use the default system encoding.
CONSOLE: Use the console encoding. Outside Windows this is same as the system encoding.

encoding_errors argument controls what to do if decoding some bytes fails. All values accepted by decode method in Python are valid, but in practice the following values are most useful:

strict: Fail if characters cannot be decoded (default).
ignore: Ignore characters that cannot be decoded.
replace: Replace characters that cannot be decoded with a replacement character.

get_binary_file(path)[source]¶

Returns the contents of a specified file.

This keyword reads the specified file and returns the contents as is. See also Get File.

grep_file(path, pattern, encoding='UTF-8', encoding_errors='strict')[source]¶

Returns the lines of the specified file that match the pattern.

This keyword reads a file from the file system using the defined path, encoding and encoding_errors similarly as Get File. A difference is that only the lines that match the given pattern are returned. Lines are returned as a single string catenated back together with newlines and the number of matched lines is automatically logged. Possible trailing newline is never returned.

A line matches if it contains the pattern anywhere in it and it does not need to match the pattern fully. The pattern matching syntax is explained in introduction, and in this case matching is case-sensitive.

If more complex pattern matching is needed, it is possible to use Get File in combination with String library keywords like Get Lines Matching Regexp.

This keyword supports special SYSTEM and CONSOLE encodings that Get File supports only with Robot Framework 4.0 and newer. When using Python 3, it is possible to use ${NONE} instead of SYSTEM with earlier versions.

log_file(path, encoding='UTF-8', encoding_errors='strict')[source]¶

Wrapper for Get File that also logs the returned file.

The file is logged with the INFO level. If you want something else, just use Get File and the built-in keyword Log with the desired level.

See Get File for more information about encoding and encoding_errors arguments.

should_exist(path, msg=None)[source]¶

Fails unless the given path (file or directory) exists.

The path can be given as an exact path or as a glob pattern. The pattern matching syntax is explained in introduction. The default error message can be overridden with the msg argument.

should_not_exist(path, msg=None)[source]¶

Fails if the given path (file or directory) exists.

The path can be given as an exact path or as a glob pattern. The pattern matching syntax is explained in introduction. The default error message can be overridden with the msg argument.

file_should_exist(path, msg=None)[source]¶

Fails unless the given path points to an existing file.

The path can be given as an exact path or as a glob pattern. The pattern matching syntax is explained in introduction. The default error message can be overridden with the msg argument.

file_should_not_exist(path, msg=None)[source]¶

Fails if the given path points to an existing file.

The path can be given as an exact path or as a glob pattern. The pattern matching syntax is explained in introduction. The default error message can be overridden with the msg argument.

directory_should_exist(path, msg=None)[source]¶

Fails unless the given path points to an existing directory.

The path can be given as an exact path or as a glob pattern. The pattern matching syntax is explained in introduction. The default error message can be overridden with the msg argument.

directory_should_not_exist(path, msg=None)[source]¶

Fails if the given path points to an existing file.

The path can be given as an exact path or as a glob pattern. The pattern matching syntax is explained in introduction. The default error message can be overridden with the msg argument.

wait_until_removed(path, timeout='1 minute')[source]¶

Waits until the given file or directory is removed.

The path can be given as an exact path or as a glob pattern. The pattern matching syntax is explained in introduction. If the path is a pattern, the keyword waits until all matching items are removed.

The optional timeout can be used to control the maximum time of waiting. The timeout is given as a timeout string, e.g. in a format 15 seconds, 1min 10s or just 10. The time string format is described in an appendix of Robot Framework User Guide.

If the timeout is negative, the keyword is never timed-out. The keyword returns immediately, if the path does not exist in the first place.

wait_until_created(path, timeout='1 minute')[source]¶

Waits until the given file or directory is created.

The path can be given as an exact path or as a glob pattern. The pattern matching syntax is explained in introduction. If the path is a pattern, the keyword returns when an item matching it is created.

The optional timeout can be used to control the maximum time of waiting. The timeout is given as a timeout string, e.g. in a format 15 seconds, 1min 10s or just 10. The time string format is described in an appendix of Robot Framework User Guide.

If the timeout is negative, the keyword is never timed-out. The keyword returns immediately, if the path already exists.

directory_should_be_empty(path, msg=None)[source]¶

Fails unless the specified directory is empty.

The default error message can be overridden with the msg argument.

directory_should_not_be_empty(path, msg=None)[source]¶

Fails if the specified directory is empty.

The default error message can be overridden with the msg argument.

file_should_be_empty(path, msg=None)[source]¶

Fails unless the specified file is empty.

The default error message can be overridden with the msg argument.

file_should_not_be_empty(path, msg=None)[source]¶

Fails if the specified directory is empty.

The default error message can be overridden with the msg argument.

create_file(path, content='', encoding='UTF-8')[source]¶

Creates a file with the given content and encoding.

If the directory where the file is created does not exist, it is automatically created along with possible missing intermediate directories. Possible existing file is overwritten.

On Windows newline characters (\n) in content are automatically converted to Windows native newline sequence (\r\n).

See Get File for more information about possible encoding values, including special values SYSTEM and CONSOLE.

Use Append To File if you want to append to an existing file and Create Binary File if you need to write bytes without encoding. File Should Not Exist can be used to avoid overwriting existing files.

Automatically converting \n to \r\n on Windows is new in Robot Framework 3.1.

create_binary_file(path, content)[source]¶

Creates a binary file with the given content.

If content is given as a Unicode string, it is first converted to bytes character by character. All characters with ordinal below 256 can be used and are converted to bytes with same values. Using characters with higher ordinal is an error.

Byte strings, and possible other types, are written to the file as is.

If the directory for the file does not exist, it is created, along with missing intermediate directories.

Use Create File if you want to create a text file using a certain encoding. File Should Not Exist can be used to avoid overwriting existing files.

append_to_file(path, content, encoding='UTF-8')[source]¶

Appends the given content to the specified file.

If the file exists, the given text is written to its end. If the file does not exist, it is created.

Other than not overwriting possible existing files, this keyword works exactly like Create File. See its documentation for more details about the usage.

Note that special encodings SYSTEM and CONSOLE only work with this keyword starting from Robot Framework 3.1.2.

remove_file(path)[source]¶

Removes a file with the given path.

Passes if the file does not exist, but fails if the path does not point to a regular file (e.g. it points to a directory).

The path can be given as an exact path or as a glob pattern. The pattern matching syntax is explained in introduction. If the path is a pattern, all files matching it are removed.

remove_files(*paths)[source]¶: Uses Remove File to remove multiple files one-by-one.

empty_directory(path)[source]¶

Deletes all the content from the given directory.

Deletes both files and sub-directories, but the specified directory itself if not removed. Use Remove Directory if you want to remove the whole directory.

create_directory(path)[source]¶

Creates the specified directory.

Also possible intermediate directories are created. Passes if the directory already exists, but fails if the path exists and is not a directory.

remove_directory(path, recursive=False)[source]¶

Removes the directory pointed to by the given path.

If the second argument recursive is given a true value (see Boolean arguments), the directory is removed recursively. Otherwise removing fails if the directory is not empty.

If the directory pointed to by the path does not exist, the keyword passes, but it fails, if the path points to a file.

copy_file(source, destination)[source]¶

Copies the source file into the destination.

Source must be a path to an existing file or a glob pattern (see Pattern matching) that matches exactly one file. How the destination is interpreted is explained below.

1) If the destination is an existing file, the source file is copied over it.

2) If the destination is an existing directory, the source file is copied into it. A possible file with the same name as the source is overwritten.

3) If the destination does not exist and it ends with a path separator (/ or \), it is considered a directory. That directory is created and a source file copied into it. Possible missing intermediate directories are also created.

4) If the destination does not exist and it does not end with a path separator, it is considered a file. If the path to the file does not exist, it is created.

The resulting destination path is returned.

See also Copy Files, Move File, and Move Files.

move_file(source, destination)[source]¶

Moves the source file into the destination.

Arguments have exactly same semantics as with Copy File keyword. Destination file path is returned.

If the source and destination are on the same filesystem, rename operation is used. Otherwise file is copied to the destination filesystem and then removed from the original filesystem.

See also Move Files, Copy File, and Copy Files.

copy_files(*sources_and_destination)[source]¶

Copies specified files to the target directory.

Source files can be given as exact paths and as glob patterns (see Pattern matching). At least one source must be given, but it is not an error if it is a pattern that does not match anything.

Last argument must be the destination directory. If the destination does not exist, it will be created.

See also Copy File, Move File, and Move Files.

move_files(*sources_and_destination)[source]¶

Moves specified files to the target directory.

Arguments have exactly same semantics as with Copy Files keyword.

See also Move File, Copy File, and Copy Files.

copy_directory(source, destination)[source]¶

Copies the source directory into the destination.

If the destination exists, the source is copied under it. Otherwise the destination directory and the possible missing intermediate directories are created.

move_directory(source, destination)[source]¶

Moves the source directory into a destination.

Uses Copy Directory keyword internally, and source and destination arguments have exactly same semantics as with that keyword.

get_environment_variable(name, default=None)[source]¶

Returns the value of an environment variable with the given name.

If no such environment variable is set, returns the default value, if given. Otherwise fails the test case.

Returned variables are automatically decoded to Unicode using the system encoding.

Note that you can also access environment variables directly using the variable syntax %{ENV_VAR_NAME}.

set_environment_variable(name, value)[source]¶

Sets an environment variable to a specified value.

Values are converted to strings automatically. Set variables are automatically encoded using the system encoding.

append_to_environment_variable(name, *values, **config)[source]¶

Appends given values to environment variable name.

If the environment variable already exists, values are added after it, and otherwise a new environment variable is created.

Values are, by default, joined together using the operating system path separator (; on Windows, : elsewhere). This can be changed by giving a separator after the values like separator=value. No other configuration parameters are accepted.

remove_environment_variable(*names)[source]¶

Deletes the specified environment variable.

Does nothing if the environment variable is not set.

It is possible to remove multiple variables by passing them to this keyword as separate arguments.

environment_variable_should_be_set(name, msg=None)[source]¶

Fails if the specified environment variable is not set.

The default error message can be overridden with the msg argument.

environment_variable_should_not_be_set(name, msg=None)[source]¶

Fails if the specified environment variable is set.

The default error message can be overridden with the msg argument.

get_environment_variables()[source]¶

Returns currently available environment variables as a dictionary.

Both keys and values are decoded to Unicode using the system encoding. Altering the returned dictionary has no effect on the actual environment variables.

log_environment_variables(level='INFO')[source]¶

Logs all environment variables using the given log level.

Environment variables are also returned the same way as with Get Environment Variables keyword.

join_path(base, *parts)[source]¶

Joins the given path part(s) to the given base path.

The path separator (/ or \) is inserted when needed and the possible absolute paths handled as expected. The resulted path is also normalized.

${path} = ‘my/path’
${p2} = ‘my/path’
${p3} = ‘my/path/my/file.txt’
${p4} = ‘/path’
${p5} = ‘/my/path2’

join_paths(base, *paths)[source]¶

Joins given paths with base and returns resulted paths.

See Join Path for more information.

@{p1} = [‘base/example’, ‘base/other’]
@{p2} = [‘/example’, ‘/my/base/other’]
@{p3} = [‘my/base/example/path’, ‘my/base/other’, ‘my/base/one/more’]

normalize_path(path, case_normalize=False)[source]¶

Normalizes the given path.

Collapses redundant separators and up-level references.
Converts / to \ on Windows.
Replaces initial ~ or ~user by that user’s home directory. The latter is not supported on Jython.
If case_normalize is given a true value (see Boolean arguments) on Windows, converts the path to all lowercase. New in Robot Framework 3.1.
${path1} = ‘abc’
${path2} = ‘def’
${path3} = ‘abc/def/ghi’
${path4} = ‘/home/robot/stuff’

On Windows result would use \ instead of / and home directory would be different.

split_path(path)[source]¶

Splits the given path from the last path separator (/ or \).

The given path is first normalized (e.g. a possible trailing path separator is removed, special directories .. and . removed). The parts that are split are returned as separate components.

${path1} = ‘abc’ & ${dir} = ‘def’
${path2} = ‘abc/def’ & ${file} = ‘ghi.txt’
${path3} = ‘def’ & ${d2} = ‘ghi’

split_extension(path)[source]¶

Splits the extension from the given path.

The given path is first normalized (e.g. possible trailing path separators removed, special directories .. and . removed). The base path and extension are returned as separate components so that the dot used as an extension separator is removed. If the path contains no extension, an empty string is returned for it. Possible leading and trailing dots in the file name are never considered to be extension separators.

${path} = ‘file’ & ${ext} = ‘extension’
${p2} = ‘path/file’ & ${e2} = ‘ext’
${p3} = ‘path/file’ & ${e3} = ‘’
${p4} = ‘p2/file’ & ${e4} = ‘ext’
${p5} = ‘path/.file’ & ${e5} = ‘ext’
${p6} = ‘path/.file’ & ${e6} = ‘’

get_modified_time(path, format='timestamp')[source]¶

Returns the last modification time of a file or directory.

How time is returned is determined based on the given format string as follows. Note that all checks are case-insensitive. Returned time is also automatically logged.

If format contains the word epoch, the time is returned in seconds after the UNIX epoch. The return value is always an integer.
If format contains any of the words year, month, day, hour, min or sec, only the selected parts are returned. The order of the returned parts is always the one in the previous sentence and the order of the words in format is not significant. The parts are returned as zero-padded strings (e.g. May -> 05).
Otherwise, and by default, the time is returned as a timestamp string in the format 2006-02-24 15:08:31.

2006-03-29 15:06:21): - ${time} = ‘2006-03-29 15:06:21’ - ${secs} = 1143637581 - ${year} = ‘2006’ - ${y} = ‘2006’ & ${d} = ‘29’ - @{time} = [‘2006’, ‘03’, ‘29’, ‘15’, ‘06’, ‘21’]

set_modified_time(path, mtime)[source]¶

Sets the file modification and access times.

Changes the modification and access times of the given file to the value determined by mtime. The time can be given in different formats described below. Note that all checks involving strings are case-insensitive. Modified time can only be set to regular files.

If mtime is a number, or a string that can be converted to a number, it is interpreted as seconds since the UNIX epoch (1970-01-01 00:00:00 UTC). This documentation was originally written about 1177654467 seconds after the epoch.
If mtime is a timestamp, that time will be used. Valid timestamp formats are YYYY-MM-DD hh:mm:ss and YYYYMMDD hhmmss.
If mtime is equal to NOW, the current local time is used.
If mtime is equal to UTC, the current time in [http://en.wikipedia.org/wiki/Coordinated_Universal_Time|UTC] is used.
If mtime is in the format like NOW - 1 day or UTC + 1 hour 30 min, the current local/UTC time plus/minus the time specified with the time string is used. The time string format is described in an appendix of Robot Framework User Guide.

get_file_size(path)[source]¶: Returns and logs file size as an integer in bytes.

list_directory(path, pattern=None, absolute=False)[source]¶

Returns and logs items in a directory, optionally filtered with pattern.

File and directory names are returned in case-sensitive alphabetical order, e.g. ['A Name', 'Second', 'a lower case name', 'one more']. Implicit directories . and .. are not returned. The returned items are automatically logged.

File and directory names are returned relative to the given path (e.g. 'file.txt') by default. If you want them be returned in absolute format (e.g. '/home/robot/file.txt'), give the absolute argument a true value (see Boolean arguments).

If pattern is given, only items matching it are returned. The pattern matching syntax is explained in introduction, and in this case matching is case-sensitive.

list_files_in_directory(path, pattern=None, absolute=False)[source]¶: Wrapper for List Directory that returns only files.

list_directories_in_directory(path, pattern=None, absolute=False)[source]¶: Wrapper for List Directory that returns only directories.

count_items_in_directory(path, pattern=None)[source]¶

Returns and logs the number of all items in the given directory.

The argument pattern has the same semantics as with List Directory keyword. The count is returned as an integer, so it must be checked e.g. with the built-in keyword Should Be Equal As Integers.

count_files_in_directory(path, pattern=None)[source]¶: Wrapper for Count Items In Directory returning only file count.

count_directories_in_directory(path, pattern=None)[source]¶: Wrapper for Count Items In Directory returning only directory count.

touch(path)[source]¶

Emulates the UNIX touch command.

Creates a file, if it does not exist. Otherwise changes its access and modification times to the current time.

Fails if used with the directories or the parent directory of the given file does not exist.

robot.libraries.Process module¶

class robot.libraries.Process.Process[source]¶

Bases: object

Robot Framework test library for running processes.

This library utilizes Python’s [http://docs.python.org/library/subprocess.html|subprocess] module and its [http://docs.python.org/library/subprocess.html#popen-constructor|Popen] class.

The library has following main usages:

Running processes in system and waiting for their completion using Run Process keyword.
Starting processes on background using Start Process.
Waiting started process to complete using Wait For Process or stopping them with Terminate Process or Terminate All Processes.

== Table of contents ==

%TOC%

= Specifying command and arguments =

Both Run Process and Start Process accept the command to execute and all arguments passed to the command as separate arguments. This makes usage convenient and also allows these keywords to automatically escape possible spaces and other special characters in commands and arguments. Notice that if a command accepts options that themselves accept values, these options and their values must be given as separate arguments.

When running processes in shell, it is also possible to give the whole command to execute as a single string. The command can then contain multiple commands to be run together. When using this approach, the caller is responsible on escaping.

Possible non-string arguments are converted to strings automatically.

= Process configuration =

Run Process and Start Process keywords can be configured using optional **configuration keyword arguments. Configuration arguments must be given after other arguments passed to these keywords and must use syntax like name=value. Available configuration arguments are listed below and discussed further in sections afterwards.

Note that because **configuration is passed using name=value syntax, possible equal signs in other arguments passed to Run Process and Start Process must be escaped with a backslash like name\=value. See Run Process for an example.

== Running processes in shell ==

The shell argument specifies whether to run the process in a shell or not. By default shell is not used, which means that shell specific commands, like copy and dir on Windows, are not available. You can, however, run shell scripts and batch files without using a shell.

Giving the shell argument any non-false value, such as shell=True, changes the program to be executed in a shell. It allows using the shell capabilities, but can also make the process invocation operating system dependent. Having a shell between the actually started process and this library can also interfere communication with the process such as stopping it and reading its outputs. Because of these problems, it is recommended to use the shell only when absolutely necessary.

When using a shell it is possible to give the whole command to execute as a single string. See Specifying command and arguments section for examples and more details in general.

== Current working directory ==

By default the child process will be executed in the same directory as the parent process, the process running tests, is executed. This can be changed by giving an alternative location using the cwd argument. Forward slashes in the given path are automatically converted to backslashes on Windows.

Standard output and error streams, when redirected to files, are also relative to the current working directory possibly set using the cwd argument.

== Environment variables ==

By default the child process will get a copy of the parent process’s environment variables. The env argument can be used to give the child a custom environment as a Python dictionary. If there is a need to specify only certain environment variable, it is possible to use the env:<name>=<value> format to set or override only that named variables. It is also possible to use these two approaches together.

== Standard output and error streams ==

By default processes are run so that their standard output and standard error streams are kept in the memory. This works fine normally, but if there is a lot of output, the output buffers may get full and the program can hang. Additionally on Jython, everything written to these in-memory buffers can be lost if the process is terminated.

To avoid the above mentioned problems, it is possible to use stdout and stderr arguments to specify files on the file system where to redirect the outputs. This can also be useful if other processes or other keywords need to read or manipulate the outputs somehow.

Given stdout and stderr paths are relative to the current working directory. Forward slashes in the given paths are automatically converted to backslashes on Windows.

As a special feature, it is possible to redirect the standard error to the standard output by using stderr=STDOUT.

Regardless are outputs redirected to files or not, they are accessible through the result object returned when the process ends. Commands are expected to write outputs using the console encoding, but output encoding can be configured using the output_encoding argument if needed.

If you are not interested in outputs at all, you can explicitly ignore them by using a special value DEVNULL both with stdout and stderr. For example, stdout=DEVNULL is the same as redirecting output on console with > /dev/null on UNIX-like operating systems or > NUL on Windows. This way the process will not hang even if there would be a lot of output, but naturally output is not available after execution either.

Support for the special value DEVNULL is new in Robot Framework 3.2.

Note that the created output files are not automatically removed after the test run. The user is responsible to remove them if needed.

== Standard input stream ==

The stdin argument makes it possible to pass information to the standard input stream of the started process. How its value is interpreted is explained in the table below.

Values PIPE and NONE are internally mapped directly to subprocess.PIPE and None, respectively, when calling [https://docs.python.org/3/library/subprocess.html#subprocess.Popen|subprocess.Popen]. The default behavior may change from PIPE to NONE in future releases. If you depend on the PIPE behavior, it is a good idea to use it explicitly.

The support to configure stdin is new in Robot Framework 4.1.2.

== Output encoding ==

Executed commands are, by default, expected to write outputs to the standard output and error streams using the encoding used by the system console. If the command uses some other encoding, that can be configured using the output_encoding argument. This is especially useful on Windows where the console uses a different encoding than rest of the system, and many commands use the general system encoding instead of the console encoding.

The value used with the output_encoding argument must be a valid encoding and must match the encoding actually used by the command. As a convenience, it is possible to use strings CONSOLE and SYSTEM to specify that the console or system encoding is used, respectively. If produced outputs use different encoding then configured, values got through the result object will be invalid.

== Alias ==

A custom name given to the process that can be used when selecting the active process.

= Active process =

The test library keeps record which of the started processes is currently active. By default it is latest process started with Start Process, but Switch Process can be used to select a different one. Using Run Process does not affect the active process.

The keywords that operate on started processes will use the active process by default, but it is possible to explicitly select a different process using the handle argument. The handle can be the identifier returned by Start Process or an alias explicitly given to Start Process or Run Process.

= Result object =

Run Process, Wait For Process and Terminate Process keywords return a result object that contains information about the process execution as its attributes. The same result object, or some of its attributes, can also be get using Get Process Result keyword. Attributes available in the object are documented in the table below.

= Boolean arguments =

Some keywords accept arguments that are handled as Boolean values true or false. If such an argument is given as a string, it is considered false if it is an empty string or equal to FALSE, NONE, NO, OFF or 0, case-insensitively. Other strings are considered true regardless their value, and other argument types are tested using the same [http://docs.python.org/library/stdtypes.html#truth|rules as in Python].

True examples:

False examples:

Considering OFF and 0 false is new in Robot Framework 3.1.

= Example =

ROBOT_LIBRARY_SCOPE = 'GLOBAL'¶

ROBOT_LIBRARY_VERSION = '4.1.2'¶

TERMINATE_TIMEOUT = 30¶

KILL_TIMEOUT = 10¶

run_process(command, *arguments, **configuration)[source]¶

Runs a process and waits for it to complete.

command and *arguments specify the command to execute and arguments passed to it. See Specifying command and arguments for more details.

**configuration contains additional configuration related to starting processes and waiting for them to finish. See Process configuration for more details about configuration related to starting processes. Configuration related to waiting for processes consists of timeout and on_timeout arguments that have same semantics as with Wait For Process keyword. By default there is no timeout, and if timeout is defined the default action on timeout is terminate.

Returns a result object containing information about the execution.

Note that possible equal signs in *arguments must be escaped with a backslash (e.g. name\=value) to avoid them to be passed in as **configuration.

This keyword does not change the active process.

start_process(command, *arguments, **configuration)[source]¶

Starts a new process on background.

See Specifying command and arguments and Process configuration for more information about the arguments, and Run Process keyword for related examples.

Makes the started process new active process. Returns an identifier that can be used as a handle to activate the started process if needed.

Processes are started so that they create a new process group. This allows sending signals to and terminating also possible child processes. This is not supported on Jython.

is_process_running(handle=None)[source]¶

Checks is the process running or not.

If handle is not given, uses the current active process.

Returns True if the process is still running and False otherwise.

process_should_be_running(handle=None, error_message='Process is not running.')[source]¶

Verifies that the process is running.

If handle is not given, uses the current active process.

Fails if the process has stopped.

process_should_be_stopped(handle=None, error_message='Process is running.')[source]¶

Verifies that the process is not running.

If handle is not given, uses the current active process.

Fails if the process is still running.

wait_for_process(handle=None, timeout=None, on_timeout='continue')[source]¶

Waits for the process to complete or to reach the given timeout.

The process to wait for must have been started earlier with Start Process. If handle is not given, uses the current active process.

timeout defines the maximum time to wait for the process. It can be given in [http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#time-format| various time formats] supported by Robot Framework, for example, 42, 42 s, or 1 minute 30 seconds. The timeout is ignored if it is Python None (default), string NONE (case-insensitively), zero, or negative.

on_timeout defines what to do if the timeout occurs. Possible values and corresponding actions are explained in the table below. Notice that reaching the timeout never fails the test.

See Terminate Process keyword for more details how processes are terminated and killed.

If the process ends before the timeout or it is terminated or killed, this keyword returns a result object containing information about the execution. If the process is left running, Python None is returned instead.

Ignoring timeout if it is string NONE, zero, or negative is new in Robot Framework 3.2.

terminate_process(handle=None, kill=False)[source]¶

Stops the process gracefully or forcefully.

If handle is not given, uses the current active process.

By default first tries to stop the process gracefully. If the process does not stop in 30 seconds, or kill argument is given a true value, (see Boolean arguments) kills the process forcefully. Stops also all the child processes of the originally started process.

Waits for the process to stop after terminating it. Returns a result object containing information about the execution similarly as Wait For Process.

On Unix-like machines graceful termination is done using TERM (15) signal and killing using KILL (9). Use Send Signal To Process instead if you just want to send either of these signals without waiting for the process to stop.

On Windows graceful termination is done using CTRL_BREAK_EVENT event and killing using Win32 API function TerminateProcess().

Limitations: - Graceful termination is not supported on Windows when using Jython.

Process is killed instead.

Stopping the whole process group is not supported when using Jython.
On Windows forceful kill only stops the main process, not possible child processes.

terminate_all_processes(kill=False)[source]¶

Terminates all still running processes started by this library.

This keyword can be used in suite teardown or elsewhere to make sure that all processes are stopped,

By default tries to terminate processes gracefully, but can be configured to forcefully kill them immediately. See Terminate Process that this keyword uses internally for more details.

send_signal_to_process(signal, handle=None, group=False)[source]¶

Sends the given signal to the specified process.

If handle is not given, uses the current active process.

Signal can be specified either as an integer as a signal name. In the latter case it is possible to give the name both with or without SIG prefix, but names are case-sensitive. For example, all the examples below send signal INT (2):

This keyword is only supported on Unix-like machines, not on Windows. What signals are supported depends on the system. For a list of existing signals on your system, see the Unix man pages related to signal handling (typically man signal or man 7 signal).

By default sends the signal only to the parent process, not to possible child processes started by it. Notice that when running processes in shell, the shell is the parent process and it depends on the system does the shell propagate the signal to the actual started process.

To send the signal to the whole process group, group argument can be set to any true value (see Boolean arguments). This is not supported by Jython, however.

get_process_id(handle=None)[source]¶

Returns the process ID (pid) of the process as an integer.

If handle is not given, uses the current active process.

Notice that the pid is not the same as the handle returned by Start Process that is used internally by this library.

get_process_object(handle=None)[source]¶

Return the underlying subprocess.Popen object.

If handle is not given, uses the current active process.

get_process_result(handle=None, rc=False, stdout=False, stderr=False, stdout_path=False, stderr_path=False)[source]¶

Returns the specified result object or some of its attributes.

The given handle specifies the process whose results should be returned. If no handle is given, results of the current active process are returned. In either case, the process must have been finishes before this keyword can be used. In practice this means that processes started with Start Process must be finished either with Wait For Process or Terminate Process before using this keyword.

If no other arguments than the optional handle are given, a whole result object is returned. If one or more of the other arguments are given any true value, only the specified attributes of the result object are returned. These attributes are always returned in the same order as arguments are specified in the keyword signature. See Boolean arguments section for more details about true and false values.

Although getting results of a previously executed process can be handy in general, the main use case for this keyword is returning results over the remote library interface. The remote interface does not support returning the whole result object, but individual attributes can be returned without problems.

switch_process(handle)[source]¶

Makes the specified process the current active process.

The handle can be an identifier returned by Start Process or the alias given to it explicitly.

split_command_line(args, escaping=False)[source]¶

Splits command line string into a list of arguments.

String is split from spaces, but argument surrounded in quotes may contain spaces in them. If escaping is given a true value, then backslash is treated as an escape character. It can escape unquoted spaces, quotes inside quotes, and so on, but it also requires using double backslashes when using Windows paths.

join_command_line(*args)[source]¶

Joins arguments into one command line string.

In resulting command line string arguments are delimited with a space, arguments containing spaces are surrounded with quotes, and possible quotes are escaped with a backslash.

If this keyword is given only one argument and that is a list like object, then the values of that list are joined instead.

class robot.libraries.Process.ExecutionResult(process, stdout, stderr, stdin=None, rc=None, output_encoding=None)[source]¶

Bases: object

stdout¶

stderr¶

close_streams()[source]¶

class robot.libraries.Process.ProcessConfiguration(cwd=None, shell=False, stdout=None, stderr=None, stdin='PIPE', output_encoding='CONSOLE', alias=None, env=None, **rest)[source]¶

Bases: object

get_command(command, arguments)[source]¶

popen_config¶

result_config¶

robot.libraries.Remote module¶

class robot.libraries.Remote.Remote(uri='http://127.0.0.1:8270', timeout=None)[source]¶

Bases: object

Connects to a remote server at uri.

Optional timeout can be used to specify a timeout to wait when initially connecting to the server and if a connection accidentally closes. Timeout can be given as seconds (e.g. 60) or using Robot Framework time format (e.g. 60s, 2 minutes 10 seconds).

The default timeout is typically several minutes, but it depends on the operating system and its configuration. Notice that setting a timeout that is shorter than keyword execution time will interrupt the keyword.

Timeouts do not work with IronPython.

ROBOT_LIBRARY_SCOPE = 'TEST SUITE'¶

get_keyword_names()[source]¶

get_keyword_arguments(name)[source]¶

get_keyword_types(name)[source]¶

get_keyword_tags(name)[source]¶

get_keyword_documentation(name)[source]¶

run_keyword(name, args, kwargs)[source]¶

class robot.libraries.Remote.ArgumentCoercer[source]¶

Bases: object

binary = <_sre.SRE_Pattern object>¶

non_ascii = <_sre.SRE_Pattern object>¶

coerce(argument)[source]¶

class robot.libraries.Remote.RemoteResult(result)[source]¶: Bases: object

class robot.libraries.Remote.XmlRpcRemoteClient(uri, timeout=None)[source]¶

Bases: object

get_library_information()[source]¶

get_keyword_names()[source]¶

get_keyword_arguments(name)[source]¶

get_keyword_types(name)[source]¶

get_keyword_tags(name)[source]¶

get_keyword_documentation(name)[source]¶

run_keyword(name, args, kwargs)[source]¶

class robot.libraries.Remote.TimeoutHTTPTransport(use_datetime=0, timeout=None)[source]¶

Bases: xmlrpclib.Transport

make_connection(host)[source]¶

accept_gzip_encoding = True¶

close()¶

encode_threshold = None¶

get_host_info(host)¶

getparser()¶

parse_response(response)¶

request(host, handler, request_body, verbose=0)¶

send_content(connection, request_body)¶

send_host(connection, host)¶

send_request(connection, handler, request_body)¶

send_user_agent(connection)¶

single_request(host, handler, request_body, verbose=0)¶

user_agent = 'xmlrpclib.py/1.0.1 (by www.pythonware.com)'¶

class robot.libraries.Remote.TimeoutHTTPSTransport(use_datetime=0, timeout=None)[source]¶

Bases: robot.libraries.Remote.TimeoutHTTPTransport

accept_gzip_encoding = True¶

close()¶

encode_threshold = None¶

get_host_info(host)¶

getparser()¶

make_connection(host)¶

parse_response(response)¶

request(host, handler, request_body, verbose=0)¶

send_content(connection, request_body)¶

send_host(connection, host)¶

send_request(connection, handler, request_body)¶

send_user_agent(connection)¶

single_request(host, handler, request_body, verbose=0)¶

user_agent = 'xmlrpclib.py/1.0.1 (by www.pythonware.com)'¶

robot.libraries.Reserved module¶

class robot.libraries.Reserved.Reserved[source]¶

Bases: object

ROBOT_LIBRARY_SCOPE = 'GLOBAL'¶

robot.libraries.Screenshot module¶

class robot.libraries.Screenshot.Screenshot(screenshot_directory=None, screenshot_module=None)[source]¶

Bases: object

Test library for taking screenshots on the machine where tests are run.

Notice that successfully taking screenshots requires tests to be run with a physical or virtual display.

== Table of contents ==

%TOC%

= Using with Python =

How screenshots are taken when using Python depends on the operating system. On OSX screenshots are taken using the built-in screencapture utility. On other operating systems you need to have one of the following tools or Python modules installed. You can specify the tool/module to use when importing the library. If no tool or module is specified, the first one found will be used.

wxPython :: http://wxpython.org :: Required also by RIDE so many Robot Framework users already have this module installed.
PyGTK :: http://pygtk.org :: This module is available by default on most Linux distributions.
Pillow :: http://python-pillow.github.io :: Only works on Windows. Also the original PIL package is supported.
Scrot :: http://en.wikipedia.org/wiki/Scrot :: Not used on Windows. Install with apt-get install scrot or similar.

= Using with Jython and IronPython =

With Jython and IronPython this library uses APIs provided by JVM and .NET platforms, respectively. These APIs are always available and thus no external modules are needed.

= Where screenshots are saved =

By default screenshots are saved into the same directory where the Robot Framework log file is written. If no log is created, screenshots are saved into the directory where the XML output file is written.

It is possible to specify a custom location for screenshots using screenshot_directory argument when importing the library and using Set Screenshot Directory keyword during execution. It is also possible to save screenshots using an absolute path.

= ScreenCapLibrary =

[https://github.com/mihaiparvu/ScreenCapLibrary|ScreenCapLibrary] is an external Robot Framework library that can be used as an alternative, which additionally provides support for multiple formats, adjusting the quality, using GIFs and video capturing.

Configure where screenshots are saved.

If screenshot_directory is not given, screenshots are saved into same directory as the log file. The directory can also be set using Set Screenshot Directory keyword.

screenshot_module specifies the module or tool to use when using this library on Python outside OSX. Possible values are wxPython, PyGTK, PIL and scrot, case-insensitively. If no value is given, the first module/tool found is used in that order. See Using with Python for more information.

ROBOT_LIBRARY_SCOPE = 'TEST SUITE'¶

ROBOT_LIBRARY_VERSION = '4.1.2'¶

set_screenshot_directory(path)[source]¶

Sets the directory where screenshots are saved.

It is possible to use / as a path separator in all operating systems. Path to the old directory is returned.

The directory can also be set in importing.

take_screenshot(name='screenshot', width='800px')[source]¶

Takes a screenshot in JPEG format and embeds it into the log file.

Name of the file where the screenshot is stored is derived from the given name. If the name ends with extension .jpg or .jpeg, the screenshot will be stored with that exact name. Otherwise a unique name is created by adding an underscore, a running index and an extension to the name.

The name will be interpreted to be relative to the directory where the log file is written. It is also possible to use absolute paths. Using / as a path separator works in all operating systems.

width specifies the size of the screenshot in the log file.

The path where the screenshot is saved is returned.

take_screenshot_without_embedding(name='screenshot')[source]¶

Takes a screenshot and links it from the log file.

This keyword is otherwise identical to Take Screenshot but the saved screenshot is not embedded into the log file. The screenshot is linked so it is nevertheless easily available.

class robot.libraries.Screenshot.ScreenshotTaker(module_name=None)[source]¶

Bases: object

test(path=None)[source]¶

robot.libraries.String module¶

class robot.libraries.String.String[source]¶

Bases: object

A test library for string manipulation and verification.

String is Robot Framework’s standard library for manipulating strings (e.g. Replace String Using Regexp, Split To Lines) and verifying their contents (e.g. Should Be String).

Following keywords from BuiltIn library can also be used with strings:

Catenate
Get Length
Length Should Be
Should (Not) Be Empty
Should (Not) Be Equal (As Strings/Integers/Numbers)
Should (Not) Match (Regexp)
Should (Not) Contain
Should (Not) Start With
Should (Not) End With
Convert To String
Convert To Bytes

ROBOT_LIBRARY_SCOPE = 'GLOBAL'¶

ROBOT_LIBRARY_VERSION = '4.1.2'¶

convert_to_lower_case(string)[source]¶

Converts string to lower case.

Uses Python’s standard [https://docs.python.org/library/stdtypes.html#str.lower|lower()] method.

convert_to_upper_case(string)[source]¶

Converts string to upper case.

Uses Python’s standard [https://docs.python.org/library/stdtypes.html#str.upper|upper()] method.

convert_to_title_case(string, exclude=None)[source]¶

Converts string to title case.

Uses the following algorithm:

Split the string to words from whitespace characters (spaces, newlines, etc.).
Exclude words that are not all lower case. This preserves, for example, “OK” and “iPhone”.
Exclude also words listed in the optional exclude argument.
Title case the first alphabetical character of each word that has not been excluded.
Join all words together so that original whitespace is preserved.

Explicitly excluded words can be given as a list or as a string with words separated by a comma and an optional space. Excluded words are actually considered to be regular expression patterns, so it is possible to use something like “example[.!?]?” to match the word “example” on it own and also if followed by “.”, “!” or “?”. See BuiltIn.Should Match Regexp for more information about Python regular expression syntax in general and how to use it in Robot Framework test data in particular.

The reason this keyword does not use Python’s standard [https://docs.python.org/library/stdtypes.html#str.title|title()] method is that it can yield undesired results, for example, if strings contain upper case letters or special characters like apostrophes. It would, for example, convert “it’s an OK iPhone” to “It’S An Ok Iphone”.

New in Robot Framework 3.2.

encode_string_to_bytes(string, encoding, errors='strict')[source]¶

Encodes the given Unicode string to bytes using the given encoding.

errors argument controls what to do if encoding some characters fails. All values accepted by encode method in Python are valid, but in practice the following values are most useful:

strict: fail if characters cannot be encoded (default)
ignore: ignore characters that cannot be encoded
replace: replace characters that cannot be encoded with a replacement character

Use Convert To Bytes in BuiltIn if you want to create bytes based on character or integer sequences. Use Decode Bytes To String if you need to convert byte strings to Unicode strings and Convert To String in BuiltIn if you need to convert arbitrary objects to Unicode.

decode_bytes_to_string(bytes, encoding, errors='strict')[source]¶

Decodes the given bytes to a Unicode string using the given encoding.

errors argument controls what to do if decoding some bytes fails. All values accepted by decode method in Python are valid, but in practice the following values are most useful:

strict: fail if characters cannot be decoded (default)
ignore: ignore characters that cannot be decoded
replace: replace characters that cannot be decoded with a replacement character

Use Encode String To Bytes if you need to convert Unicode strings to byte strings, and Convert To String in BuiltIn if you need to convert arbitrary objects to Unicode strings.

format_string(template, *positional, **named)[source]¶

Formats a template using the given positional and named arguments.

The template can be either be a string or an absolute path to an existing file. In the latter case the file is read and its contents are used as the template. If the template file contains non-ASCII characters, it must be encoded using UTF-8.

The template is formatted using Python’s [https://docs.python.org/library/string.html#format-string-syntax|format string syntax]. Placeholders are marked using {} with possible field name and format specification inside. Literal curly braces can be inserted by doubling them like {{ and }}.

New in Robot Framework 3.1.

get_line_count(string)[source]¶: Returns and logs the number of lines in the given string.

split_to_lines(string, start=0, end=None)[source]¶

Splits the given string to lines.

It is possible to get only a selection of lines from start to end so that start index is inclusive and end is exclusive. Line numbering starts from 0, and it is possible to use negative indices to refer to lines from the end.

Lines are returned without the newlines. The number of returned lines is automatically logged.

Use Get Line if you only need to get a single line.

get_line(string, line_number)[source]¶

Returns the specified line from the given string.

Line numbering starts from 0 and it is possible to use negative indices to refer to lines from the end. The line is returned without the newline character.

Use Split To Lines if all lines are needed.

get_lines_containing_string(string, pattern, case_insensitive=False)[source]¶

Returns lines of the given string that contain the pattern.

The pattern is always considered to be a normal string, not a glob or regexp pattern. A line matches if the pattern is found anywhere on it.

The match is case-sensitive by default, but giving case_insensitive a true value makes it case-insensitive. The value is considered true if it is a non-empty string that is not equal to false, none or no. If the value is not a string, its truth value is got directly in Python.

Lines are returned as one string catenated back together with newlines. Possible trailing newline is never returned. The number of matching lines is automatically logged.

See Get Lines Matching Pattern and Get Lines Matching Regexp if you need more complex pattern matching.

get_lines_matching_pattern(string, pattern, case_insensitive=False)[source]¶

Returns lines of the given string that match the pattern.

The pattern is a _glob pattern_ where:

A line matches only if it matches the pattern fully.

The match is case-sensitive by default, but giving case_insensitive a true value makes it case-insensitive. The value is considered true if it is a non-empty string that is not equal to false, none or no. If the value is not a string, its truth value is got directly in Python.

Lines are returned as one string catenated back together with newlines. Possible trailing newline is never returned. The number of matching lines is automatically logged.

See Get Lines Matching Regexp if you need more complex patterns and Get Lines Containing String if searching literal strings is enough.

get_lines_matching_regexp(string, pattern, partial_match=False)[source]¶

Returns lines of the given string that match the regexp pattern.

See BuiltIn.Should Match Regexp for more information about Python regular expression syntax in general and how to use it in Robot Framework test data in particular.

By default lines match only if they match the pattern fully, but partial matching can be enabled by giving the partial_match argument a true value. The value is considered true if it is a non-empty string that is not equal to false, none or no. If the value is not a string, its truth value is got directly in Python.

If the pattern is empty, it matches only empty lines by default. When partial matching is enabled, empty pattern matches all lines.

Notice that to make the match case-insensitive, you need to prefix the pattern with case-insensitive flag (?i).

Lines are returned as one string concatenated back together with newlines. Possible trailing newline is never returned. The number of matching lines is automatically logged.

See Get Lines Matching Pattern and Get Lines Containing String if you do not need full regular expression powers (and complexity).

get_regexp_matches(string, pattern, *groups)[source]¶

Returns a list of all non-overlapping matches in the given string.

string is the string to find matches from and pattern is the regular expression. See BuiltIn.Should Match Regexp for more information about Python regular expression syntax in general and how to use it in Robot Framework test data in particular.

If no groups are used, the returned list contains full matches. If one group is used, the list contains only contents of that group. If multiple groups are used, the list contains tuples that contain individual group contents. All groups can be given as indexes (starting from 1) and named groups also as names.

replace_string(string, search_for, replace_with, count=-1)[source]¶

Replaces search_for in the given string with replace_with.

search_for is used as a literal string. See Replace String Using Regexp if more powerful pattern matching is needed. If you need to just remove a string see Remove String.

If the optional argument count is given, only that many occurrences from left are replaced. Negative count means that all occurrences are replaced (default behaviour) and zero means that nothing is done.

A modified version of the string is returned and the original string is not altered.

replace_string_using_regexp(string, pattern, replace_with, count=-1)[source]¶

Replaces pattern in the given string with replace_with.

This keyword is otherwise identical to Replace String, but the pattern to search for is considered to be a regular expression. See BuiltIn.Should Match Regexp for more information about Python regular expression syntax in general and how to use it in Robot Framework test data in particular.

If you need to just remove a string see Remove String Using Regexp.

remove_string(string, *removables)[source]¶

Removes all removables from the given string.

removables are used as literal strings. Each removable will be matched to a temporary string from which preceding removables have been already removed. See second example below.

Use Remove String Using Regexp if more powerful pattern matching is needed. If only a certain number of matches should be removed, Replace String or Replace String Using Regexp can be used.

A modified version of the string is returned and the original string is not altered.

remove_string_using_regexp(string, *patterns)[source]¶

Removes patterns from the given string.

This keyword is otherwise identical to Remove String, but the patterns to search for are considered to be a regular expression. See Replace String Using Regexp for more information about the regular expression syntax. That keyword can also be used if there is a need to remove only a certain number of occurrences.

split_string(string, separator=None, max_split=-1)[source]¶

Splits the string using separator as a delimiter string.

If a separator is not given, any whitespace string is a separator. In that case also possible consecutive whitespace as well as leading and trailing whitespace is ignored.

Split words are returned as a list. If the optional max_split is given, at most max_split splits are done, and the returned list will have maximum max_split + 1 elements.

See Split String From Right if you want to start splitting from right, and Fetch From Left and Fetch From Right if you only want to get first/last part of the string.

split_string_from_right(string, separator=None, max_split=-1)[source]¶

Splits the string using separator starting from right.

Same as Split String, but splitting is started from right. This has an effect only when max_split is given.

split_string_to_characters(string)[source]¶: Splits the given string to characters.

fetch_from_left(string, marker)[source]¶

Returns contents of the string before the first occurrence of marker.

If the marker is not found, whole string is returned.

See also Fetch From Right, Split String and Split String From Right.

fetch_from_right(string, marker)[source]¶

Returns contents of the string after the last occurrence of marker.

If the marker is not found, whole string is returned.

See also Fetch From Left, Split String and Split String From Right.

generate_random_string(length=8, chars='[LETTERS][NUMBERS]')[source]¶

Generates a string with a desired length from the given chars.

The population sequence chars contains the characters to use when generating the random string. It can contain any characters, and it is possible to use special markers explained in the table below:

get_substring(string, start, end=None)[source]¶

Returns a substring from start index to end index.

The start index is inclusive and end is exclusive. Indexing starts from 0, and it is possible to use negative indices to refer to characters from the end.

strip_string(string, mode='both', characters=None)[source]¶

Remove leading and/or trailing whitespaces from the given string.

mode is either left to remove leading characters, right to remove trailing characters, both (default) to remove the characters from both sides of the string or none to return the unmodified string.

If the optional characters is given, it must be a string and the characters in the string will be stripped in the string. Please note, that this is not a substring to be removed but a list of characters, see the example below.

should_be_string(item, msg=None)[source]¶

Fails if the given item is not a string.

With Python 2, except with IronPython, this keyword passes regardless is the item a Unicode string or a byte string. Use Should Be Unicode String or Should Be Byte String if you want to restrict the string type. Notice that with Python 2, except with IronPython, 'string' creates a byte string and u'unicode' must be used to create a Unicode string.

With Python 3 and IronPython, this keyword passes if the string is a Unicode string but fails if it is bytes. Notice that with both Python 3 and IronPython, 'string' creates a Unicode string, and b'bytes' must be used to create a byte string.

The default error message can be overridden with the optional msg argument.

should_not_be_string(item, msg=None)[source]¶

Fails if the given item is a string.

See Should Be String for more details about Unicode strings and byte strings.

The default error message can be overridden with the optional msg argument.

should_be_unicode_string(item, msg=None)[source]¶

Fails if the given item is not a Unicode string.

Use Should Be Byte String if you want to verify the item is a byte string, or Should Be String if both Unicode and byte strings are fine. See Should Be String for more details about Unicode strings and byte strings.

The default error message can be overridden with the optional msg argument.

should_be_byte_string(item, msg=None)[source]¶

Fails if the given item is not a byte string.

Use Should Be Unicode String if you want to verify the item is a Unicode string, or Should Be String if both Unicode and byte strings are fine. See Should Be String for more details about Unicode strings and byte strings.

The default error message can be overridden with the optional msg argument.

should_be_lower_case(string, msg=None)[source]¶

Fails if the given string is not in lower case.

For example, 'string' and 'with specials!' would pass, and 'String', '' and ' ' would fail.

The default error message can be overridden with the optional msg argument.

See also Should Be Upper Case and Should Be Title Case.

should_be_upper_case(string, msg=None)[source]¶

Fails if the given string is not in upper case.

For example, 'STRING' and 'WITH SPECIALS!' would pass, and 'String', '' and ' ' would fail.

The default error message can be overridden with the optional msg argument.

See also Should Be Title Case and Should Be Lower Case.

should_be_title_case(string, msg=None, exclude=None)[source]¶

Fails if given string is not title.

string is a title cased string if there is at least one upper case letter in each word.

For example, 'This Is Title' and 'OK, Give Me My iPhone' would pass. 'all words lower' and 'Word In lower' would fail.

This logic changed in Robot Framework 4.0 to be compatible with Convert to Title Case. See Convert to Title Case for title case algorithm and reasoning.

The default error message can be overridden with the optional msg argument.

Words can be explicitly excluded with the optional exclude argument.

Explicitly excluded words can be given as a list or as a string with words separated by a comma and an optional space. Excluded words are actually considered to be regular expression patterns, so it is possible to use something like “example[.!?]?” to match the word “example” on it own and also if followed by “.”, “!” or “?”. See BuiltIn.Should Match Regexp for more information about Python regular expression syntax in general and how to use it in Robot Framework test data in particular.

See also Should Be Upper Case and Should Be Lower Case.

robot.libraries.Telnet module¶

class robot.libraries.Telnet.Telnet(timeout='3 seconds', newline='CRLF', prompt=None, prompt_is_regexp=False, encoding='UTF-8', encoding_errors='ignore', default_log_level='INFO', window_size=None, environ_user=None, terminal_emulation=False, terminal_type=None, telnetlib_log_level='TRACE', connection_timeout=None)[source]¶

Bases: object

A test library providing communication over Telnet connections.

Telnet is Robot Framework’s standard library that makes it possible to connect to Telnet servers and execute commands on the opened connections.

== Table of contents ==

%TOC%

= Connections =

The first step of using Telnet is opening a connection with Open Connection keyword. Typically the next step is logging in with Login keyword, and in the end the opened connection can be closed with Close Connection.

It is possible to open multiple connections and switch the active one using Switch Connection. Close All Connections can be used to close all the connections, which is especially useful in suite teardowns to guarantee that all connections are always closed.

= Writing and reading =

After opening a connection and possibly logging in, commands can be executed or text written to the connection for other reasons using Write and Write Bare keywords. The main difference between these two is that the former adds a [#Configuration|configurable newline] after the text automatically.

After writing something to the connection, the resulting output can be read using Read, Read Until, Read Until Regexp, and Read Until Prompt keywords. Which one to use depends on the context, but the latest one is often the most convenient.

As a convenience when running a command, it is possible to use Execute Command that simply uses Write and Read Until Prompt internally. Write Until Expected Output is useful if you need to wait until writing something produces a desired output.

Written and read text is automatically encoded/decoded using a [#Configuration|configured encoding].

The ANSI escape codes, like cursor movement and color codes, are normally returned as part of the read operation. If an escape code occurs in middle of a search pattern it may also prevent finding the searched string. Terminal emulation can be used to process these escape codes as they would be if a real terminal would be in use.

= Configuration =

Many aspects related the connections can be easily configured either globally or per connection basis. Global configuration is done when [#Importing|library is imported], and these values can be overridden per connection by Open Connection or with setting specific keywords Set Timeout, Set Newline, Set Prompt, Set Encoding, Set Default Log Level and Set Telnetlib Log Level.

Values of environ_user, window_size, terminal_emulation, and terminal_type can not be changed after opening the connection.

== Timeout ==

Timeout defines how long is the maximum time to wait when reading output. It is used internally by Read Until, Read Until Regexp, Read Until Prompt, and Login keywords. The default value is 3 seconds.

== Connection Timeout ==

Connection Timeout defines how long is the maximum time to wait when opening the telnet connection. It is used internally by Open Connection. The default value is the system global default timeout.

== Newline ==

Newline defines which line separator Write keyword should use. The default value is CRLF that is typically used by Telnet connections.

Newline can be given either in escaped format using \n and \r or with special LF and CR syntax.

== Prompt ==

Often the easiest way to read the output of a command is reading all the output until the next prompt with Read Until Prompt. It also makes it easier, and faster, to verify did Login succeed.

Prompt can be specified either as a normal string or a regular expression. The latter is especially useful if the prompt changes as a result of the executed commands. Prompt can be set to be a regular expression by giving prompt_is_regexp argument a true value (see Boolean arguments).

== Encoding ==

To ease handling text containing non-ASCII characters, all written text is encoded and read text decoded by default. The default encoding is UTF-8 that works also with ASCII. Encoding can be disabled by using a special encoding value NONE. This is mainly useful if you need to get the bytes received from the connection as-is.

Notice that when writing to the connection, only Unicode strings are encoded using the defined encoding. Byte strings are expected to be already encoded correctly. Notice also that normal text in test data is passed to the library as Unicode and you need to use variables to use bytes.

It is also possible to configure the error handler to use if encoding or decoding characters fails. Accepted values are the same that encode/decode functions in Python strings accept. In practice the following values are the most useful:

ignore: ignore characters that cannot be encoded (default)
strict: fail if characters cannot be encoded
replace: replace characters that cannot be encoded with a replacement character

== Default log level ==

Default log level specifies the log level keywords use for logging unless they are given an explicit log level. The default value is INFO, and changing it, for example, to DEBUG can be a good idea if there is lot of unnecessary output that makes log files big.

== Terminal type ==

By default the Telnet library does not negotiate any specific terminal type with the server. If a specific terminal type, for example vt100, is desired, the terminal type can be configured in importing and with Open Connection.

== Window size ==

Window size for negotiation with the server can be configured when importing the library and with Open Connection.

== USER environment variable ==

Telnet protocol allows the USER environment variable to be sent when connecting to the server. On some servers it may happen that there is no login prompt, and on those cases this configuration option will allow still to define the desired username. The option environ_user can be used in importing and with Open Connection.

= Terminal emulation =

Telnet library supports terminal emulation with [http://pyte.readthedocs.io|Pyte]. Terminal emulation will process the output in a virtual screen. This means that ANSI escape codes, like cursor movements, and also control characters, like carriage returns and backspaces, have the same effect on the result as they would have on a normal terminal screen. For example the sequence acdc\x1b[3Dbba will result in output abba.

Terminal emulation is taken into use by giving terminal_emulation argument a true value (see Boolean arguments) either in the library initialization or with Open Connection.

As Pyte approximates vt-style terminal, you may also want to set the terminal type as vt100. We also recommend that you increase the window size, as the terminal emulation will break all lines that are longer than the window row length.

When terminal emulation is used, the newline and encoding can not be changed anymore after opening the connection.

As a prerequisite for using terminal emulation, you need to have Pyte installed. Due to backwards incompatible changes in Pyte, different Robot Framework versions support different Pyte versions:

Pyte 0.6 and newer are supported by Robot Framework 3.0.3. Latest Pyte version can be installed (or upgraded) with pip install --upgrade pyte.
Pyte 0.5.2 and older are supported by Robot Framework 3.0.2 and earlier. Pyte 0.5.2 can be installed with pip install pyte==0.5.2.

= Logging =

All keywords that read something log the output. These keywords take the log level to use as an optional argument, and if no log level is specified they use the [#Configuration|configured] default value.

The valid log levels to use are TRACE, DEBUG, INFO (default), and WARN. Levels below INFO are not shown in log files by default whereas warnings are shown more prominently.

The [http://docs.python.org/library/telnetlib.html|telnetlib module] used by this library has a custom logging system for logging content it sends and receives. By default these messages are written using TRACE level, but the level is configurable with the telnetlib_log_level option either in the library initialization, to the Open Connection or by using the Set Telnetlib Log Level keyword to the active connection. Special level NONE con be used to disable the logging altogether.

= Time string format =

Timeouts and other times used must be given as a time string using format like 15 seconds or 1min 10s. If the timeout is given as just a number, for example, 10 or 1.5, it is considered to be seconds. The time string format is described in more detail in an appendix of [http://robotframework.org/robotframework/#user-guide|Robot Framework User Guide].

= Boolean arguments =

Some keywords accept arguments that are handled as Boolean values true or false. If such an argument is given as a string, it is considered false if it is an empty string or equal to FALSE, NONE, NO, OFF or 0, case-insensitively. Other strings are considered true regardless their value, and other argument types are tested using the same [http://docs.python.org/library/stdtypes.html#truth|rules as in Python].

True examples:

False examples:

Considering string NONE false is new in Robot Framework 3.0.3 and considering also OFF and 0 false is new in Robot Framework 3.1.

Telnet library can be imported with optional configuration parameters.

Configuration parameters are used as default values when new connections are opened with Open Connection keyword. They can also be overridden after opening the connection using the Set … keywords. See these keywords as well as Configuration, Terminal emulation and Logging sections above for more information about these parameters and their possible values.

See Time string format and Boolean arguments sections for information about using arguments accepting times and Boolean values, respectively.

ROBOT_LIBRARY_SCOPE = 'TEST_SUITE'¶

ROBOT_LIBRARY_VERSION = '4.1.2'¶

get_keyword_names()[source]¶

open_connection(host, alias=None, port=23, timeout=None, newline=None, prompt=None, prompt_is_regexp=False, encoding=None, encoding_errors=None, default_log_level=None, window_size=None, environ_user=None, terminal_emulation=None, terminal_type=None, telnetlib_log_level=None, connection_timeout=None)[source]¶

Opens a new Telnet connection to the given host and port.

The timeout, newline, prompt, prompt_is_regexp, encoding, default_log_level, window_size, environ_user, terminal_emulation, terminal_type and telnetlib_log_level arguments get default values when the library is [#Importing|imported]. Setting them here overrides those values for the opened connection. See Configuration, Terminal emulation and Logging sections for more information about these parameters and their possible values.

Possible already opened connections are cached and it is possible to switch back to them using Switch Connection keyword. It is possible to switch either using explicitly given alias or using index returned by this keyword. Indexing starts from 1 and is reset back to it by Close All Connections keyword.

switch_connection(index_or_alias)[source]¶

Switches between active connections using an index or an alias.

Aliases can be given to Open Connection keyword which also always returns the connection index.

This keyword returns the index of previous active connection.

The example above expects that there were no other open connections when opening the first one, because it used index 1 when switching to the connection later. If you are not sure about that, you can store the index into a variable as shown below.

close_all_connections()[source]¶

Closes all open connections and empties the connection cache.

If multiple connections are opened, this keyword should be used in a test or suite teardown to make sure that all connections are closed. It is not an error is some of the connections have already been closed by Close Connection.

After this keyword, new indexes returned by Open Connection keyword are reset to 1.

class robot.libraries.Telnet.TelnetConnection(host=None, port=23, timeout=3.0, newline='CRLF', prompt=None, prompt_is_regexp=False, encoding='UTF-8', encoding_errors='ignore', default_log_level='INFO', window_size=None, environ_user=None, terminal_emulation=False, terminal_type=None, telnetlib_log_level='TRACE', connection_timeout=None)[source]¶

Bases: telnetlib.Telnet

NEW_ENVIRON_IS = '\x00'¶

NEW_ENVIRON_VAR = '\x00'¶

NEW_ENVIRON_VALUE = '\x01'¶

INTERNAL_UPDATE_FREQUENCY = 0.03¶

set_timeout(timeout)[source]¶

Sets the timeout used for waiting output in the current connection.

Read operations that expect some output to appear (Read Until, Read Until Regexp, Read Until Prompt, Login) use this timeout and fail if the expected output does not appear before this timeout expires.

The timeout must be given in time string format. The old timeout is returned and can be used to restore the timeout later.

See Configuration section for more information about global and connection specific configuration.

set_newline(newline)[source]¶

Sets the newline used by Write keyword in the current connection.

The old newline is returned and can be used to restore the newline later. See Set Timeout for a similar example.

If terminal emulation is used, the newline can not be changed on an open connection.

See Configuration section for more information about global and connection specific configuration.

set_prompt(prompt, prompt_is_regexp=False)[source]¶

Sets the prompt used by Read Until Prompt and Login in the current connection.

If prompt_is_regexp is given a true value (see Boolean arguments), the given prompt is considered to be a regular expression.

The old prompt is returned and can be used to restore the prompt later.

See the documentation of [http://docs.python.org/library/re.html|Python re module] for more information about the supported regular expression syntax. Notice that possible backslashes need to be escaped in Robot Framework test data.

See Configuration section for more information about global and connection specific configuration.

set_encoding(encoding=None, errors=None)[source]¶

Sets the encoding to use for writing and reading in the current connection.

The given encoding specifies the encoding to use when written/read text is encoded/decoded, and errors specifies the error handler to use if encoding/decoding fails. Either of these can be omitted and in that case the old value is not affected. Use string NONE to disable encoding altogether.

See Configuration section for more information about encoding and error handlers, as well as global and connection specific configuration in general.

The old values are returned and can be used to restore the encoding and the error handler later. See Set Prompt for a similar example.

If terminal emulation is used, the encoding can not be changed on an open connection.

set_telnetlib_log_level(level)[source]¶

Sets the log level used for logging in the underlying telnetlib.

Note that telnetlib can be very noisy thus using the level NONE can shutdown the messages generated by this library.

set_default_log_level(level)[source]¶

Sets the default log level used for logging in the current connection.

The old default log level is returned and can be used to restore the log level later.

See Configuration section for more information about global and connection specific configuration.

close_connection(loglevel=None)[source]¶

Closes the current Telnet connection.

Remaining output in the connection is read, logged, and returned. It is not an error to close an already closed connection.

Use Close All Connections if you want to make sure all opened connections are closed.

See Logging section for more information about log levels.

login(username, password, login_prompt='login: ', password_prompt='Password: ', login_timeout='1 second', login_incorrect='Login incorrect')[source]¶

Logs in to the Telnet server with the given user information.

This keyword reads from the connection until the login_prompt is encountered and then types the given username. Then it reads until the password_prompt and types the given password. In both cases a newline is appended automatically and the connection specific timeout used when waiting for outputs.

How logging status is verified depends on whether a prompt is set for this connection or not:

1) If the prompt is set, this keyword reads the output until the prompt is found using the normal timeout. If no prompt is found, login is considered failed and also this keyword fails. Note that in this case both login_timeout and login_incorrect arguments are ignored.

2) If the prompt is not set, this keywords sleeps until login_timeout and then reads all the output available on the connection. If the output contains login_incorrect text, login is considered failed and also this keyword fails.

See Configuration section for more information about setting newline, timeout, and prompt.

write(text, loglevel=None)[source]¶

Writes the given text plus a newline into the connection.

The newline character sequence to use can be [#Configuration|configured] both globally and per connection basis. The default value is CRLF.

This keyword consumes the written text, until the added newline, from the output and logs and returns it. The given text itself must not contain newlines. Use Write Bare instead if either of these features causes a problem.

Note: This keyword does not return the possible output of the executed command. To get the output, one of the Read … keywords must be used. See Writing and reading section for more details.

See Logging section for more information about log levels.

write_bare(text)[source]¶

Writes the given text, and nothing else, into the connection.

This keyword does not append a newline nor consume the written text. Use Write if these features are needed.

write_until_expected_output(text, expected, timeout, retry_interval, loglevel=None)[source]¶

Writes the given text repeatedly, until expected appears in the output.

text is written without appending a newline and it is consumed from the output before trying to find expected. If expected does not appear in the output within timeout, this keyword fails.

retry_interval defines the time to wait expected to appear before writing the text again. Consuming the written text is subject to the normal [#Configuration|configured timeout].

Both timeout and retry_interval must be given in time string format. See Logging section for more information about log levels.

The above example writes command ps -ef | grep myprocess\r\n until myprocess appears in the output. The command is written every 0.5 seconds and the keyword fails if myprocess does not appear in the output in 5 seconds.

write_control_character(character)[source]¶

Writes the given control character into the connection.

The control character is prepended with an IAC (interpret as command) character.

The following control character names are supported: BRK, IP, AO, AYT, EC, EL, NOP. Additionally, you can use arbitrary numbers to send any control character.

read(loglevel=None)[source]¶

Reads everything that is currently available in the output.

Read output is both returned and logged. See Logging section for more information about log levels.

read_until(expected, loglevel=None)[source]¶

Reads output until expected text is encountered.

Text up to and including the match is returned and logged. If no match is found, this keyword fails. How much to wait for the output depends on the [#Configuration|configured timeout].

See Logging section for more information about log levels. Use Read Until Regexp if more complex matching is needed.

read_until_regexp(*expected)[source]¶

Reads output until any of the expected regular expressions match.

This keyword accepts any number of regular expressions patterns or compiled Python regular expression objects as arguments. Text up to and including the first match to any of the regular expressions is returned and logged. If no match is found, this keyword fails. How much to wait for the output depends on the [#Configuration|configured timeout].

If the last given argument is a [#Logging|valid log level], it is used as loglevel similarly as with Read Until keyword.

See the documentation of [http://docs.python.org/library/re.html|Python re module] for more information about the supported regular expression syntax. Notice that possible backslashes need to be escaped in Robot Framework test data.

read_until_prompt(loglevel=None, strip_prompt=False)[source]¶

Reads output until the prompt is encountered.

This keyword requires the prompt to be [#Configuration|configured] either in importing or with Open Connection or Set Prompt keyword.

By default, text up to and including the prompt is returned and logged. If no prompt is found, this keyword fails. How much to wait for the output depends on the [#Configuration|configured timeout].

If you want to exclude the prompt from the returned output, set strip_prompt to a true value (see Boolean arguments). If your prompt is a regular expression, make sure that the expression spans the whole prompt, because only the part of the output that matches the regular expression is stripped away.

See Logging section for more information about log levels.

execute_command(command, loglevel=None, strip_prompt=False)[source]¶

Executes the given command and reads, logs, and returns everything until the prompt.

This keyword requires the prompt to be [#Configuration|configured] either in importing or with Open Connection or Set Prompt keyword.

This is a convenience keyword that uses Write and Read Until Prompt internally. Following two examples are thus functionally identical:

See Logging section for more information about log levels and Read Until Prompt for more information about the strip_prompt parameter.

msg(msg, *args)[source]¶

close()¶: Close the connection.

expect(list, timeout=None)¶

Read until one from a list of a regular expressions matches.

The first argument is a list of regular expressions, either compiled (re.RegexObject instances) or uncompiled (strings). The optional second argument is a timeout, in seconds; default is no timeout.

Return a tuple of three items: the index in the list of the first regular expression that matches; the match object returned; and the text read up till and including the match.

If EOF is read and no text was read, raise EOFError. Otherwise, when nothing matches, return (-1, None, text) where text is the text received so far (may be the empty string if a timeout happened).

If a regular expression ends with a greedy match (e.g. ‘.*’) or if more than one expression can match the same input, the results are undeterministic, and may depend on the I/O timing.

fileno()¶: Return the fileno() of the socket object used internally.

fill_rawq()¶

Fill raw queue from exactly one recv() system call.

Block if no data is immediately available. Set self.eof when connection is closed.

get_socket()¶: Return the socket object used internally.

interact()¶: Interaction function, emulates a very dumb telnet client.

listener()¶: Helper for mt_interact() – this executes in the other thread.

mt_interact()¶: Multithreaded version of interact().

open(host, port=0, timeout=<object object>)¶

Connect to a host.

The optional second argument is the port number, which defaults to the standard telnet port (23).

Don’t try to reopen an already connected instance.

process_rawq()¶

Transfer from raw queue to cooked queue.

Set self.eof when connection is closed. Don’t block unless in the midst of an IAC sequence.

rawq_getchar()¶

Get next char from raw queue.

Block if no data is immediately available. Raise EOFError when connection is closed.

read_all()¶: Read all data until EOF; block until connection closed.

read_eager()¶

Read readily available data.

Raise EOFError if connection closed and no cooked data available. Return ‘’ if no cooked data available otherwise. Don’t block unless in the midst of an IAC sequence.

read_lazy()¶

Process and return data that’s already in the queues (lazy).

Raise EOFError if connection closed and no data available. Return ‘’ if no cooked data available otherwise. Don’t block unless in the midst of an IAC sequence.

read_sb_data()¶

Return any data available in the SB … SE queue.

Return ‘’ if no SB … SE available. Should only be called after seeing a SB or SE command. When a new SB command is found, old unread SB data will be discarded. Don’t block.

read_some()¶

Read at least one byte of cooked data unless EOF is hit.

Return ‘’ if EOF is hit. Block if no data is immediately available.

read_very_eager()¶

Read everything that’s possible without blocking in I/O (eager).

Raise EOFError if connection closed and no cooked data available. Return ‘’ if no cooked data available otherwise. Don’t block unless in the midst of an IAC sequence.

read_very_lazy()¶

Return any data available in the cooked queue (very lazy).

Raise EOFError if connection closed and no data available. Return ‘’ if no cooked data available otherwise. Don’t block.

set_debuglevel(debuglevel)¶

Set the debug level.

The higher it is, the more debug output you get (on sys.stdout).

set_option_negotiation_callback(callback)¶: Provide a callback function called after each receipt of a telnet option.

sock_avail()¶: Test whether data is available on the socket.

class robot.libraries.Telnet.TerminalEmulator(window_size=None, newline='rn')[source]¶

Bases: object

current_output¶

feed(text)[source]¶

read()[source]¶

read_until(expected)[source]¶

read_until_regexp(regexp_list)[source]¶

exception robot.libraries.Telnet.NoMatchError(expected, timeout, output=None)[source]¶

Bases: exceptions.AssertionError

ROBOT_SUPPRESS_NAME = True¶

args¶

message¶

robot.libraries.XML module¶

class robot.libraries.XML.XML(use_lxml=False)[source]¶

Bases: object

Robot Framework test library for verifying and modifying XML documents.

As the name implies, _XML_ is a test library for verifying contents of XML files. In practice it is a pretty thin wrapper on top of Python’s [http://docs.python.org/library/xml.etree.elementtree.html|ElementTree XML API].

The library has the following main usages:

Parsing an XML file, or a string containing XML, into an XML element structure and finding certain elements from it for for further analysis (e.g. Parse XML and Get Element keywords).
Getting text or attributes of elements (e.g. Get Element Text and Get Element Attribute).
Directly verifying text, attributes, or whole elements (e.g Element Text Should Be and Elements Should Be Equal).
Modifying XML and saving it (e.g. Set Element Text, Add Element and Save XML).

== Table of contents ==

%TOC%

= Parsing XML =

XML can be parsed into an element structure using Parse XML keyword. The XML to be parsed can be specified using a path to an XML file or as a string or bytes that contain XML directly. The keyword returns the root element of the structure, which then contains other elements as its children and their children. Possible comments and processing instructions in the source XML are removed.

XML is not validated during parsing even if has a schema defined. How possible doctype elements are handled otherwise depends on the used XML module and on the platform. The standard ElementTree strips doctypes altogether but when using lxml they are preserved when XML is saved.

The element structure returned by Parse XML, as well as elements returned by keywords such as Get Element, can be used as the source argument with other keywords. In addition to an already parsed XML structure, other keywords also accept paths to XML files and strings containing XML similarly as Parse XML. Notice that keywords that modify XML do not write those changes back to disk even if the source would be given as a path to a file. Changes must always saved explicitly using Save XML keyword.

When the source is given as a path to a file, the forward slash character (/) can be used as the path separator regardless the operating system. On Windows also the backslash works, but it the test data it needs to be escaped by doubling it (\\). Using the built-in variable ${/} naturally works too.

Note: Support for XML as bytes is new in Robot Framework 3.2.

= Using lxml =

By default this library uses Python’s standard [http://docs.python.org/library/xml.etree.elementtree.html|ElementTree] module for parsing XML, but it can be configured to use [http://lxml.de|lxml] module instead when importing the library. The resulting element structure has same API regardless which module is used for parsing.

The main benefits of using lxml is that it supports richer xpath syntax than the standard ElementTree and enables using Evaluate Xpath keyword. It also preserves the doctype and possible namespace prefixes saving XML.

= Example =

The following simple example demonstrates parsing XML and verifying its contents both using keywords in this library and in _BuiltIn_ and _Collections_ libraries. How to use xpath expressions to find elements and what attributes the returned elements contain are discussed, with more examples, in Finding elements with xpath and Element attributes sections.

In this example, as well as in many other examples in this documentation, ${XML} refers to the following example XML document. In practice ${XML} could either be a path to an XML file or it could contain the XML itself.

Notice that in the example three last lines are equivalent. Which one to use in practice depends on which other elements you need to get or verify. If you only need to do one verification, using the last line alone would suffice. If more verifications are needed, parsing the XML with Parse XML only once would be more efficient.

= Finding elements with xpath =

ElementTree, and thus also this library, supports finding elements using xpath expressions. ElementTree does not, however, support the full xpath standard. The supported xpath syntax is explained below and [https://docs.python.org/library/xml.etree.elementtree.html#xpath-support| ElementTree documentation] provides more details. In the examples ${XML} refers to the same XML structure as in the earlier example.

If lxml support is enabled when importing the library, the whole [http://www.w3.org/TR/xpath/|xpath 1.0 standard] is supported. That includes everything listed below but also lot of other useful constructs.

== Tag names ==

When just a single tag name is used, xpath matches all direct child elements that have that tag name.

== Paths ==

Paths are created by combining tag names with a forward slash (/). For example, parent/child matches all child elements under parent element. Notice that if there are multiple parent elements that all have child elements, parent/child xpath will match all these child elements.

== Wildcards ==

An asterisk (*) can be used in paths instead of a tag name to denote any element.

== Current element ==

The current element is denoted with a dot (.). Normally the current element is implicit and does not need to be included in the xpath.

== Parent element ==

The parent element of another element is denoted with two dots (..). Notice that it is not possible to refer to the parent of the current element.

== Search all sub elements ==

Two forward slashes (//) mean that all sub elements, not only the direct children, are searched. If the search is started from the current element, an explicit dot is required.

== Predicates ==

Predicates allow selecting elements using also other criteria than tag names, for example, attributes or position. They are specified after the normal tag name or path using syntax path[predicate]. The path can have wildcards and other special syntax explained earlier. What predicates the standard ElementTree supports is explained in the table below.

Predicates can also be stacked like path[predicate1][predicate2]. A limitation is that possible position predicate must always be first.

= Element attributes =

All keywords returning elements, such as Parse XML, and Get Element, return ElementTree’s [http://docs.python.org/library/xml.etree.elementtree.html#element-objects|Element objects]. These elements can be used as inputs for other keywords, but they also contain several useful attributes that can be accessed directly using the extended variable syntax.

The attributes that are both useful and convenient to use in the test data are explained below. Also other attributes, including methods, can be accessed, but that is typically better to do in custom libraries than directly in the test data.

The examples use the same ${XML} structure as the earlier examples.

== tag ==

The tag of the element.

== text ==

The text that the element contains or Python None if the element has no text. Notice that the text _does not_ contain texts of possible child elements nor text after or between children. Notice also that in XML whitespace is significant, so the text contains also possible indentation and newlines. To get also text of the possible children, optionally whitespace normalized, use Get Element Text keyword.

== tail ==

The text after the element before the next opening or closing tag. Python None if the element has no tail. Similarly as with text, also tail contains possible indentation and newlines.

== attrib ==

A Python dictionary containing attributes of the element.

= Handling XML namespaces =

ElementTree and lxml handle possible namespaces in XML documents by adding the namespace URI to tag names in so called Clark Notation. That is inconvenient especially with xpaths, and by default this library strips those namespaces away and moves them to xmlns attribute instead. That can be avoided by passing keep_clark_notation argument to Parse XML keyword. Alternatively Parse XML supports stripping namespace information altogether by using strip_namespaces argument. The pros and cons of different approaches are discussed in more detail below.

== How ElementTree handles namespaces ==

If an XML document has namespaces, ElementTree adds namespace information to tag names in [http://www.jclark.com/xml/xmlns.htm|Clark Notation] (e.g. {http://ns.uri}tag) and removes original xmlns attributes. This is done both with default namespaces and with namespaces with a prefix. How it works in practice is illustrated by the following example, where ${NS} variable contains this XML document:

As you can see, including the namespace URI in tag names makes xpaths really long and complex.

If you save the XML, ElementTree moves namespace information back to xmlns attributes. Unfortunately it does not restore the original prefixes:

The resulting output is semantically same as the original, but mangling prefixes like this may still not be desirable. Notice also that the actual output depends slightly on ElementTree version.

== Default namespace handling ==

Because the way ElementTree handles namespaces makes xpaths so complicated, this library, by default, strips namespaces from tag names and moves that information back to xmlns attributes. How this works in practice is shown by the example below, where ${NS} variable contains the same XML document as in the previous example.

Now that tags do not contain namespace information, xpaths are simple again.

A minor limitation of this approach is that namespace prefixes are lost. As a result the saved output is not exactly same as the original one in this case either:

Also this output is semantically same as the original. If the original XML had only default namespaces, the output would also look identical.

== Namespaces when using lxml ==

This library handles namespaces same way both when using lxml and when not using it. There are, however, differences how lxml internally handles namespaces compared to the standard ElementTree. The main difference is that lxml stores information about namespace prefixes and they are thus preserved if XML is saved. Another visible difference is that lxml includes namespace information in child elements got with Get Element if the parent element has namespaces.

== Stripping namespaces altogether ==

Because namespaces often add unnecessary complexity, Parse XML supports stripping them altogether by using strip_namespaces=True. When this option is enabled, namespaces are not shown anywhere nor are they included if XML is saved.

== Attribute namespaces ==

Attributes in XML documents are, by default, in the same namespaces as the element they belong to. It is possible to use different namespaces by using prefixes, but this is pretty rare.

If an attribute has a namespace prefix, ElementTree will replace it with Clark Notation the same way it handles elements. Because stripping namespaces from attributes could cause attribute conflicts, this library does not handle attribute namespaces at all. Thus the following example works the same way regardless how namespaces are handled.

= Boolean arguments =

Some keywords accept arguments that are handled as Boolean values true or false. If such an argument is given as a string, it is considered false if it is an empty string or equal to FALSE, NONE, NO, OFF or 0, case-insensitively. Other strings are considered true regardless their value, and other argument types are tested using the same [http://docs.python.org/library/stdtypes.html#truth|rules as in Python].

True examples:

False examples:

Considering OFF and 0 false is new in Robot Framework 3.1.

== Pattern matching ==

Some keywords, for example Elements Should Match, support so called [http://en.wikipedia.org/wiki/Glob_(programming)|glob patterns] where:

Unlike with glob patterns normally, path separator characters / and \ and the newline character \n are matches by the above wildcards.

Support for brackets like [abc] and [!a-z] is new in Robot Framework 3.1

Import library with optionally lxml mode enabled.

By default this library uses Python’s standard [http://docs.python.org/library/xml.etree.elementtree.html|ElementTree] module for parsing XML. If use_lxml argument is given a true value (see Boolean arguments), the library will use [http://lxml.de|lxml] module instead. See Using lxml section for benefits provided by lxml.

Using lxml requires that the lxml module is installed on the system. If lxml mode is enabled but the module is not installed, this library will emit a warning and revert back to using the standard ElementTree.

ROBOT_LIBRARY_SCOPE = 'GLOBAL'¶

ROBOT_LIBRARY_VERSION = '4.1.2'¶

parse_xml(source, keep_clark_notation=False, strip_namespaces=False)[source]¶

Parses the given XML file or string into an element structure.

The source can either be a path to an XML file or a string containing XML. In both cases the XML is parsed into ElementTree [http://docs.python.org/library/xml.etree.elementtree.html#element-objects|element structure] and the root element is returned. Possible comments and processing instructions in the source XML are removed.

As discussed in Handling XML namespaces section, this keyword, by default, removes namespace information ElementTree has added to tag names and moves it into xmlns attributes. This typically eases handling XML documents with namespaces considerably. If you do not want that to happen, or want to avoid the small overhead of going through the element structure when your XML does not have namespaces, you can disable this feature by giving keep_clark_notation argument a true value (see Boolean arguments).

If you want to strip namespace information altogether so that it is not included even if XML is saved, you can give a true value to strip_namespaces argument.

Use Get Element keyword if you want to get a certain element and not the whole structure. See Parsing XML section for more details and examples.

get_element(source, xpath='.')[source]¶

Returns an element in the source matching the xpath.

The source can be a path to an XML file, a string containing XML, or an already parsed XML element. The xpath specifies which element to find. See the introduction for more details about both the possible sources and the supported xpath syntax.

The keyword fails if more, or less, than one element matches the xpath. Use Get Elements if you want all matching elements to be returned.

Parse XML is recommended for parsing XML when the whole structure is needed. It must be used if there is a need to configure how XML namespaces are handled.

Many other keywords use this keyword internally, and keywords modifying XML are typically documented to both to modify the given source and to return it. Modifying the source does not apply if the source is given as a string. The XML structure parsed based on the string and then modified is nevertheless returned.

get_elements(source, xpath)[source]¶

Returns a list of elements in the source matching the xpath.

The source can be a path to an XML file, a string containing XML, or an already parsed XML element. The xpath specifies which element to find. See the introduction for more details.

Elements matching the xpath are returned as a list. If no elements match, an empty list is returned. Use Get Element if you want to get exactly one match.

get_child_elements(source, xpath='.')[source]¶

Returns the child elements of the specified element as a list.

The element whose children to return is specified using source and xpath. They have exactly the same semantics as with Get Element keyword.

All the direct child elements of the specified element are returned. If the element has no children, an empty list is returned.

get_element_count(source, xpath='.')[source]¶

Returns and logs how many elements the given xpath matches.

Arguments source and xpath have exactly the same semantics as with Get Elements keyword that this keyword uses internally.

See also Element Should Exist and Element Should Not Exist.

element_should_exist(source, xpath='.', message=None)[source]¶

Verifies that one or more element match the given xpath.

Arguments source and xpath have exactly the same semantics as with Get Elements keyword. Keyword passes if the xpath matches one or more elements in the source. The default error message can be overridden with the message argument.

See also Element Should Not Exist as well as Get Element Count that this keyword uses internally.

element_should_not_exist(source, xpath='.', message=None)[source]¶

Verifies that no element match the given xpath.

Arguments source and xpath have exactly the same semantics as with Get Elements keyword. Keyword fails if the xpath matches any element in the source. The default error message can be overridden with the message argument.

See also Element Should Exist as well as Get Element Count that this keyword uses internally.

get_element_text(source, xpath='.', normalize_whitespace=False)[source]¶

Returns all text of the element, possibly whitespace normalized.

The element whose text to return is specified using source and xpath. They have exactly the same semantics as with Get Element keyword.

This keyword returns all the text of the specified element, including all the text its children and grandchildren contain. If the element has no text, an empty string is returned. The returned text is thus not always the same as the text attribute of the element.

By default all whitespace, including newlines and indentation, inside the element is returned as-is. If normalize_whitespace is given a true value (see Boolean arguments), then leading and trailing whitespace is stripped, newlines and tabs converted to spaces, and multiple spaces collapsed into one. This is especially useful when dealing with HTML data.

See also Get Elements Texts, Element Text Should Be and Element Text Should Match.

get_elements_texts(source, xpath, normalize_whitespace=False)[source]¶

Returns text of all elements matching xpath as a list.

The elements whose text to return is specified using source and xpath. They have exactly the same semantics as with Get Elements keyword.

The text of the matched elements is returned using the same logic as with Get Element Text. This includes optional whitespace normalization using the normalize_whitespace option.

element_text_should_be(source, expected, xpath='.', normalize_whitespace=False, message=None)[source]¶

Verifies that the text of the specified element is expected.

The element whose text is verified is specified using source and xpath. They have exactly the same semantics as with Get Element keyword.

The text to verify is got from the specified element using the same logic as with Get Element Text. This includes optional whitespace normalization using the normalize_whitespace option.

The keyword passes if the text of the element is equal to the expected value, and otherwise it fails. The default error message can be overridden with the message argument. Use Element Text Should Match to verify the text against a pattern instead of an exact value.

element_text_should_match(source, pattern, xpath='.', normalize_whitespace=False, message=None)[source]¶

Verifies that the text of the specified element matches expected.

This keyword works exactly like Element Text Should Be except that the expected value can be given as a pattern that the text of the element must match.

Pattern matching is similar as matching files in a shell with *, ? and [chars] acting as wildcards. See the Pattern matching section for more information.

get_element_attribute(source, name, xpath='.', default=None)[source]¶

Returns the named attribute of the specified element.

The element whose attribute to return is specified using source and xpath. They have exactly the same semantics as with Get Element keyword.

The value of the attribute name of the specified element is returned. If the element does not have such element, the default value is returned instead.

See also Get Element Attributes, Element Attribute Should Be, Element Attribute Should Match and Element Should Not Have Attribute.

get_element_attributes(source, xpath='.')[source]¶

Returns all attributes of the specified element.

The element whose attributes to return is specified using source and xpath. They have exactly the same semantics as with Get Element keyword.

Attributes are returned as a Python dictionary. It is a copy of the original attributes so modifying it has no effect on the XML structure.

Use Get Element Attribute to get the value of a single attribute.

element_attribute_should_be(source, name, expected, xpath='.', message=None)[source]¶

Verifies that the specified attribute is expected.

The element whose attribute is verified is specified using source and xpath. They have exactly the same semantics as with Get Element keyword.

The keyword passes if the attribute name of the element is equal to the expected value, and otherwise it fails. The default error message can be overridden with the message argument.

To test that the element does not have a certain attribute, Python None (i.e. variable ${NONE}) can be used as the expected value. A cleaner alternative is using Element Should Not Have Attribute.

See also Element Attribute Should Match and Get Element Attribute.

element_attribute_should_match(source, name, pattern, xpath='.', message=None)[source]¶

Verifies that the specified attribute matches expected.

This keyword works exactly like Element Attribute Should Be except that the expected value can be given as a pattern that the attribute of the element must match.

Pattern matching is similar as matching files in a shell with *, ? and [chars] acting as wildcards. See the Pattern matching section for more information.

element_should_not_have_attribute(source, name, xpath='.', message=None)[source]¶

Verifies that the specified element does not have attribute name.

The element whose attribute is verified is specified using source and xpath. They have exactly the same semantics as with Get Element keyword.

The keyword fails if the specified element has attribute name. The default error message can be overridden with the message argument.

See also Get Element Attribute, Get Element Attributes, Element Text Should Be and Element Text Should Match.

elements_should_be_equal(source, expected, exclude_children=False, normalize_whitespace=False)[source]¶

Verifies that the given source element is equal to expected.

Both source and expected can be given as a path to an XML file, as a string containing XML, or as an already parsed XML element structure. See introduction for more information about parsing XML in general.

The keyword passes if the source element and expected element are equal. This includes testing the tag names, texts, and attributes of the elements. By default also child elements are verified the same way, but this can be disabled by setting exclude_children to a true value (see Boolean arguments).

All texts inside the given elements are verified, but possible text outside them is not. By default texts must match exactly, but setting normalize_whitespace to a true value makes text verification independent on newlines, tabs, and the amount of spaces. For more details about handling text see Get Element Text keyword and discussion about elements’ text and tail attributes in the introduction.

The last example may look a bit strange because the <p> element only has text Text with. The reason is that rest of the text inside <p> actually belongs to the child elements. This includes the . at the end that is the tail text of the <i> element.

robot.libraries.dialogs_ipy module¶

robot.libraries.dialogs_jy module¶

robot.libraries.dialogs_py module¶

class robot.libraries.dialogs_py.MessageDialog(message, value=None, **extra)[source]¶

Bases: robot.libraries.dialogs_py._TkDialog

after(ms, func=None, *args)¶

Call function once after given time.

MS specifies the time in milliseconds. FUNC gives the function which shall be called. Additional parameters are given as parameters to the function call. Return identifier to cancel scheduling with after_cancel.

after_cancel(id)¶

Cancel scheduling of function identified with ID.

Identifier returned by after or after_idle must be given as first parameter.

after_idle(func, *args)¶

Call FUNC once if the Tcl main loop has no event to process.

Return an identifier to cancel the scheduling with after_cancel.

aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)¶: Instruct the window manager to set the aspect ratio (width/height) of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple of the actual values if no argument is given.

attributes(*args)¶

This subcommand returns or sets platform specific attributes

The first form returns a list of the platform specific flags and their values. The second form returns the value for the specific option. The third form sets one or more of the values. The values are as follows:

On Windows, -disabled gets or sets whether the window is in a disabled state. -toolwindow gets or sets the style of the window to toolwindow (as defined in the MSDN). -topmost gets or sets whether this is a topmost window (displays above all other windows).

On Macintosh, XXXXX

On Unix, there are currently no special attribute values.

bbox(column=None, row=None, col2=None, row2=None)¶

Return a tuple of integer coordinates for the bounding box of this widget controlled by the geometry manager grid.

If COLUMN, ROW is given the bounding box applies from the cell with row and column 0 to the specified cell. If COL2 and ROW2 are given the bounding box starts at that cell.

The returned integers specify the offset of the upper left corner in the master widget and the width and height.

bell(displayof=0)¶: Ring a display’s bell.

bind(sequence=None, func=None, add=None)¶

Bind to this widget at event SEQUENCE a call to function FUNC.

SEQUENCE is a string of concatenated event patterns. An event pattern is of the form <MODIFIER-MODIFIER-TYPE-DETAIL> where MODIFIER is one of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4, Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3, B3, Alt, Button4, B4, Double, Button5, B5 Triple, Mod1, M1. TYPE is one of Activate, Enter, Map, ButtonPress, Button, Expose, Motion, ButtonRelease FocusIn, MouseWheel, Circulate, FocusOut, Property, Colormap, Gravity Reparent, Configure, KeyPress, Key, Unmap, Deactivate, KeyRelease Visibility, Destroy, Leave and DETAIL is the button number for ButtonPress, ButtonRelease and DETAIL is the Keysym for KeyPress and KeyRelease. Examples are <Control-Button-1> for pressing Control and mouse button 1 or <Alt-A> for pressing A and the Alt key (KeyPress can be omitted). An event pattern can also be a virtual event of the form <<AString>> where AString can be arbitrary. This event can be generated by event_generate. If events are concatenated they must appear shortly after each other.

FUNC will be called if the event sequence occurs with an instance of Event as argument. If the return value of FUNC is “break” no further bound function is invoked.

An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function.

Bind will return an identifier to allow deletion of the bound function with unbind without memory leak.

If FUNC or SEQUENCE is omitted the bound function or list of bound events are returned.

bind_all(sequence=None, func=None, add=None)¶: Bind to all widgets at an event SEQUENCE a call to function FUNC. An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function. See bind for the return value.

bind_class(className, sequence=None, func=None, add=None)¶: Bind to widgets with bindtag CLASSNAME at event SEQUENCE a call of function FUNC. An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function. See bind for the return value.

bindtags(tagList=None)¶

Set or get the list of bindtags for this widget.

With no argument return the list of all bindtags associated with this widget. With a list of strings as argument the bindtags are set to this list. The bindtags determine in which order events are processed (see bind).

cget(key)¶: Return the resource value for a KEY given as string.

client(name=None)¶: Store NAME in WM_CLIENT_MACHINE property of this widget. Return current value.

clipboard_append(string, **kw)¶

Append STRING to the Tk clipboard.

A widget specified at the optional displayof keyword argument specifies the target display. The clipboard can be retrieved with selection_get.

clipboard_clear(**kw)¶

Clear the data in the Tk clipboard.

A widget specified for the optional displayof keyword argument specifies the target display.

clipboard_get(**kw)¶

Retrieve data from the clipboard on window’s display.

The window keyword defaults to the root window of the Tkinter application.

The type keyword specifies the form in which the data is to be returned and should be an atom name such as STRING or FILE_NAME. Type defaults to STRING, except on X11, where the default is to try UTF8_STRING and fall back to STRING.

This command is equivalent to:

selection_get(CLIPBOARD)

colormapwindows(*wlist)¶: Store list of window names (WLIST) into WM_COLORMAPWINDOWS property of this widget. This list contains windows whose colormaps differ from their parents. Return current list of widgets if WLIST is empty.

colormodel(value=None)¶: Useless. Not implemented in Tk.

columnconfigure(index, cnf={}, **kw)¶

Configure column INDEX of a grid.

Valid resources are minsize (minimum size of the column), weight (how much does additional space propagate to this column) and pad (how much space to let additionally).

command(value=None)¶: Store VALUE in WM_COMMAND property. It is the command which shall be used to invoke the application. Return current command if VALUE is None.

config(cnf=None, **kw)¶

Configure resources of a widget.

The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method keys.

configure(cnf=None, **kw)¶

Configure resources of a widget.

The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method keys.

deiconify()¶: Deiconify this widget. If it was never mapped it will not be mapped. On Windows it will raise this widget and give it the focus.

deletecommand(name)¶

Internal function.

Delete the Tcl command provided in NAME.

destroy()¶: Destroy this and all descendants widgets.

event_add(virtual, *sequences)¶: Bind a virtual event VIRTUAL (of the form <<Name>>) to an event SEQUENCE such that the virtual event is triggered whenever SEQUENCE occurs.

event_delete(virtual, *sequences)¶: Unbind a virtual event VIRTUAL from SEQUENCE.

event_generate(sequence, **kw)¶: Generate an event SEQUENCE. Additional keyword arguments specify parameter of the event (e.g. x, y, rootx, rooty).

event_info(virtual=None)¶: Return a list of all virtual events or the information about the SEQUENCE bound to the virtual event VIRTUAL.

focus()¶

Direct input focus to this widget.

If the application currently does not have the focus this widget will get the focus if the application gets the focus through the window manager.

focus_displayof()¶

Return the widget which has currently the focus on the display where this widget is located.

Return None if the application does not have the focus.

focus_force()¶: Direct input focus to this widget even if the application does not have the focus. Use with caution!

focus_get()¶

Return the widget which has currently the focus in the application.

Use focus_displayof to allow working with several displays. Return None if application does not have the focus.

focus_lastfor()¶: Return the widget which would have the focus if top level for this widget gets the focus from the window manager.

focus_set()¶

Direct input focus to this widget.

If the application currently does not have the focus this widget will get the focus if the application gets the focus through the window manager.

focusmodel(model=None)¶: Set focus model to MODEL. “active” means that this widget will claim the focus itself, “passive” means that the window manager shall give the focus. Return current focus model if MODEL is None.

frame()¶: Return identifier for decorative frame of this widget if present.

geometry(newGeometry=None)¶: Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return current value if None is given.

getboolean(s)¶: Return a boolean value for Tcl boolean values true and false given as parameter.

getdouble¶: alias of __builtin__.float

getint¶: alias of __builtin__.int

getvar(name='PY_VAR')¶: Return value of Tcl variable NAME.

grab_current()¶: Return widget which has currently the grab in this application or None.

grab_release()¶: Release grab for this widget if currently set.

grab_set(timeout=30)¶

grab_set_global()¶

Set global grab for this widget.

A global grab directs all events to this and descendant widgets on the display. Use with caution - other applications do not get events anymore.

grab_status()¶: Return None, “local” or “global” if this widget has no, a local or a global grab.

grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)¶: Instruct the window manager that this widget shall only be resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the number of grid units requested in Tk_GeometryRequest.

grid_bbox(column=None, row=None, col2=None, row2=None)¶

Return a tuple of integer coordinates for the bounding box of this widget controlled by the geometry manager grid.

If COLUMN, ROW is given the bounding box applies from the cell with row and column 0 to the specified cell. If COL2 and ROW2 are given the bounding box starts at that cell.

The returned integers specify the offset of the upper left corner in the master widget and the width and height.

grid_columnconfigure(index, cnf={}, **kw)¶

Configure column INDEX of a grid.

Valid resources are minsize (minimum size of the column), weight (how much does additional space propagate to this column) and pad (how much space to let additionally).

grid_location(x, y)¶: Return a tuple of column and row which identify the cell at which the pixel at position X and Y inside the master widget is located.

grid_propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given, the current setting will be returned.

grid_rowconfigure(index, cnf={}, **kw)¶

Configure row INDEX of a grid.

Valid resources are minsize (minimum size of the row), weight (how much does additional space propagate to this row) and pad (how much space to let additionally).

grid_size()¶: Return a tuple of the number of column and rows in the grid.

grid_slaves(row=None, column=None)¶: Return a list of all slaves of this widget in its packing order.

group(pathName=None)¶: Set the group leader widgets for related widgets to PATHNAME. Return the group leader of this widget if None is given.

iconbitmap(bitmap=None, default=None)¶

Set bitmap for the iconified widget to BITMAP. Return the bitmap if None is given.

Under Windows, the DEFAULT parameter can be used to set the icon for the widget and any descendents that don’t have an icon set explicitly. DEFAULT can be the relative path to a .ico file (example: root.iconbitmap(default=’myicon.ico’) ). See Tk documentation for more information.

iconify()¶: Display widget as icon.

iconmask(bitmap=None)¶: Set mask for the icon bitmap of this widget. Return the mask if None is given.

iconname(newName=None)¶: Set the name of the icon for this widget. Return the name if None is given.

iconposition(x=None, y=None)¶: Set the position of the icon of this widget to X and Y. Return a tuple of the current values of X and X if None is given.

iconwindow(pathName=None)¶: Set widget PATHNAME to be displayed instead of icon. Return the current value if None is given.

image_names()¶: Return a list of all existing image names.

image_types()¶: Return a list of all available image types (e.g. photo bitmap).

keys()¶: Return a list of all resource names of this widget.

lift(aboveThis=None)¶: Raise this widget in the stacking order.

lower(belowThis=None)¶: Lower this widget in the stacking order.

mainloop(n=0)¶: Call the mainloop of Tk.

maxsize(width=None, height=None)¶: Set max WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

minsize(width=None, height=None)¶: Set min WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

nametowidget(name)¶: Return the Tkinter instance of a widget identified by its Tcl name NAME.

option_add(pattern, value, priority=None)¶

Set a VALUE (second parameter) for an option PATTERN (first parameter).

An optional third parameter gives the numeric priority (defaults to 80).

option_clear()¶

Clear the option database.

It will be reloaded if option_add is called.

option_get(name, className)¶

Return the value for an option NAME for this widget with CLASSNAME.

Values with higher priority override lower values.

option_readfile(fileName, priority=None)¶

Read file FILENAME into the option database.

An optional second parameter gives the numeric priority.

overrideredirect(boolean=None)¶: Instruct the window manager to ignore this widget if BOOLEAN is given with 1. Return the current value if None is given.

pack_propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given the current setting will be returned.

pack_slaves()¶: Return a list of all slaves of this widget in its packing order.

place_slaves()¶: Return a list of all slaves of this widget in its packing order.

positionfrom(who=None)¶: Instruct the window manager that the position of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given the current setting will be returned.

protocol(name=None, func=None)¶: Bind function FUNC to command NAME for this widget. Return the function bound to NAME if None is given. NAME could be e.g. “WM_SAVE_YOURSELF” or “WM_DELETE_WINDOW”.

quit()¶: Quit the Tcl interpreter. All widgets will be destroyed.

register(func, subst=None, needcleanup=1)¶: Return a newly created Tcl function. If this function is called, the Python function FUNC will be executed. An optional function SUBST can be given which will be executed before FUNC.

resizable(width=None, height=None)¶: Instruct the window manager whether this width can be resized in WIDTH or HEIGHT. Both values are boolean values.

rowconfigure(index, cnf={}, **kw)¶

Configure row INDEX of a grid.

Valid resources are minsize (minimum size of the row), weight (how much does additional space propagate to this row) and pad (how much space to let additionally).

selection_clear(**kw)¶: Clear the current X selection.

selection_get(**kw)¶

Return the contents of the current X selection.

A keyword parameter selection specifies the name of the selection and defaults to PRIMARY. A keyword parameter displayof specifies a widget on the display to use. A keyword parameter type specifies the form of data to be fetched, defaulting to STRING except on X11, where UTF8_STRING is tried before STRING.

selection_handle(command, **kw)¶

Specify a function COMMAND to call if the X selection owned by this widget is queried by another application.

This function must return the contents of the selection. The function will be called with the arguments OFFSET and LENGTH which allows the chunking of very long selections. The following keyword parameters can be provided: selection - name of the selection (default PRIMARY), type - type of the selection (e.g. STRING, FILE_NAME).

selection_own(**kw)¶

Become owner of X selection.

A keyword parameter selection specifies the name of the selection (default PRIMARY).

selection_own_get(**kw)¶

Return owner of X selection.

The following keyword parameter can be provided: selection - name of the selection (default PRIMARY), type - type of the selection (e.g. STRING, FILE_NAME).

send(interp, cmd, *args)¶: Send Tcl command CMD to different interpreter INTERP to be executed.

setvar(name='PY_VAR', value='1')¶: Set Tcl variable NAME to VALUE.

show()¶

size()¶: Return a tuple of the number of column and rows in the grid.

sizefrom(who=None)¶: Instruct the window manager that the size of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

slaves()¶: Return a list of all slaves of this widget in its packing order.

state(newstate=None)¶: Query or set the state of this widget as one of normal, icon, iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).

title(string=None)¶: Set the title of this widget.

tk_bisque()¶: Change the color scheme to light brown as used in Tk 3.6 and before.

tk_focusFollowsMouse()¶: The widget under mouse will get automatically focus. Can not be disabled easily.

tk_focusNext()¶

Return the next widget in the focus order which follows widget which has currently the focus.

The focus order first goes to the next child, then to the children of the child recursively and then to the next sibling which is higher in the stacking order. A widget is omitted if it has the takefocus resource set to 0.

tk_focusPrev()¶: Return previous widget in the focus order. See tk_focusNext for details.

tk_menuBar(*args)¶: Do not use. Needed in Tk 3.6 and earlier.

tk_setPalette(*args, **kw)¶

Set a new color scheme for all widget elements.

A single color as argument will cause that all colors of Tk widget elements are derived from this. Alternatively several keyword parameters and its associated colors can be given. The following keywords are valid: activeBackground, foreground, selectColor, activeForeground, highlightBackground, selectBackground, background, highlightColor, selectForeground, disabledForeground, insertBackground, troughColor.

tk_strictMotif(boolean=None)¶

Set Tcl internal variable, whether the look and feel should adhere to Motif.

A parameter of 1 means adhere to Motif (e.g. no color change if mouse passes over slider). Returns the set value.

tkraise(aboveThis=None)¶: Raise this widget in the stacking order.

transient(master=None)¶: Instruct the window manager that this widget is transient with regard to widget MASTER.

unbind(sequence, funcid=None)¶: Unbind for this widget for event SEQUENCE the function identified with FUNCID.

unbind_all(sequence)¶: Unbind for all widgets for event SEQUENCE all functions.

unbind_class(className, sequence)¶: Unbind for all widgets with bindtag CLASSNAME for event SEQUENCE all functions.

update()¶: Enter event loop until all pending events have been processed by Tcl.

update_idletasks()¶: Enter event loop until all idle callbacks have been called. This will update the display of windows but not process events caused by the user.

wait_variable(name='PY_VAR')¶

Wait until the variable is modified.

A parameter of type IntVar, StringVar, DoubleVar or BooleanVar must be given.

wait_visibility(window=None)¶

Wait until the visibility of a WIDGET changes (e.g. it appears).

If no parameter is given self is used.

wait_window(window=None)¶

Wait until a WIDGET is destroyed.

If no parameter is given self is used.

waitvar(name='PY_VAR')¶

Wait until the variable is modified.

A parameter of type IntVar, StringVar, DoubleVar or BooleanVar must be given.

winfo_atom(name, displayof=0)¶: Return integer which represents atom NAME.

winfo_atomname(id, displayof=0)¶: Return name of atom with identifier ID.

winfo_cells()¶: Return number of cells in the colormap for this widget.

winfo_children()¶: Return a list of all widgets which are children of this widget.

winfo_class()¶: Return window class name of this widget.

winfo_colormapfull()¶: Return true if at the last color request the colormap was full.

winfo_containing(rootX, rootY, displayof=0)¶: Return the widget which is at the root coordinates ROOTX, ROOTY.

winfo_depth()¶: Return the number of bits per pixel.

winfo_exists()¶: Return true if this widget exists.

winfo_fpixels(number)¶: Return the number of pixels for the given distance NUMBER (e.g. “3c”) as float.

winfo_geometry()¶: Return geometry string for this widget in the form “widthxheight+X+Y”.

winfo_height()¶: Return height of this widget.

winfo_id()¶: Return identifier ID for this widget.

winfo_interps(displayof=0)¶: Return the name of all Tcl interpreters for this display.

winfo_ismapped()¶: Return true if this widget is mapped.

winfo_manager()¶: Return the window manager name for this widget.

winfo_name()¶: Return the name of this widget.

winfo_parent()¶: Return the name of the parent of this widget.

winfo_pathname(id, displayof=0)¶: Return the pathname of the widget given by ID.

winfo_pixels(number)¶: Rounded integer value of winfo_fpixels.

winfo_pointerx()¶: Return the x coordinate of the pointer on the root window.

winfo_pointerxy()¶: Return a tuple of x and y coordinates of the pointer on the root window.

winfo_pointery()¶: Return the y coordinate of the pointer on the root window.

winfo_reqheight()¶: Return requested height of this widget.

winfo_reqwidth()¶: Return requested width of this widget.

winfo_rgb(color)¶: Return tuple of decimal values for red, green, blue for COLOR in this widget.

winfo_rootx()¶: Return x coordinate of upper left corner of this widget on the root window.

winfo_rooty()¶: Return y coordinate of upper left corner of this widget on the root window.

winfo_screen()¶: Return the screen name of this widget.

winfo_screencells()¶: Return the number of the cells in the colormap of the screen of this widget.

winfo_screendepth()¶: Return the number of bits per pixel of the root window of the screen of this widget.

winfo_screenheight()¶: Return the number of pixels of the height of the screen of this widget in pixel.

winfo_screenmmheight()¶: Return the number of pixels of the height of the screen of this widget in mm.

winfo_screenmmwidth()¶: Return the number of pixels of the width of the screen of this widget in mm.

winfo_screenvisual()¶: Return one of the strings directcolor, grayscale, pseudocolor, staticcolor, staticgray, or truecolor for the default colormodel of this screen.

winfo_screenwidth()¶: Return the number of pixels of the width of the screen of this widget in pixel.

winfo_server()¶: Return information of the X-Server of the screen of this widget in the form “XmajorRminor vendor vendorVersion”.

winfo_toplevel()¶: Return the toplevel widget of this widget.

winfo_viewable()¶: Return true if the widget and all its higher ancestors are mapped.

winfo_visual()¶: Return one of the strings directcolor, grayscale, pseudocolor, staticcolor, staticgray, or truecolor for the colormodel of this widget.

winfo_visualid()¶: Return the X identifier for the visual for this widget.

winfo_visualsavailable(includeids=0)¶

Return a list of all visuals available for the screen of this widget.

Each item in the list consists of a visual name (see winfo_visual), a depth and if INCLUDEIDS=1 is given also the X identifier.

winfo_vrootheight()¶: Return the height of the virtual root window associated with this widget in pixels. If there is no virtual root window return the height of the screen.

winfo_vrootwidth()¶: Return the width of the virtual root window associated with this widget in pixel. If there is no virtual root window return the width of the screen.

winfo_vrootx()¶: Return the x offset of the virtual root relative to the root window of the screen of this widget.

winfo_vrooty()¶: Return the y offset of the virtual root relative to the root window of the screen of this widget.

winfo_width()¶: Return the width of this widget.

winfo_x()¶: Return the x coordinate of the upper left corner of this widget in the parent.

winfo_y()¶: Return the y coordinate of the upper left corner of this widget in the parent.

withdraw()¶: Withdraw this widget from the screen such that it is unmapped and forgotten by the window manager. Re-draw it with wm_deiconify.

wm_aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)¶: Instruct the window manager to set the aspect ratio (width/height) of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple of the actual values if no argument is given.

wm_attributes(*args)¶

This subcommand returns or sets platform specific attributes

The first form returns a list of the platform specific flags and their values. The second form returns the value for the specific option. The third form sets one or more of the values. The values are as follows:

On Windows, -disabled gets or sets whether the window is in a disabled state. -toolwindow gets or sets the style of the window to toolwindow (as defined in the MSDN). -topmost gets or sets whether this is a topmost window (displays above all other windows).

On Macintosh, XXXXX

On Unix, there are currently no special attribute values.

wm_client(name=None)¶: Store NAME in WM_CLIENT_MACHINE property of this widget. Return current value.

wm_colormapwindows(*wlist)¶: Store list of window names (WLIST) into WM_COLORMAPWINDOWS property of this widget. This list contains windows whose colormaps differ from their parents. Return current list of widgets if WLIST is empty.

wm_command(value=None)¶: Store VALUE in WM_COMMAND property. It is the command which shall be used to invoke the application. Return current command if VALUE is None.

wm_deiconify()¶: Deiconify this widget. If it was never mapped it will not be mapped. On Windows it will raise this widget and give it the focus.

wm_focusmodel(model=None)¶: Set focus model to MODEL. “active” means that this widget will claim the focus itself, “passive” means that the window manager shall give the focus. Return current focus model if MODEL is None.

wm_frame()¶: Return identifier for decorative frame of this widget if present.

wm_geometry(newGeometry=None)¶: Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return current value if None is given.

wm_grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)¶: Instruct the window manager that this widget shall only be resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the number of grid units requested in Tk_GeometryRequest.

wm_group(pathName=None)¶: Set the group leader widgets for related widgets to PATHNAME. Return the group leader of this widget if None is given.

wm_iconbitmap(bitmap=None, default=None)¶

Set bitmap for the iconified widget to BITMAP. Return the bitmap if None is given.

Under Windows, the DEFAULT parameter can be used to set the icon for the widget and any descendents that don’t have an icon set explicitly. DEFAULT can be the relative path to a .ico file (example: root.iconbitmap(default=’myicon.ico’) ). See Tk documentation for more information.

wm_iconify()¶: Display widget as icon.

wm_iconmask(bitmap=None)¶: Set mask for the icon bitmap of this widget. Return the mask if None is given.

wm_iconname(newName=None)¶: Set the name of the icon for this widget. Return the name if None is given.

wm_iconposition(x=None, y=None)¶: Set the position of the icon of this widget to X and Y. Return a tuple of the current values of X and X if None is given.

wm_iconwindow(pathName=None)¶: Set widget PATHNAME to be displayed instead of icon. Return the current value if None is given.

wm_maxsize(width=None, height=None)¶: Set max WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

wm_minsize(width=None, height=None)¶: Set min WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

wm_overrideredirect(boolean=None)¶: Instruct the window manager to ignore this widget if BOOLEAN is given with 1. Return the current value if None is given.

wm_positionfrom(who=None)¶: Instruct the window manager that the position of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

wm_protocol(name=None, func=None)¶: Bind function FUNC to command NAME for this widget. Return the function bound to NAME if None is given. NAME could be e.g. “WM_SAVE_YOURSELF” or “WM_DELETE_WINDOW”.

wm_resizable(width=None, height=None)¶: Instruct the window manager whether this width can be resized in WIDTH or HEIGHT. Both values are boolean values.

wm_sizefrom(who=None)¶: Instruct the window manager that the size of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

wm_state(newstate=None)¶: Query or set the state of this widget as one of normal, icon, iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).

wm_title(string=None)¶: Set the title of this widget.

wm_transient(master=None)¶: Instruct the window manager that this widget is transient with regard to widget MASTER.

wm_withdraw()¶: Withdraw this widget from the screen such that it is unmapped and forgotten by the window manager. Re-draw it with wm_deiconify.

class robot.libraries.dialogs_py.InputDialog(message, default='', hidden=False)[source]¶

Bases: robot.libraries.dialogs_py._TkDialog

after(ms, func=None, *args)¶

Call function once after given time.

MS specifies the time in milliseconds. FUNC gives the function which shall be called. Additional parameters are given as parameters to the function call. Return identifier to cancel scheduling with after_cancel.

after_cancel(id)¶

Cancel scheduling of function identified with ID.

Identifier returned by after or after_idle must be given as first parameter.

after_idle(func, *args)¶

Call FUNC once if the Tcl main loop has no event to process.

Return an identifier to cancel the scheduling with after_cancel.

aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)¶: Instruct the window manager to set the aspect ratio (width/height) of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple of the actual values if no argument is given.

attributes(*args)¶

This subcommand returns or sets platform specific attributes

The first form returns a list of the platform specific flags and their values. The second form returns the value for the specific option. The third form sets one or more of the values. The values are as follows:

On Windows, -disabled gets or sets whether the window is in a disabled state. -toolwindow gets or sets the style of the window to toolwindow (as defined in the MSDN). -topmost gets or sets whether this is a topmost window (displays above all other windows).

On Macintosh, XXXXX

On Unix, there are currently no special attribute values.

bbox(column=None, row=None, col2=None, row2=None)¶

Return a tuple of integer coordinates for the bounding box of this widget controlled by the geometry manager grid.

If COLUMN, ROW is given the bounding box applies from the cell with row and column 0 to the specified cell. If COL2 and ROW2 are given the bounding box starts at that cell.

The returned integers specify the offset of the upper left corner in the master widget and the width and height.

bell(displayof=0)¶: Ring a display’s bell.

bind(sequence=None, func=None, add=None)¶

Bind to this widget at event SEQUENCE a call to function FUNC.

SEQUENCE is a string of concatenated event patterns. An event pattern is of the form <MODIFIER-MODIFIER-TYPE-DETAIL> where MODIFIER is one of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4, Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3, B3, Alt, Button4, B4, Double, Button5, B5 Triple, Mod1, M1. TYPE is one of Activate, Enter, Map, ButtonPress, Button, Expose, Motion, ButtonRelease FocusIn, MouseWheel, Circulate, FocusOut, Property, Colormap, Gravity Reparent, Configure, KeyPress, Key, Unmap, Deactivate, KeyRelease Visibility, Destroy, Leave and DETAIL is the button number for ButtonPress, ButtonRelease and DETAIL is the Keysym for KeyPress and KeyRelease. Examples are <Control-Button-1> for pressing Control and mouse button 1 or <Alt-A> for pressing A and the Alt key (KeyPress can be omitted). An event pattern can also be a virtual event of the form <<AString>> where AString can be arbitrary. This event can be generated by event_generate. If events are concatenated they must appear shortly after each other.

FUNC will be called if the event sequence occurs with an instance of Event as argument. If the return value of FUNC is “break” no further bound function is invoked.

An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function.

Bind will return an identifier to allow deletion of the bound function with unbind without memory leak.

If FUNC or SEQUENCE is omitted the bound function or list of bound events are returned.

bind_all(sequence=None, func=None, add=None)¶: Bind to all widgets at an event SEQUENCE a call to function FUNC. An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function. See bind for the return value.

bind_class(className, sequence=None, func=None, add=None)¶: Bind to widgets with bindtag CLASSNAME at event SEQUENCE a call of function FUNC. An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function. See bind for the return value.

bindtags(tagList=None)¶

Set or get the list of bindtags for this widget.

With no argument return the list of all bindtags associated with this widget. With a list of strings as argument the bindtags are set to this list. The bindtags determine in which order events are processed (see bind).

cget(key)¶: Return the resource value for a KEY given as string.

client(name=None)¶: Store NAME in WM_CLIENT_MACHINE property of this widget. Return current value.

clipboard_append(string, **kw)¶

Append STRING to the Tk clipboard.

A widget specified at the optional displayof keyword argument specifies the target display. The clipboard can be retrieved with selection_get.

clipboard_clear(**kw)¶

Clear the data in the Tk clipboard.

A widget specified for the optional displayof keyword argument specifies the target display.

clipboard_get(**kw)¶

Retrieve data from the clipboard on window’s display.

The window keyword defaults to the root window of the Tkinter application.

The type keyword specifies the form in which the data is to be returned and should be an atom name such as STRING or FILE_NAME. Type defaults to STRING, except on X11, where the default is to try UTF8_STRING and fall back to STRING.

This command is equivalent to:

selection_get(CLIPBOARD)

colormapwindows(*wlist)¶: Store list of window names (WLIST) into WM_COLORMAPWINDOWS property of this widget. This list contains windows whose colormaps differ from their parents. Return current list of widgets if WLIST is empty.

colormodel(value=None)¶: Useless. Not implemented in Tk.

columnconfigure(index, cnf={}, **kw)¶

Configure column INDEX of a grid.

Valid resources are minsize (minimum size of the column), weight (how much does additional space propagate to this column) and pad (how much space to let additionally).

command(value=None)¶: Store VALUE in WM_COMMAND property. It is the command which shall be used to invoke the application. Return current command if VALUE is None.

config(cnf=None, **kw)¶

Configure resources of a widget.

The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method keys.

configure(cnf=None, **kw)¶

Configure resources of a widget.

The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method keys.

deiconify()¶: Deiconify this widget. If it was never mapped it will not be mapped. On Windows it will raise this widget and give it the focus.

deletecommand(name)¶

Internal function.

Delete the Tcl command provided in NAME.

destroy()¶: Destroy this and all descendants widgets.

event_add(virtual, *sequences)¶: Bind a virtual event VIRTUAL (of the form <<Name>>) to an event SEQUENCE such that the virtual event is triggered whenever SEQUENCE occurs.

event_delete(virtual, *sequences)¶: Unbind a virtual event VIRTUAL from SEQUENCE.

event_generate(sequence, **kw)¶: Generate an event SEQUENCE. Additional keyword arguments specify parameter of the event (e.g. x, y, rootx, rooty).

event_info(virtual=None)¶: Return a list of all virtual events or the information about the SEQUENCE bound to the virtual event VIRTUAL.

focus()¶

Direct input focus to this widget.

If the application currently does not have the focus this widget will get the focus if the application gets the focus through the window manager.

focus_displayof()¶

Return the widget which has currently the focus on the display where this widget is located.

Return None if the application does not have the focus.

focus_force()¶: Direct input focus to this widget even if the application does not have the focus. Use with caution!

focus_get()¶

Return the widget which has currently the focus in the application.

Use focus_displayof to allow working with several displays. Return None if application does not have the focus.

focus_lastfor()¶: Return the widget which would have the focus if top level for this widget gets the focus from the window manager.

focus_set()¶

Direct input focus to this widget.

If the application currently does not have the focus this widget will get the focus if the application gets the focus through the window manager.

focusmodel(model=None)¶: Set focus model to MODEL. “active” means that this widget will claim the focus itself, “passive” means that the window manager shall give the focus. Return current focus model if MODEL is None.

frame()¶: Return identifier for decorative frame of this widget if present.

geometry(newGeometry=None)¶: Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return current value if None is given.

getboolean(s)¶: Return a boolean value for Tcl boolean values true and false given as parameter.

getdouble¶: alias of __builtin__.float

getint¶: alias of __builtin__.int

getvar(name='PY_VAR')¶: Return value of Tcl variable NAME.

grab_current()¶: Return widget which has currently the grab in this application or None.

grab_release()¶: Release grab for this widget if currently set.

grab_set(timeout=30)¶

grab_set_global()¶

Set global grab for this widget.

A global grab directs all events to this and descendant widgets on the display. Use with caution - other applications do not get events anymore.

grab_status()¶: Return None, “local” or “global” if this widget has no, a local or a global grab.

grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)¶: Instruct the window manager that this widget shall only be resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the number of grid units requested in Tk_GeometryRequest.

grid_bbox(column=None, row=None, col2=None, row2=None)¶

Return a tuple of integer coordinates for the bounding box of this widget controlled by the geometry manager grid.

If COLUMN, ROW is given the bounding box applies from the cell with row and column 0 to the specified cell. If COL2 and ROW2 are given the bounding box starts at that cell.

The returned integers specify the offset of the upper left corner in the master widget and the width and height.

grid_columnconfigure(index, cnf={}, **kw)¶

Configure column INDEX of a grid.

Valid resources are minsize (minimum size of the column), weight (how much does additional space propagate to this column) and pad (how much space to let additionally).

grid_location(x, y)¶: Return a tuple of column and row which identify the cell at which the pixel at position X and Y inside the master widget is located.

grid_propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given, the current setting will be returned.

grid_rowconfigure(index, cnf={}, **kw)¶

Configure row INDEX of a grid.

Valid resources are minsize (minimum size of the row), weight (how much does additional space propagate to this row) and pad (how much space to let additionally).

grid_size()¶: Return a tuple of the number of column and rows in the grid.

grid_slaves(row=None, column=None)¶: Return a list of all slaves of this widget in its packing order.

group(pathName=None)¶: Set the group leader widgets for related widgets to PATHNAME. Return the group leader of this widget if None is given.

iconbitmap(bitmap=None, default=None)¶

Set bitmap for the iconified widget to BITMAP. Return the bitmap if None is given.

Under Windows, the DEFAULT parameter can be used to set the icon for the widget and any descendents that don’t have an icon set explicitly. DEFAULT can be the relative path to a .ico file (example: root.iconbitmap(default=’myicon.ico’) ). See Tk documentation for more information.

iconify()¶: Display widget as icon.

iconmask(bitmap=None)¶: Set mask for the icon bitmap of this widget. Return the mask if None is given.

iconname(newName=None)¶: Set the name of the icon for this widget. Return the name if None is given.

iconposition(x=None, y=None)¶: Set the position of the icon of this widget to X and Y. Return a tuple of the current values of X and X if None is given.

iconwindow(pathName=None)¶: Set widget PATHNAME to be displayed instead of icon. Return the current value if None is given.

image_names()¶: Return a list of all existing image names.

image_types()¶: Return a list of all available image types (e.g. photo bitmap).

keys()¶: Return a list of all resource names of this widget.

lift(aboveThis=None)¶: Raise this widget in the stacking order.

lower(belowThis=None)¶: Lower this widget in the stacking order.

mainloop(n=0)¶: Call the mainloop of Tk.

maxsize(width=None, height=None)¶: Set max WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

minsize(width=None, height=None)¶: Set min WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

nametowidget(name)¶: Return the Tkinter instance of a widget identified by its Tcl name NAME.

option_add(pattern, value, priority=None)¶

Set a VALUE (second parameter) for an option PATTERN (first parameter).

An optional third parameter gives the numeric priority (defaults to 80).

option_clear()¶

Clear the option database.

It will be reloaded if option_add is called.

option_get(name, className)¶

Return the value for an option NAME for this widget with CLASSNAME.

Values with higher priority override lower values.

option_readfile(fileName, priority=None)¶

Read file FILENAME into the option database.

An optional second parameter gives the numeric priority.

overrideredirect(boolean=None)¶: Instruct the window manager to ignore this widget if BOOLEAN is given with 1. Return the current value if None is given.

pack_propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given the current setting will be returned.

pack_slaves()¶: Return a list of all slaves of this widget in its packing order.

place_slaves()¶: Return a list of all slaves of this widget in its packing order.

positionfrom(who=None)¶: Instruct the window manager that the position of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given the current setting will be returned.

protocol(name=None, func=None)¶: Bind function FUNC to command NAME for this widget. Return the function bound to NAME if None is given. NAME could be e.g. “WM_SAVE_YOURSELF” or “WM_DELETE_WINDOW”.

quit()¶: Quit the Tcl interpreter. All widgets will be destroyed.

register(func, subst=None, needcleanup=1)¶: Return a newly created Tcl function. If this function is called, the Python function FUNC will be executed. An optional function SUBST can be given which will be executed before FUNC.

resizable(width=None, height=None)¶: Instruct the window manager whether this width can be resized in WIDTH or HEIGHT. Both values are boolean values.

rowconfigure(index, cnf={}, **kw)¶

Configure row INDEX of a grid.

Valid resources are minsize (minimum size of the row), weight (how much does additional space propagate to this row) and pad (how much space to let additionally).

selection_clear(**kw)¶: Clear the current X selection.

selection_get(**kw)¶

Return the contents of the current X selection.

A keyword parameter selection specifies the name of the selection and defaults to PRIMARY. A keyword parameter displayof specifies a widget on the display to use. A keyword parameter type specifies the form of data to be fetched, defaulting to STRING except on X11, where UTF8_STRING is tried before STRING.

selection_handle(command, **kw)¶

Specify a function COMMAND to call if the X selection owned by this widget is queried by another application.

This function must return the contents of the selection. The function will be called with the arguments OFFSET and LENGTH which allows the chunking of very long selections. The following keyword parameters can be provided: selection - name of the selection (default PRIMARY), type - type of the selection (e.g. STRING, FILE_NAME).

selection_own(**kw)¶

Become owner of X selection.

A keyword parameter selection specifies the name of the selection (default PRIMARY).

selection_own_get(**kw)¶

Return owner of X selection.

The following keyword parameter can be provided: selection - name of the selection (default PRIMARY), type - type of the selection (e.g. STRING, FILE_NAME).

send(interp, cmd, *args)¶: Send Tcl command CMD to different interpreter INTERP to be executed.

setvar(name='PY_VAR', value='1')¶: Set Tcl variable NAME to VALUE.

show()¶

size()¶: Return a tuple of the number of column and rows in the grid.

sizefrom(who=None)¶: Instruct the window manager that the size of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

slaves()¶: Return a list of all slaves of this widget in its packing order.

state(newstate=None)¶: Query or set the state of this widget as one of normal, icon, iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).

title(string=None)¶: Set the title of this widget.

tk_bisque()¶: Change the color scheme to light brown as used in Tk 3.6 and before.

tk_focusFollowsMouse()¶: The widget under mouse will get automatically focus. Can not be disabled easily.

tk_focusNext()¶

Return the next widget in the focus order which follows widget which has currently the focus.

The focus order first goes to the next child, then to the children of the child recursively and then to the next sibling which is higher in the stacking order. A widget is omitted if it has the takefocus resource set to 0.

tk_focusPrev()¶: Return previous widget in the focus order. See tk_focusNext for details.

tk_menuBar(*args)¶: Do not use. Needed in Tk 3.6 and earlier.

tk_setPalette(*args, **kw)¶

Set a new color scheme for all widget elements.

A single color as argument will cause that all colors of Tk widget elements are derived from this. Alternatively several keyword parameters and its associated colors can be given. The following keywords are valid: activeBackground, foreground, selectColor, activeForeground, highlightBackground, selectBackground, background, highlightColor, selectForeground, disabledForeground, insertBackground, troughColor.

tk_strictMotif(boolean=None)¶

Set Tcl internal variable, whether the look and feel should adhere to Motif.

A parameter of 1 means adhere to Motif (e.g. no color change if mouse passes over slider). Returns the set value.

tkraise(aboveThis=None)¶: Raise this widget in the stacking order.

transient(master=None)¶: Instruct the window manager that this widget is transient with regard to widget MASTER.

unbind(sequence, funcid=None)¶: Unbind for this widget for event SEQUENCE the function identified with FUNCID.

unbind_all(sequence)¶: Unbind for all widgets for event SEQUENCE all functions.

unbind_class(className, sequence)¶: Unbind for all widgets with bindtag CLASSNAME for event SEQUENCE all functions.

update()¶: Enter event loop until all pending events have been processed by Tcl.

update_idletasks()¶: Enter event loop until all idle callbacks have been called. This will update the display of windows but not process events caused by the user.

wait_variable(name='PY_VAR')¶

Wait until the variable is modified.

A parameter of type IntVar, StringVar, DoubleVar or BooleanVar must be given.

wait_visibility(window=None)¶

Wait until the visibility of a WIDGET changes (e.g. it appears).

If no parameter is given self is used.

wait_window(window=None)¶

Wait until a WIDGET is destroyed.

If no parameter is given self is used.

waitvar(name='PY_VAR')¶

Wait until the variable is modified.

A parameter of type IntVar, StringVar, DoubleVar or BooleanVar must be given.

winfo_atom(name, displayof=0)¶: Return integer which represents atom NAME.

winfo_atomname(id, displayof=0)¶: Return name of atom with identifier ID.

winfo_cells()¶: Return number of cells in the colormap for this widget.

winfo_children()¶: Return a list of all widgets which are children of this widget.

winfo_class()¶: Return window class name of this widget.

winfo_colormapfull()¶: Return true if at the last color request the colormap was full.

winfo_containing(rootX, rootY, displayof=0)¶: Return the widget which is at the root coordinates ROOTX, ROOTY.

winfo_depth()¶: Return the number of bits per pixel.

winfo_exists()¶: Return true if this widget exists.

winfo_fpixels(number)¶: Return the number of pixels for the given distance NUMBER (e.g. “3c”) as float.

winfo_geometry()¶: Return geometry string for this widget in the form “widthxheight+X+Y”.

winfo_height()¶: Return height of this widget.

winfo_id()¶: Return identifier ID for this widget.

winfo_interps(displayof=0)¶: Return the name of all Tcl interpreters for this display.

winfo_ismapped()¶: Return true if this widget is mapped.

winfo_manager()¶: Return the window manager name for this widget.

winfo_name()¶: Return the name of this widget.

winfo_parent()¶: Return the name of the parent of this widget.

winfo_pathname(id, displayof=0)¶: Return the pathname of the widget given by ID.

winfo_pixels(number)¶: Rounded integer value of winfo_fpixels.

winfo_pointerx()¶: Return the x coordinate of the pointer on the root window.

winfo_pointerxy()¶: Return a tuple of x and y coordinates of the pointer on the root window.

winfo_pointery()¶: Return the y coordinate of the pointer on the root window.

winfo_reqheight()¶: Return requested height of this widget.

winfo_reqwidth()¶: Return requested width of this widget.

winfo_rgb(color)¶: Return tuple of decimal values for red, green, blue for COLOR in this widget.

winfo_rootx()¶: Return x coordinate of upper left corner of this widget on the root window.

winfo_rooty()¶: Return y coordinate of upper left corner of this widget on the root window.

winfo_screen()¶: Return the screen name of this widget.

winfo_screencells()¶: Return the number of the cells in the colormap of the screen of this widget.

winfo_screendepth()¶: Return the number of bits per pixel of the root window of the screen of this widget.

winfo_screenheight()¶: Return the number of pixels of the height of the screen of this widget in pixel.

winfo_screenmmheight()¶: Return the number of pixels of the height of the screen of this widget in mm.

winfo_screenmmwidth()¶: Return the number of pixels of the width of the screen of this widget in mm.

winfo_screenvisual()¶: Return one of the strings directcolor, grayscale, pseudocolor, staticcolor, staticgray, or truecolor for the default colormodel of this screen.

winfo_screenwidth()¶: Return the number of pixels of the width of the screen of this widget in pixel.

winfo_server()¶: Return information of the X-Server of the screen of this widget in the form “XmajorRminor vendor vendorVersion”.

winfo_toplevel()¶: Return the toplevel widget of this widget.

winfo_viewable()¶: Return true if the widget and all its higher ancestors are mapped.

winfo_visual()¶: Return one of the strings directcolor, grayscale, pseudocolor, staticcolor, staticgray, or truecolor for the colormodel of this widget.

winfo_visualid()¶: Return the X identifier for the visual for this widget.

winfo_visualsavailable(includeids=0)¶

Return a list of all visuals available for the screen of this widget.

Each item in the list consists of a visual name (see winfo_visual), a depth and if INCLUDEIDS=1 is given also the X identifier.

winfo_vrootheight()¶: Return the height of the virtual root window associated with this widget in pixels. If there is no virtual root window return the height of the screen.

winfo_vrootwidth()¶: Return the width of the virtual root window associated with this widget in pixel. If there is no virtual root window return the width of the screen.

winfo_vrootx()¶: Return the x offset of the virtual root relative to the root window of the screen of this widget.

winfo_vrooty()¶: Return the y offset of the virtual root relative to the root window of the screen of this widget.

winfo_width()¶: Return the width of this widget.

winfo_x()¶: Return the x coordinate of the upper left corner of this widget in the parent.

winfo_y()¶: Return the y coordinate of the upper left corner of this widget in the parent.

withdraw()¶: Withdraw this widget from the screen such that it is unmapped and forgotten by the window manager. Re-draw it with wm_deiconify.

wm_aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)¶: Instruct the window manager to set the aspect ratio (width/height) of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple of the actual values if no argument is given.

wm_attributes(*args)¶

This subcommand returns or sets platform specific attributes

The first form returns a list of the platform specific flags and their values. The second form returns the value for the specific option. The third form sets one or more of the values. The values are as follows:

On Windows, -disabled gets or sets whether the window is in a disabled state. -toolwindow gets or sets the style of the window to toolwindow (as defined in the MSDN). -topmost gets or sets whether this is a topmost window (displays above all other windows).

On Macintosh, XXXXX

On Unix, there are currently no special attribute values.

wm_client(name=None)¶: Store NAME in WM_CLIENT_MACHINE property of this widget. Return current value.

wm_colormapwindows(*wlist)¶: Store list of window names (WLIST) into WM_COLORMAPWINDOWS property of this widget. This list contains windows whose colormaps differ from their parents. Return current list of widgets if WLIST is empty.

wm_command(value=None)¶: Store VALUE in WM_COMMAND property. It is the command which shall be used to invoke the application. Return current command if VALUE is None.

wm_deiconify()¶: Deiconify this widget. If it was never mapped it will not be mapped. On Windows it will raise this widget and give it the focus.

wm_focusmodel(model=None)¶: Set focus model to MODEL. “active” means that this widget will claim the focus itself, “passive” means that the window manager shall give the focus. Return current focus model if MODEL is None.

wm_frame()¶: Return identifier for decorative frame of this widget if present.

wm_geometry(newGeometry=None)¶: Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return current value if None is given.

wm_grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)¶: Instruct the window manager that this widget shall only be resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the number of grid units requested in Tk_GeometryRequest.

wm_group(pathName=None)¶: Set the group leader widgets for related widgets to PATHNAME. Return the group leader of this widget if None is given.

wm_iconbitmap(bitmap=None, default=None)¶

Set bitmap for the iconified widget to BITMAP. Return the bitmap if None is given.

Under Windows, the DEFAULT parameter can be used to set the icon for the widget and any descendents that don’t have an icon set explicitly. DEFAULT can be the relative path to a .ico file (example: root.iconbitmap(default=’myicon.ico’) ). See Tk documentation for more information.

wm_iconify()¶: Display widget as icon.

wm_iconmask(bitmap=None)¶: Set mask for the icon bitmap of this widget. Return the mask if None is given.

wm_iconname(newName=None)¶: Set the name of the icon for this widget. Return the name if None is given.

wm_iconposition(x=None, y=None)¶: Set the position of the icon of this widget to X and Y. Return a tuple of the current values of X and X if None is given.

wm_iconwindow(pathName=None)¶: Set widget PATHNAME to be displayed instead of icon. Return the current value if None is given.

wm_maxsize(width=None, height=None)¶: Set max WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

wm_minsize(width=None, height=None)¶: Set min WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

wm_overrideredirect(boolean=None)¶: Instruct the window manager to ignore this widget if BOOLEAN is given with 1. Return the current value if None is given.

wm_positionfrom(who=None)¶: Instruct the window manager that the position of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

wm_protocol(name=None, func=None)¶: Bind function FUNC to command NAME for this widget. Return the function bound to NAME if None is given. NAME could be e.g. “WM_SAVE_YOURSELF” or “WM_DELETE_WINDOW”.

wm_resizable(width=None, height=None)¶: Instruct the window manager whether this width can be resized in WIDTH or HEIGHT. Both values are boolean values.

wm_sizefrom(who=None)¶: Instruct the window manager that the size of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

wm_state(newstate=None)¶: Query or set the state of this widget as one of normal, icon, iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).

wm_title(string=None)¶: Set the title of this widget.

wm_transient(master=None)¶: Instruct the window manager that this widget is transient with regard to widget MASTER.

wm_withdraw()¶: Withdraw this widget from the screen such that it is unmapped and forgotten by the window manager. Re-draw it with wm_deiconify.

class robot.libraries.dialogs_py.SelectionDialog(message, values)[source]¶

Bases: robot.libraries.dialogs_py._TkDialog

after(ms, func=None, *args)¶

Call function once after given time.

MS specifies the time in milliseconds. FUNC gives the function which shall be called. Additional parameters are given as parameters to the function call. Return identifier to cancel scheduling with after_cancel.

after_cancel(id)¶

Cancel scheduling of function identified with ID.

Identifier returned by after or after_idle must be given as first parameter.

after_idle(func, *args)¶

Call FUNC once if the Tcl main loop has no event to process.

Return an identifier to cancel the scheduling with after_cancel.

aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)¶: Instruct the window manager to set the aspect ratio (width/height) of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple of the actual values if no argument is given.

attributes(*args)¶

This subcommand returns or sets platform specific attributes

The first form returns a list of the platform specific flags and their values. The second form returns the value for the specific option. The third form sets one or more of the values. The values are as follows:

On Windows, -disabled gets or sets whether the window is in a disabled state. -toolwindow gets or sets the style of the window to toolwindow (as defined in the MSDN). -topmost gets or sets whether this is a topmost window (displays above all other windows).

On Macintosh, XXXXX

On Unix, there are currently no special attribute values.

bbox(column=None, row=None, col2=None, row2=None)¶

Return a tuple of integer coordinates for the bounding box of this widget controlled by the geometry manager grid.

If COLUMN, ROW is given the bounding box applies from the cell with row and column 0 to the specified cell. If COL2 and ROW2 are given the bounding box starts at that cell.

The returned integers specify the offset of the upper left corner in the master widget and the width and height.

bell(displayof=0)¶: Ring a display’s bell.

bind(sequence=None, func=None, add=None)¶

Bind to this widget at event SEQUENCE a call to function FUNC.

SEQUENCE is a string of concatenated event patterns. An event pattern is of the form <MODIFIER-MODIFIER-TYPE-DETAIL> where MODIFIER is one of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4, Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3, B3, Alt, Button4, B4, Double, Button5, B5 Triple, Mod1, M1. TYPE is one of Activate, Enter, Map, ButtonPress, Button, Expose, Motion, ButtonRelease FocusIn, MouseWheel, Circulate, FocusOut, Property, Colormap, Gravity Reparent, Configure, KeyPress, Key, Unmap, Deactivate, KeyRelease Visibility, Destroy, Leave and DETAIL is the button number for ButtonPress, ButtonRelease and DETAIL is the Keysym for KeyPress and KeyRelease. Examples are <Control-Button-1> for pressing Control and mouse button 1 or <Alt-A> for pressing A and the Alt key (KeyPress can be omitted). An event pattern can also be a virtual event of the form <<AString>> where AString can be arbitrary. This event can be generated by event_generate. If events are concatenated they must appear shortly after each other.

FUNC will be called if the event sequence occurs with an instance of Event as argument. If the return value of FUNC is “break” no further bound function is invoked.

An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function.

Bind will return an identifier to allow deletion of the bound function with unbind without memory leak.

If FUNC or SEQUENCE is omitted the bound function or list of bound events are returned.

bind_all(sequence=None, func=None, add=None)¶: Bind to all widgets at an event SEQUENCE a call to function FUNC. An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function. See bind for the return value.

bind_class(className, sequence=None, func=None, add=None)¶: Bind to widgets with bindtag CLASSNAME at event SEQUENCE a call of function FUNC. An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function. See bind for the return value.

bindtags(tagList=None)¶

Set or get the list of bindtags for this widget.

With no argument return the list of all bindtags associated with this widget. With a list of strings as argument the bindtags are set to this list. The bindtags determine in which order events are processed (see bind).

cget(key)¶: Return the resource value for a KEY given as string.

client(name=None)¶: Store NAME in WM_CLIENT_MACHINE property of this widget. Return current value.

clipboard_append(string, **kw)¶

Append STRING to the Tk clipboard.

A widget specified at the optional displayof keyword argument specifies the target display. The clipboard can be retrieved with selection_get.

clipboard_clear(**kw)¶

Clear the data in the Tk clipboard.

A widget specified for the optional displayof keyword argument specifies the target display.

clipboard_get(**kw)¶

Retrieve data from the clipboard on window’s display.

The window keyword defaults to the root window of the Tkinter application.

The type keyword specifies the form in which the data is to be returned and should be an atom name such as STRING or FILE_NAME. Type defaults to STRING, except on X11, where the default is to try UTF8_STRING and fall back to STRING.

This command is equivalent to:

selection_get(CLIPBOARD)

colormapwindows(*wlist)¶: Store list of window names (WLIST) into WM_COLORMAPWINDOWS property of this widget. This list contains windows whose colormaps differ from their parents. Return current list of widgets if WLIST is empty.

colormodel(value=None)¶: Useless. Not implemented in Tk.

columnconfigure(index, cnf={}, **kw)¶

Configure column INDEX of a grid.

Valid resources are minsize (minimum size of the column), weight (how much does additional space propagate to this column) and pad (how much space to let additionally).

command(value=None)¶: Store VALUE in WM_COMMAND property. It is the command which shall be used to invoke the application. Return current command if VALUE is None.

config(cnf=None, **kw)¶

Configure resources of a widget.

The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method keys.

configure(cnf=None, **kw)¶

Configure resources of a widget.

The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method keys.

deiconify()¶: Deiconify this widget. If it was never mapped it will not be mapped. On Windows it will raise this widget and give it the focus.

deletecommand(name)¶

Internal function.

Delete the Tcl command provided in NAME.

destroy()¶: Destroy this and all descendants widgets.

event_add(virtual, *sequences)¶: Bind a virtual event VIRTUAL (of the form <<Name>>) to an event SEQUENCE such that the virtual event is triggered whenever SEQUENCE occurs.

event_delete(virtual, *sequences)¶: Unbind a virtual event VIRTUAL from SEQUENCE.

event_generate(sequence, **kw)¶: Generate an event SEQUENCE. Additional keyword arguments specify parameter of the event (e.g. x, y, rootx, rooty).

event_info(virtual=None)¶: Return a list of all virtual events or the information about the SEQUENCE bound to the virtual event VIRTUAL.

focus()¶

Direct input focus to this widget.

If the application currently does not have the focus this widget will get the focus if the application gets the focus through the window manager.

focus_displayof()¶

Return the widget which has currently the focus on the display where this widget is located.

Return None if the application does not have the focus.

focus_force()¶: Direct input focus to this widget even if the application does not have the focus. Use with caution!

focus_get()¶

Return the widget which has currently the focus in the application.

Use focus_displayof to allow working with several displays. Return None if application does not have the focus.

focus_lastfor()¶: Return the widget which would have the focus if top level for this widget gets the focus from the window manager.

focus_set()¶

Direct input focus to this widget.

If the application currently does not have the focus this widget will get the focus if the application gets the focus through the window manager.

focusmodel(model=None)¶: Set focus model to MODEL. “active” means that this widget will claim the focus itself, “passive” means that the window manager shall give the focus. Return current focus model if MODEL is None.

frame()¶: Return identifier for decorative frame of this widget if present.

geometry(newGeometry=None)¶: Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return current value if None is given.

getboolean(s)¶: Return a boolean value for Tcl boolean values true and false given as parameter.

getdouble¶: alias of __builtin__.float

getint¶: alias of __builtin__.int

getvar(name='PY_VAR')¶: Return value of Tcl variable NAME.

grab_current()¶: Return widget which has currently the grab in this application or None.

grab_release()¶: Release grab for this widget if currently set.

grab_set(timeout=30)¶

grab_set_global()¶

Set global grab for this widget.

A global grab directs all events to this and descendant widgets on the display. Use with caution - other applications do not get events anymore.

grab_status()¶: Return None, “local” or “global” if this widget has no, a local or a global grab.

grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)¶: Instruct the window manager that this widget shall only be resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the number of grid units requested in Tk_GeometryRequest.

grid_bbox(column=None, row=None, col2=None, row2=None)¶

Return a tuple of integer coordinates for the bounding box of this widget controlled by the geometry manager grid.

If COLUMN, ROW is given the bounding box applies from the cell with row and column 0 to the specified cell. If COL2 and ROW2 are given the bounding box starts at that cell.

The returned integers specify the offset of the upper left corner in the master widget and the width and height.

grid_columnconfigure(index, cnf={}, **kw)¶

Configure column INDEX of a grid.

Valid resources are minsize (minimum size of the column), weight (how much does additional space propagate to this column) and pad (how much space to let additionally).

grid_location(x, y)¶: Return a tuple of column and row which identify the cell at which the pixel at position X and Y inside the master widget is located.

grid_propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given, the current setting will be returned.

grid_rowconfigure(index, cnf={}, **kw)¶

Configure row INDEX of a grid.

Valid resources are minsize (minimum size of the row), weight (how much does additional space propagate to this row) and pad (how much space to let additionally).

grid_size()¶: Return a tuple of the number of column and rows in the grid.

grid_slaves(row=None, column=None)¶: Return a list of all slaves of this widget in its packing order.

group(pathName=None)¶: Set the group leader widgets for related widgets to PATHNAME. Return the group leader of this widget if None is given.

iconbitmap(bitmap=None, default=None)¶

Set bitmap for the iconified widget to BITMAP. Return the bitmap if None is given.

Under Windows, the DEFAULT parameter can be used to set the icon for the widget and any descendents that don’t have an icon set explicitly. DEFAULT can be the relative path to a .ico file (example: root.iconbitmap(default=’myicon.ico’) ). See Tk documentation for more information.

iconify()¶: Display widget as icon.

iconmask(bitmap=None)¶: Set mask for the icon bitmap of this widget. Return the mask if None is given.

iconname(newName=None)¶: Set the name of the icon for this widget. Return the name if None is given.

iconposition(x=None, y=None)¶: Set the position of the icon of this widget to X and Y. Return a tuple of the current values of X and X if None is given.

iconwindow(pathName=None)¶: Set widget PATHNAME to be displayed instead of icon. Return the current value if None is given.

image_names()¶: Return a list of all existing image names.

image_types()¶: Return a list of all available image types (e.g. photo bitmap).

keys()¶: Return a list of all resource names of this widget.

lift(aboveThis=None)¶: Raise this widget in the stacking order.

lower(belowThis=None)¶: Lower this widget in the stacking order.

mainloop(n=0)¶: Call the mainloop of Tk.

maxsize(width=None, height=None)¶: Set max WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

minsize(width=None, height=None)¶: Set min WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

nametowidget(name)¶: Return the Tkinter instance of a widget identified by its Tcl name NAME.

option_add(pattern, value, priority=None)¶

Set a VALUE (second parameter) for an option PATTERN (first parameter).

An optional third parameter gives the numeric priority (defaults to 80).

option_clear()¶

Clear the option database.

It will be reloaded if option_add is called.

option_get(name, className)¶

Return the value for an option NAME for this widget with CLASSNAME.

Values with higher priority override lower values.

option_readfile(fileName, priority=None)¶

Read file FILENAME into the option database.

An optional second parameter gives the numeric priority.

overrideredirect(boolean=None)¶: Instruct the window manager to ignore this widget if BOOLEAN is given with 1. Return the current value if None is given.

pack_propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given the current setting will be returned.

pack_slaves()¶: Return a list of all slaves of this widget in its packing order.

place_slaves()¶: Return a list of all slaves of this widget in its packing order.

positionfrom(who=None)¶: Instruct the window manager that the position of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given the current setting will be returned.

protocol(name=None, func=None)¶: Bind function FUNC to command NAME for this widget. Return the function bound to NAME if None is given. NAME could be e.g. “WM_SAVE_YOURSELF” or “WM_DELETE_WINDOW”.

quit()¶: Quit the Tcl interpreter. All widgets will be destroyed.

register(func, subst=None, needcleanup=1)¶: Return a newly created Tcl function. If this function is called, the Python function FUNC will be executed. An optional function SUBST can be given which will be executed before FUNC.

resizable(width=None, height=None)¶: Instruct the window manager whether this width can be resized in WIDTH or HEIGHT. Both values are boolean values.

rowconfigure(index, cnf={}, **kw)¶

Configure row INDEX of a grid.

Valid resources are minsize (minimum size of the row), weight (how much does additional space propagate to this row) and pad (how much space to let additionally).

selection_clear(**kw)¶: Clear the current X selection.

selection_get(**kw)¶

Return the contents of the current X selection.

A keyword parameter selection specifies the name of the selection and defaults to PRIMARY. A keyword parameter displayof specifies a widget on the display to use. A keyword parameter type specifies the form of data to be fetched, defaulting to STRING except on X11, where UTF8_STRING is tried before STRING.

selection_handle(command, **kw)¶

Specify a function COMMAND to call if the X selection owned by this widget is queried by another application.

This function must return the contents of the selection. The function will be called with the arguments OFFSET and LENGTH which allows the chunking of very long selections. The following keyword parameters can be provided: selection - name of the selection (default PRIMARY), type - type of the selection (e.g. STRING, FILE_NAME).

selection_own(**kw)¶

Become owner of X selection.

A keyword parameter selection specifies the name of the selection (default PRIMARY).

selection_own_get(**kw)¶

Return owner of X selection.

The following keyword parameter can be provided: selection - name of the selection (default PRIMARY), type - type of the selection (e.g. STRING, FILE_NAME).

send(interp, cmd, *args)¶: Send Tcl command CMD to different interpreter INTERP to be executed.

setvar(name='PY_VAR', value='1')¶: Set Tcl variable NAME to VALUE.

show()¶

size()¶: Return a tuple of the number of column and rows in the grid.

sizefrom(who=None)¶: Instruct the window manager that the size of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

slaves()¶: Return a list of all slaves of this widget in its packing order.

state(newstate=None)¶: Query or set the state of this widget as one of normal, icon, iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).

title(string=None)¶: Set the title of this widget.

tk_bisque()¶: Change the color scheme to light brown as used in Tk 3.6 and before.

tk_focusFollowsMouse()¶: The widget under mouse will get automatically focus. Can not be disabled easily.

tk_focusNext()¶

Return the next widget in the focus order which follows widget which has currently the focus.

The focus order first goes to the next child, then to the children of the child recursively and then to the next sibling which is higher in the stacking order. A widget is omitted if it has the takefocus resource set to 0.

tk_focusPrev()¶: Return previous widget in the focus order. See tk_focusNext for details.

tk_menuBar(*args)¶: Do not use. Needed in Tk 3.6 and earlier.

tk_setPalette(*args, **kw)¶

Set a new color scheme for all widget elements.

A single color as argument will cause that all colors of Tk widget elements are derived from this. Alternatively several keyword parameters and its associated colors can be given. The following keywords are valid: activeBackground, foreground, selectColor, activeForeground, highlightBackground, selectBackground, background, highlightColor, selectForeground, disabledForeground, insertBackground, troughColor.

tk_strictMotif(boolean=None)¶

Set Tcl internal variable, whether the look and feel should adhere to Motif.

A parameter of 1 means adhere to Motif (e.g. no color change if mouse passes over slider). Returns the set value.

tkraise(aboveThis=None)¶: Raise this widget in the stacking order.

transient(master=None)¶: Instruct the window manager that this widget is transient with regard to widget MASTER.

unbind(sequence, funcid=None)¶: Unbind for this widget for event SEQUENCE the function identified with FUNCID.

unbind_all(sequence)¶: Unbind for all widgets for event SEQUENCE all functions.

unbind_class(className, sequence)¶: Unbind for all widgets with bindtag CLASSNAME for event SEQUENCE all functions.

update()¶: Enter event loop until all pending events have been processed by Tcl.

update_idletasks()¶: Enter event loop until all idle callbacks have been called. This will update the display of windows but not process events caused by the user.

wait_variable(name='PY_VAR')¶

Wait until the variable is modified.

A parameter of type IntVar, StringVar, DoubleVar or BooleanVar must be given.

wait_visibility(window=None)¶

Wait until the visibility of a WIDGET changes (e.g. it appears).

If no parameter is given self is used.

wait_window(window=None)¶

Wait until a WIDGET is destroyed.

If no parameter is given self is used.

waitvar(name='PY_VAR')¶

Wait until the variable is modified.

A parameter of type IntVar, StringVar, DoubleVar or BooleanVar must be given.

winfo_atom(name, displayof=0)¶: Return integer which represents atom NAME.

winfo_atomname(id, displayof=0)¶: Return name of atom with identifier ID.

winfo_cells()¶: Return number of cells in the colormap for this widget.

winfo_children()¶: Return a list of all widgets which are children of this widget.

winfo_class()¶: Return window class name of this widget.

winfo_colormapfull()¶: Return true if at the last color request the colormap was full.

winfo_containing(rootX, rootY, displayof=0)¶: Return the widget which is at the root coordinates ROOTX, ROOTY.

winfo_depth()¶: Return the number of bits per pixel.

winfo_exists()¶: Return true if this widget exists.

winfo_fpixels(number)¶: Return the number of pixels for the given distance NUMBER (e.g. “3c”) as float.

winfo_geometry()¶: Return geometry string for this widget in the form “widthxheight+X+Y”.

winfo_height()¶: Return height of this widget.

winfo_id()¶: Return identifier ID for this widget.

winfo_interps(displayof=0)¶: Return the name of all Tcl interpreters for this display.

winfo_ismapped()¶: Return true if this widget is mapped.

winfo_manager()¶: Return the window manager name for this widget.

winfo_name()¶: Return the name of this widget.

winfo_parent()¶: Return the name of the parent of this widget.

winfo_pathname(id, displayof=0)¶: Return the pathname of the widget given by ID.

winfo_pixels(number)¶: Rounded integer value of winfo_fpixels.

winfo_pointerx()¶: Return the x coordinate of the pointer on the root window.

winfo_pointerxy()¶: Return a tuple of x and y coordinates of the pointer on the root window.

winfo_pointery()¶: Return the y coordinate of the pointer on the root window.

winfo_reqheight()¶: Return requested height of this widget.

winfo_reqwidth()¶: Return requested width of this widget.

winfo_rgb(color)¶: Return tuple of decimal values for red, green, blue for COLOR in this widget.

winfo_rootx()¶: Return x coordinate of upper left corner of this widget on the root window.

winfo_rooty()¶: Return y coordinate of upper left corner of this widget on the root window.

winfo_screen()¶: Return the screen name of this widget.

winfo_screencells()¶: Return the number of the cells in the colormap of the screen of this widget.

winfo_screendepth()¶: Return the number of bits per pixel of the root window of the screen of this widget.

winfo_screenheight()¶: Return the number of pixels of the height of the screen of this widget in pixel.

winfo_screenmmheight()¶: Return the number of pixels of the height of the screen of this widget in mm.

winfo_screenmmwidth()¶: Return the number of pixels of the width of the screen of this widget in mm.

winfo_screenvisual()¶: Return one of the strings directcolor, grayscale, pseudocolor, staticcolor, staticgray, or truecolor for the default colormodel of this screen.

winfo_screenwidth()¶: Return the number of pixels of the width of the screen of this widget in pixel.

winfo_server()¶: Return information of the X-Server of the screen of this widget in the form “XmajorRminor vendor vendorVersion”.

winfo_toplevel()¶: Return the toplevel widget of this widget.

winfo_viewable()¶: Return true if the widget and all its higher ancestors are mapped.

winfo_visual()¶: Return one of the strings directcolor, grayscale, pseudocolor, staticcolor, staticgray, or truecolor for the colormodel of this widget.

winfo_visualid()¶: Return the X identifier for the visual for this widget.

winfo_visualsavailable(includeids=0)¶

Return a list of all visuals available for the screen of this widget.

Each item in the list consists of a visual name (see winfo_visual), a depth and if INCLUDEIDS=1 is given also the X identifier.

winfo_vrootheight()¶: Return the height of the virtual root window associated with this widget in pixels. If there is no virtual root window return the height of the screen.

winfo_vrootwidth()¶: Return the width of the virtual root window associated with this widget in pixel. If there is no virtual root window return the width of the screen.

winfo_vrootx()¶: Return the x offset of the virtual root relative to the root window of the screen of this widget.

winfo_vrooty()¶: Return the y offset of the virtual root relative to the root window of the screen of this widget.

winfo_width()¶: Return the width of this widget.

winfo_x()¶: Return the x coordinate of the upper left corner of this widget in the parent.

winfo_y()¶: Return the y coordinate of the upper left corner of this widget in the parent.

withdraw()¶: Withdraw this widget from the screen such that it is unmapped and forgotten by the window manager. Re-draw it with wm_deiconify.

wm_aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)¶: Instruct the window manager to set the aspect ratio (width/height) of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple of the actual values if no argument is given.

wm_attributes(*args)¶

This subcommand returns or sets platform specific attributes

The first form returns a list of the platform specific flags and their values. The second form returns the value for the specific option. The third form sets one or more of the values. The values are as follows:

On Windows, -disabled gets or sets whether the window is in a disabled state. -toolwindow gets or sets the style of the window to toolwindow (as defined in the MSDN). -topmost gets or sets whether this is a topmost window (displays above all other windows).

On Macintosh, XXXXX

On Unix, there are currently no special attribute values.

wm_client(name=None)¶: Store NAME in WM_CLIENT_MACHINE property of this widget. Return current value.

wm_colormapwindows(*wlist)¶: Store list of window names (WLIST) into WM_COLORMAPWINDOWS property of this widget. This list contains windows whose colormaps differ from their parents. Return current list of widgets if WLIST is empty.

wm_command(value=None)¶: Store VALUE in WM_COMMAND property. It is the command which shall be used to invoke the application. Return current command if VALUE is None.

wm_deiconify()¶: Deiconify this widget. If it was never mapped it will not be mapped. On Windows it will raise this widget and give it the focus.

wm_focusmodel(model=None)¶: Set focus model to MODEL. “active” means that this widget will claim the focus itself, “passive” means that the window manager shall give the focus. Return current focus model if MODEL is None.

wm_frame()¶: Return identifier for decorative frame of this widget if present.

wm_geometry(newGeometry=None)¶: Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return current value if None is given.

wm_grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)¶: Instruct the window manager that this widget shall only be resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the number of grid units requested in Tk_GeometryRequest.

wm_group(pathName=None)¶: Set the group leader widgets for related widgets to PATHNAME. Return the group leader of this widget if None is given.

wm_iconbitmap(bitmap=None, default=None)¶

Set bitmap for the iconified widget to BITMAP. Return the bitmap if None is given.

Under Windows, the DEFAULT parameter can be used to set the icon for the widget and any descendents that don’t have an icon set explicitly. DEFAULT can be the relative path to a .ico file (example: root.iconbitmap(default=’myicon.ico’) ). See Tk documentation for more information.

wm_iconify()¶: Display widget as icon.

wm_iconmask(bitmap=None)¶: Set mask for the icon bitmap of this widget. Return the mask if None is given.

wm_iconname(newName=None)¶: Set the name of the icon for this widget. Return the name if None is given.

wm_iconposition(x=None, y=None)¶: Set the position of the icon of this widget to X and Y. Return a tuple of the current values of X and X if None is given.

wm_iconwindow(pathName=None)¶: Set widget PATHNAME to be displayed instead of icon. Return the current value if None is given.

wm_maxsize(width=None, height=None)¶: Set max WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

wm_minsize(width=None, height=None)¶: Set min WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

wm_overrideredirect(boolean=None)¶: Instruct the window manager to ignore this widget if BOOLEAN is given with 1. Return the current value if None is given.

wm_positionfrom(who=None)¶: Instruct the window manager that the position of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

wm_protocol(name=None, func=None)¶: Bind function FUNC to command NAME for this widget. Return the function bound to NAME if None is given. NAME could be e.g. “WM_SAVE_YOURSELF” or “WM_DELETE_WINDOW”.

wm_resizable(width=None, height=None)¶: Instruct the window manager whether this width can be resized in WIDTH or HEIGHT. Both values are boolean values.

wm_sizefrom(who=None)¶: Instruct the window manager that the size of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

wm_state(newstate=None)¶: Query or set the state of this widget as one of normal, icon, iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).

wm_title(string=None)¶: Set the title of this widget.

wm_transient(master=None)¶: Instruct the window manager that this widget is transient with regard to widget MASTER.

wm_withdraw()¶: Withdraw this widget from the screen such that it is unmapped and forgotten by the window manager. Re-draw it with wm_deiconify.

class robot.libraries.dialogs_py.MultipleSelectionDialog(message, values)[source]¶

Bases: robot.libraries.dialogs_py._TkDialog

after(ms, func=None, *args)¶

Call function once after given time.

MS specifies the time in milliseconds. FUNC gives the function which shall be called. Additional parameters are given as parameters to the function call. Return identifier to cancel scheduling with after_cancel.

after_cancel(id)¶

Cancel scheduling of function identified with ID.

Identifier returned by after or after_idle must be given as first parameter.

after_idle(func, *args)¶

Call FUNC once if the Tcl main loop has no event to process.

Return an identifier to cancel the scheduling with after_cancel.

aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)¶: Instruct the window manager to set the aspect ratio (width/height) of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple of the actual values if no argument is given.

attributes(*args)¶

This subcommand returns or sets platform specific attributes

The first form returns a list of the platform specific flags and their values. The second form returns the value for the specific option. The third form sets one or more of the values. The values are as follows:

On Windows, -disabled gets or sets whether the window is in a disabled state. -toolwindow gets or sets the style of the window to toolwindow (as defined in the MSDN). -topmost gets or sets whether this is a topmost window (displays above all other windows).

On Macintosh, XXXXX

On Unix, there are currently no special attribute values.

bbox(column=None, row=None, col2=None, row2=None)¶

Return a tuple of integer coordinates for the bounding box of this widget controlled by the geometry manager grid.

If COLUMN, ROW is given the bounding box applies from the cell with row and column 0 to the specified cell. If COL2 and ROW2 are given the bounding box starts at that cell.

The returned integers specify the offset of the upper left corner in the master widget and the width and height.

bell(displayof=0)¶: Ring a display’s bell.

bind(sequence=None, func=None, add=None)¶

Bind to this widget at event SEQUENCE a call to function FUNC.

SEQUENCE is a string of concatenated event patterns. An event pattern is of the form <MODIFIER-MODIFIER-TYPE-DETAIL> where MODIFIER is one of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4, Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3, B3, Alt, Button4, B4, Double, Button5, B5 Triple, Mod1, M1. TYPE is one of Activate, Enter, Map, ButtonPress, Button, Expose, Motion, ButtonRelease FocusIn, MouseWheel, Circulate, FocusOut, Property, Colormap, Gravity Reparent, Configure, KeyPress, Key, Unmap, Deactivate, KeyRelease Visibility, Destroy, Leave and DETAIL is the button number for ButtonPress, ButtonRelease and DETAIL is the Keysym for KeyPress and KeyRelease. Examples are <Control-Button-1> for pressing Control and mouse button 1 or <Alt-A> for pressing A and the Alt key (KeyPress can be omitted). An event pattern can also be a virtual event of the form <<AString>> where AString can be arbitrary. This event can be generated by event_generate. If events are concatenated they must appear shortly after each other.

FUNC will be called if the event sequence occurs with an instance of Event as argument. If the return value of FUNC is “break” no further bound function is invoked.

An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function.

Bind will return an identifier to allow deletion of the bound function with unbind without memory leak.

If FUNC or SEQUENCE is omitted the bound function or list of bound events are returned.

bind_all(sequence=None, func=None, add=None)¶: Bind to all widgets at an event SEQUENCE a call to function FUNC. An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function. See bind for the return value.

bind_class(className, sequence=None, func=None, add=None)¶: Bind to widgets with bindtag CLASSNAME at event SEQUENCE a call of function FUNC. An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function. See bind for the return value.

bindtags(tagList=None)¶

Set or get the list of bindtags for this widget.

With no argument return the list of all bindtags associated with this widget. With a list of strings as argument the bindtags are set to this list. The bindtags determine in which order events are processed (see bind).

cget(key)¶: Return the resource value for a KEY given as string.

client(name=None)¶: Store NAME in WM_CLIENT_MACHINE property of this widget. Return current value.

clipboard_append(string, **kw)¶

Append STRING to the Tk clipboard.

A widget specified at the optional displayof keyword argument specifies the target display. The clipboard can be retrieved with selection_get.

clipboard_clear(**kw)¶

Clear the data in the Tk clipboard.

A widget specified for the optional displayof keyword argument specifies the target display.

clipboard_get(**kw)¶

Retrieve data from the clipboard on window’s display.

The window keyword defaults to the root window of the Tkinter application.

The type keyword specifies the form in which the data is to be returned and should be an atom name such as STRING or FILE_NAME. Type defaults to STRING, except on X11, where the default is to try UTF8_STRING and fall back to STRING.

This command is equivalent to:

selection_get(CLIPBOARD)

colormapwindows(*wlist)¶: Store list of window names (WLIST) into WM_COLORMAPWINDOWS property of this widget. This list contains windows whose colormaps differ from their parents. Return current list of widgets if WLIST is empty.

colormodel(value=None)¶: Useless. Not implemented in Tk.

columnconfigure(index, cnf={}, **kw)¶

Configure column INDEX of a grid.

Valid resources are minsize (minimum size of the column), weight (how much does additional space propagate to this column) and pad (how much space to let additionally).

command(value=None)¶: Store VALUE in WM_COMMAND property. It is the command which shall be used to invoke the application. Return current command if VALUE is None.

config(cnf=None, **kw)¶

Configure resources of a widget.

The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method keys.

configure(cnf=None, **kw)¶

Configure resources of a widget.

The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method keys.

deiconify()¶: Deiconify this widget. If it was never mapped it will not be mapped. On Windows it will raise this widget and give it the focus.

deletecommand(name)¶

Internal function.

Delete the Tcl command provided in NAME.

destroy()¶: Destroy this and all descendants widgets.

event_add(virtual, *sequences)¶: Bind a virtual event VIRTUAL (of the form <<Name>>) to an event SEQUENCE such that the virtual event is triggered whenever SEQUENCE occurs.

event_delete(virtual, *sequences)¶: Unbind a virtual event VIRTUAL from SEQUENCE.

event_generate(sequence, **kw)¶: Generate an event SEQUENCE. Additional keyword arguments specify parameter of the event (e.g. x, y, rootx, rooty).

event_info(virtual=None)¶: Return a list of all virtual events or the information about the SEQUENCE bound to the virtual event VIRTUAL.

focus()¶

Direct input focus to this widget.

If the application currently does not have the focus this widget will get the focus if the application gets the focus through the window manager.

focus_displayof()¶

Return the widget which has currently the focus on the display where this widget is located.

Return None if the application does not have the focus.

focus_force()¶: Direct input focus to this widget even if the application does not have the focus. Use with caution!

focus_get()¶

Return the widget which has currently the focus in the application.

Use focus_displayof to allow working with several displays. Return None if application does not have the focus.

focus_lastfor()¶: Return the widget which would have the focus if top level for this widget gets the focus from the window manager.

focus_set()¶

Direct input focus to this widget.

If the application currently does not have the focus this widget will get the focus if the application gets the focus through the window manager.

focusmodel(model=None)¶: Set focus model to MODEL. “active” means that this widget will claim the focus itself, “passive” means that the window manager shall give the focus. Return current focus model if MODEL is None.

frame()¶: Return identifier for decorative frame of this widget if present.

geometry(newGeometry=None)¶: Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return current value if None is given.

getboolean(s)¶: Return a boolean value for Tcl boolean values true and false given as parameter.

getdouble¶: alias of __builtin__.float

getint¶: alias of __builtin__.int

getvar(name='PY_VAR')¶: Return value of Tcl variable NAME.

grab_current()¶: Return widget which has currently the grab in this application or None.

grab_release()¶: Release grab for this widget if currently set.

grab_set(timeout=30)¶

grab_set_global()¶

Set global grab for this widget.

A global grab directs all events to this and descendant widgets on the display. Use with caution - other applications do not get events anymore.

grab_status()¶: Return None, “local” or “global” if this widget has no, a local or a global grab.

grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)¶: Instruct the window manager that this widget shall only be resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the number of grid units requested in Tk_GeometryRequest.

grid_bbox(column=None, row=None, col2=None, row2=None)¶

Return a tuple of integer coordinates for the bounding box of this widget controlled by the geometry manager grid.

If COLUMN, ROW is given the bounding box applies from the cell with row and column 0 to the specified cell. If COL2 and ROW2 are given the bounding box starts at that cell.

The returned integers specify the offset of the upper left corner in the master widget and the width and height.

grid_columnconfigure(index, cnf={}, **kw)¶

Configure column INDEX of a grid.

Valid resources are minsize (minimum size of the column), weight (how much does additional space propagate to this column) and pad (how much space to let additionally).

grid_location(x, y)¶: Return a tuple of column and row which identify the cell at which the pixel at position X and Y inside the master widget is located.

grid_propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given, the current setting will be returned.

grid_rowconfigure(index, cnf={}, **kw)¶

Configure row INDEX of a grid.

Valid resources are minsize (minimum size of the row), weight (how much does additional space propagate to this row) and pad (how much space to let additionally).

grid_size()¶: Return a tuple of the number of column and rows in the grid.

grid_slaves(row=None, column=None)¶: Return a list of all slaves of this widget in its packing order.

group(pathName=None)¶: Set the group leader widgets for related widgets to PATHNAME. Return the group leader of this widget if None is given.

iconbitmap(bitmap=None, default=None)¶

Set bitmap for the iconified widget to BITMAP. Return the bitmap if None is given.

Under Windows, the DEFAULT parameter can be used to set the icon for the widget and any descendents that don’t have an icon set explicitly. DEFAULT can be the relative path to a .ico file (example: root.iconbitmap(default=’myicon.ico’) ). See Tk documentation for more information.

iconify()¶: Display widget as icon.

iconmask(bitmap=None)¶: Set mask for the icon bitmap of this widget. Return the mask if None is given.

iconname(newName=None)¶: Set the name of the icon for this widget. Return the name if None is given.

iconposition(x=None, y=None)¶: Set the position of the icon of this widget to X and Y. Return a tuple of the current values of X and X if None is given.

iconwindow(pathName=None)¶: Set widget PATHNAME to be displayed instead of icon. Return the current value if None is given.

image_names()¶: Return a list of all existing image names.

image_types()¶: Return a list of all available image types (e.g. photo bitmap).

keys()¶: Return a list of all resource names of this widget.

lift(aboveThis=None)¶: Raise this widget in the stacking order.

lower(belowThis=None)¶: Lower this widget in the stacking order.

mainloop(n=0)¶: Call the mainloop of Tk.

maxsize(width=None, height=None)¶: Set max WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

minsize(width=None, height=None)¶: Set min WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

nametowidget(name)¶: Return the Tkinter instance of a widget identified by its Tcl name NAME.

option_add(pattern, value, priority=None)¶

Set a VALUE (second parameter) for an option PATTERN (first parameter).

An optional third parameter gives the numeric priority (defaults to 80).

option_clear()¶

Clear the option database.

It will be reloaded if option_add is called.

option_get(name, className)¶

Return the value for an option NAME for this widget with CLASSNAME.

Values with higher priority override lower values.

option_readfile(fileName, priority=None)¶

Read file FILENAME into the option database.

An optional second parameter gives the numeric priority.

overrideredirect(boolean=None)¶: Instruct the window manager to ignore this widget if BOOLEAN is given with 1. Return the current value if None is given.

pack_propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given the current setting will be returned.

pack_slaves()¶: Return a list of all slaves of this widget in its packing order.

place_slaves()¶: Return a list of all slaves of this widget in its packing order.

positionfrom(who=None)¶: Instruct the window manager that the position of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given the current setting will be returned.

protocol(name=None, func=None)¶: Bind function FUNC to command NAME for this widget. Return the function bound to NAME if None is given. NAME could be e.g. “WM_SAVE_YOURSELF” or “WM_DELETE_WINDOW”.

quit()¶: Quit the Tcl interpreter. All widgets will be destroyed.

register(func, subst=None, needcleanup=1)¶: Return a newly created Tcl function. If this function is called, the Python function FUNC will be executed. An optional function SUBST can be given which will be executed before FUNC.

resizable(width=None, height=None)¶: Instruct the window manager whether this width can be resized in WIDTH or HEIGHT. Both values are boolean values.

rowconfigure(index, cnf={}, **kw)¶

Configure row INDEX of a grid.

Valid resources are minsize (minimum size of the row), weight (how much does additional space propagate to this row) and pad (how much space to let additionally).

selection_clear(**kw)¶: Clear the current X selection.

selection_get(**kw)¶

Return the contents of the current X selection.

A keyword parameter selection specifies the name of the selection and defaults to PRIMARY. A keyword parameter displayof specifies a widget on the display to use. A keyword parameter type specifies the form of data to be fetched, defaulting to STRING except on X11, where UTF8_STRING is tried before STRING.

selection_handle(command, **kw)¶

Specify a function COMMAND to call if the X selection owned by this widget is queried by another application.

This function must return the contents of the selection. The function will be called with the arguments OFFSET and LENGTH which allows the chunking of very long selections. The following keyword parameters can be provided: selection - name of the selection (default PRIMARY), type - type of the selection (e.g. STRING, FILE_NAME).

selection_own(**kw)¶

Become owner of X selection.

A keyword parameter selection specifies the name of the selection (default PRIMARY).

selection_own_get(**kw)¶

Return owner of X selection.

The following keyword parameter can be provided: selection - name of the selection (default PRIMARY), type - type of the selection (e.g. STRING, FILE_NAME).

send(interp, cmd, *args)¶: Send Tcl command CMD to different interpreter INTERP to be executed.

setvar(name='PY_VAR', value='1')¶: Set Tcl variable NAME to VALUE.

show()¶

size()¶: Return a tuple of the number of column and rows in the grid.

sizefrom(who=None)¶: Instruct the window manager that the size of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

slaves()¶: Return a list of all slaves of this widget in its packing order.

state(newstate=None)¶: Query or set the state of this widget as one of normal, icon, iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).

title(string=None)¶: Set the title of this widget.

tk_bisque()¶: Change the color scheme to light brown as used in Tk 3.6 and before.

tk_focusFollowsMouse()¶: The widget under mouse will get automatically focus. Can not be disabled easily.

tk_focusNext()¶

Return the next widget in the focus order which follows widget which has currently the focus.

The focus order first goes to the next child, then to the children of the child recursively and then to the next sibling which is higher in the stacking order. A widget is omitted if it has the takefocus resource set to 0.

tk_focusPrev()¶: Return previous widget in the focus order. See tk_focusNext for details.

tk_menuBar(*args)¶: Do not use. Needed in Tk 3.6 and earlier.

tk_setPalette(*args, **kw)¶

Set a new color scheme for all widget elements.

A single color as argument will cause that all colors of Tk widget elements are derived from this. Alternatively several keyword parameters and its associated colors can be given. The following keywords are valid: activeBackground, foreground, selectColor, activeForeground, highlightBackground, selectBackground, background, highlightColor, selectForeground, disabledForeground, insertBackground, troughColor.

tk_strictMotif(boolean=None)¶

Set Tcl internal variable, whether the look and feel should adhere to Motif.

A parameter of 1 means adhere to Motif (e.g. no color change if mouse passes over slider). Returns the set value.

tkraise(aboveThis=None)¶: Raise this widget in the stacking order.

transient(master=None)¶: Instruct the window manager that this widget is transient with regard to widget MASTER.

unbind(sequence, funcid=None)¶: Unbind for this widget for event SEQUENCE the function identified with FUNCID.

unbind_all(sequence)¶: Unbind for all widgets for event SEQUENCE all functions.

unbind_class(className, sequence)¶: Unbind for all widgets with bindtag CLASSNAME for event SEQUENCE all functions.

update()¶: Enter event loop until all pending events have been processed by Tcl.

update_idletasks()¶: Enter event loop until all idle callbacks have been called. This will update the display of windows but not process events caused by the user.

wait_variable(name='PY_VAR')¶

Wait until the variable is modified.

A parameter of type IntVar, StringVar, DoubleVar or BooleanVar must be given.

wait_visibility(window=None)¶

Wait until the visibility of a WIDGET changes (e.g. it appears).

If no parameter is given self is used.

wait_window(window=None)¶

Wait until a WIDGET is destroyed.

If no parameter is given self is used.

waitvar(name='PY_VAR')¶

Wait until the variable is modified.

A parameter of type IntVar, StringVar, DoubleVar or BooleanVar must be given.

winfo_atom(name, displayof=0)¶: Return integer which represents atom NAME.

winfo_atomname(id, displayof=0)¶: Return name of atom with identifier ID.

winfo_cells()¶: Return number of cells in the colormap for this widget.

winfo_children()¶: Return a list of all widgets which are children of this widget.

winfo_class()¶: Return window class name of this widget.

winfo_colormapfull()¶: Return true if at the last color request the colormap was full.

winfo_containing(rootX, rootY, displayof=0)¶: Return the widget which is at the root coordinates ROOTX, ROOTY.

winfo_depth()¶: Return the number of bits per pixel.

winfo_exists()¶: Return true if this widget exists.

winfo_fpixels(number)¶: Return the number of pixels for the given distance NUMBER (e.g. “3c”) as float.

winfo_geometry()¶: Return geometry string for this widget in the form “widthxheight+X+Y”.

winfo_height()¶: Return height of this widget.

winfo_id()¶: Return identifier ID for this widget.

winfo_interps(displayof=0)¶: Return the name of all Tcl interpreters for this display.

winfo_ismapped()¶: Return true if this widget is mapped.

winfo_manager()¶: Return the window manager name for this widget.

winfo_name()¶: Return the name of this widget.

winfo_parent()¶: Return the name of the parent of this widget.

winfo_pathname(id, displayof=0)¶: Return the pathname of the widget given by ID.

winfo_pixels(number)¶: Rounded integer value of winfo_fpixels.

winfo_pointerx()¶: Return the x coordinate of the pointer on the root window.

winfo_pointerxy()¶: Return a tuple of x and y coordinates of the pointer on the root window.

winfo_pointery()¶: Return the y coordinate of the pointer on the root window.

winfo_reqheight()¶: Return requested height of this widget.

winfo_reqwidth()¶: Return requested width of this widget.

winfo_rgb(color)¶: Return tuple of decimal values for red, green, blue for COLOR in this widget.

winfo_rootx()¶: Return x coordinate of upper left corner of this widget on the root window.

winfo_rooty()¶: Return y coordinate of upper left corner of this widget on the root window.

winfo_screen()¶: Return the screen name of this widget.

winfo_screencells()¶: Return the number of the cells in the colormap of the screen of this widget.

winfo_screendepth()¶: Return the number of bits per pixel of the root window of the screen of this widget.

winfo_screenheight()¶: Return the number of pixels of the height of the screen of this widget in pixel.

winfo_screenmmheight()¶: Return the number of pixels of the height of the screen of this widget in mm.

winfo_screenmmwidth()¶: Return the number of pixels of the width of the screen of this widget in mm.

winfo_screenvisual()¶: Return one of the strings directcolor, grayscale, pseudocolor, staticcolor, staticgray, or truecolor for the default colormodel of this screen.

winfo_screenwidth()¶: Return the number of pixels of the width of the screen of this widget in pixel.

winfo_server()¶: Return information of the X-Server of the screen of this widget in the form “XmajorRminor vendor vendorVersion”.

winfo_toplevel()¶: Return the toplevel widget of this widget.

winfo_viewable()¶: Return true if the widget and all its higher ancestors are mapped.

winfo_visual()¶: Return one of the strings directcolor, grayscale, pseudocolor, staticcolor, staticgray, or truecolor for the colormodel of this widget.

winfo_visualid()¶: Return the X identifier for the visual for this widget.

winfo_visualsavailable(includeids=0)¶

Return a list of all visuals available for the screen of this widget.

Each item in the list consists of a visual name (see winfo_visual), a depth and if INCLUDEIDS=1 is given also the X identifier.

winfo_vrootheight()¶: Return the height of the virtual root window associated with this widget in pixels. If there is no virtual root window return the height of the screen.

winfo_vrootwidth()¶: Return the width of the virtual root window associated with this widget in pixel. If there is no virtual root window return the width of the screen.

winfo_vrootx()¶: Return the x offset of the virtual root relative to the root window of the screen of this widget.

winfo_vrooty()¶: Return the y offset of the virtual root relative to the root window of the screen of this widget.

winfo_width()¶: Return the width of this widget.

winfo_x()¶: Return the x coordinate of the upper left corner of this widget in the parent.

winfo_y()¶: Return the y coordinate of the upper left corner of this widget in the parent.

withdraw()¶: Withdraw this widget from the screen such that it is unmapped and forgotten by the window manager. Re-draw it with wm_deiconify.

wm_aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)¶: Instruct the window manager to set the aspect ratio (width/height) of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple of the actual values if no argument is given.

wm_attributes(*args)¶

This subcommand returns or sets platform specific attributes

The first form returns a list of the platform specific flags and their values. The second form returns the value for the specific option. The third form sets one or more of the values. The values are as follows:

On Windows, -disabled gets or sets whether the window is in a disabled state. -toolwindow gets or sets the style of the window to toolwindow (as defined in the MSDN). -topmost gets or sets whether this is a topmost window (displays above all other windows).

On Macintosh, XXXXX

On Unix, there are currently no special attribute values.

wm_client(name=None)¶: Store NAME in WM_CLIENT_MACHINE property of this widget. Return current value.

wm_colormapwindows(*wlist)¶: Store list of window names (WLIST) into WM_COLORMAPWINDOWS property of this widget. This list contains windows whose colormaps differ from their parents. Return current list of widgets if WLIST is empty.

wm_command(value=None)¶: Store VALUE in WM_COMMAND property. It is the command which shall be used to invoke the application. Return current command if VALUE is None.

wm_deiconify()¶: Deiconify this widget. If it was never mapped it will not be mapped. On Windows it will raise this widget and give it the focus.

wm_focusmodel(model=None)¶: Set focus model to MODEL. “active” means that this widget will claim the focus itself, “passive” means that the window manager shall give the focus. Return current focus model if MODEL is None.

wm_frame()¶: Return identifier for decorative frame of this widget if present.

wm_geometry(newGeometry=None)¶: Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return current value if None is given.

wm_grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)¶: Instruct the window manager that this widget shall only be resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the number of grid units requested in Tk_GeometryRequest.

wm_group(pathName=None)¶: Set the group leader widgets for related widgets to PATHNAME. Return the group leader of this widget if None is given.

wm_iconbitmap(bitmap=None, default=None)¶

Set bitmap for the iconified widget to BITMAP. Return the bitmap if None is given.

Under Windows, the DEFAULT parameter can be used to set the icon for the widget and any descendents that don’t have an icon set explicitly. DEFAULT can be the relative path to a .ico file (example: root.iconbitmap(default=’myicon.ico’) ). See Tk documentation for more information.

wm_iconify()¶: Display widget as icon.

wm_iconmask(bitmap=None)¶: Set mask for the icon bitmap of this widget. Return the mask if None is given.

wm_iconname(newName=None)¶: Set the name of the icon for this widget. Return the name if None is given.

wm_iconposition(x=None, y=None)¶: Set the position of the icon of this widget to X and Y. Return a tuple of the current values of X and X if None is given.

wm_iconwindow(pathName=None)¶: Set widget PATHNAME to be displayed instead of icon. Return the current value if None is given.

wm_maxsize(width=None, height=None)¶: Set max WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

wm_minsize(width=None, height=None)¶: Set min WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

wm_overrideredirect(boolean=None)¶: Instruct the window manager to ignore this widget if BOOLEAN is given with 1. Return the current value if None is given.

wm_positionfrom(who=None)¶: Instruct the window manager that the position of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

wm_protocol(name=None, func=None)¶: Bind function FUNC to command NAME for this widget. Return the function bound to NAME if None is given. NAME could be e.g. “WM_SAVE_YOURSELF” or “WM_DELETE_WINDOW”.

wm_resizable(width=None, height=None)¶: Instruct the window manager whether this width can be resized in WIDTH or HEIGHT. Both values are boolean values.

wm_sizefrom(who=None)¶: Instruct the window manager that the size of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

wm_state(newstate=None)¶: Query or set the state of this widget as one of normal, icon, iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).

wm_title(string=None)¶: Set the title of this widget.

wm_transient(master=None)¶: Instruct the window manager that this widget is transient with regard to widget MASTER.

wm_withdraw()¶: Withdraw this widget from the screen such that it is unmapped and forgotten by the window manager. Re-draw it with wm_deiconify.

class robot.libraries.dialogs_py.PassFailDialog(message, value=None, **extra)[source]¶

Bases: robot.libraries.dialogs_py._TkDialog

after(ms, func=None, *args)¶

Call function once after given time.

MS specifies the time in milliseconds. FUNC gives the function which shall be called. Additional parameters are given as parameters to the function call. Return identifier to cancel scheduling with after_cancel.

after_cancel(id)¶

Cancel scheduling of function identified with ID.

Identifier returned by after or after_idle must be given as first parameter.

after_idle(func, *args)¶

Call FUNC once if the Tcl main loop has no event to process.

Return an identifier to cancel the scheduling with after_cancel.

aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)¶: Instruct the window manager to set the aspect ratio (width/height) of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple of the actual values if no argument is given.

attributes(*args)¶

This subcommand returns or sets platform specific attributes

The first form returns a list of the platform specific flags and their values. The second form returns the value for the specific option. The third form sets one or more of the values. The values are as follows:

On Windows, -disabled gets or sets whether the window is in a disabled state. -toolwindow gets or sets the style of the window to toolwindow (as defined in the MSDN). -topmost gets or sets whether this is a topmost window (displays above all other windows).

On Macintosh, XXXXX

On Unix, there are currently no special attribute values.

bbox(column=None, row=None, col2=None, row2=None)¶

Return a tuple of integer coordinates for the bounding box of this widget controlled by the geometry manager grid.

If COLUMN, ROW is given the bounding box applies from the cell with row and column 0 to the specified cell. If COL2 and ROW2 are given the bounding box starts at that cell.

The returned integers specify the offset of the upper left corner in the master widget and the width and height.

bell(displayof=0)¶: Ring a display’s bell.

bind(sequence=None, func=None, add=None)¶

Bind to this widget at event SEQUENCE a call to function FUNC.

SEQUENCE is a string of concatenated event patterns. An event pattern is of the form <MODIFIER-MODIFIER-TYPE-DETAIL> where MODIFIER is one of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4, Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3, B3, Alt, Button4, B4, Double, Button5, B5 Triple, Mod1, M1. TYPE is one of Activate, Enter, Map, ButtonPress, Button, Expose, Motion, ButtonRelease FocusIn, MouseWheel, Circulate, FocusOut, Property, Colormap, Gravity Reparent, Configure, KeyPress, Key, Unmap, Deactivate, KeyRelease Visibility, Destroy, Leave and DETAIL is the button number for ButtonPress, ButtonRelease and DETAIL is the Keysym for KeyPress and KeyRelease. Examples are <Control-Button-1> for pressing Control and mouse button 1 or <Alt-A> for pressing A and the Alt key (KeyPress can be omitted). An event pattern can also be a virtual event of the form <<AString>> where AString can be arbitrary. This event can be generated by event_generate. If events are concatenated they must appear shortly after each other.

FUNC will be called if the event sequence occurs with an instance of Event as argument. If the return value of FUNC is “break” no further bound function is invoked.

An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function.

Bind will return an identifier to allow deletion of the bound function with unbind without memory leak.

If FUNC or SEQUENCE is omitted the bound function or list of bound events are returned.

bind_all(sequence=None, func=None, add=None)¶: Bind to all widgets at an event SEQUENCE a call to function FUNC. An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function. See bind for the return value.

bind_class(className, sequence=None, func=None, add=None)¶: Bind to widgets with bindtag CLASSNAME at event SEQUENCE a call of function FUNC. An additional boolean parameter ADD specifies whether FUNC will be called additionally to the other bound function or whether it will replace the previous function. See bind for the return value.

bindtags(tagList=None)¶

Set or get the list of bindtags for this widget.

With no argument return the list of all bindtags associated with this widget. With a list of strings as argument the bindtags are set to this list. The bindtags determine in which order events are processed (see bind).

cget(key)¶: Return the resource value for a KEY given as string.

client(name=None)¶: Store NAME in WM_CLIENT_MACHINE property of this widget. Return current value.

clipboard_append(string, **kw)¶

Append STRING to the Tk clipboard.

A widget specified at the optional displayof keyword argument specifies the target display. The clipboard can be retrieved with selection_get.

clipboard_clear(**kw)¶

Clear the data in the Tk clipboard.

A widget specified for the optional displayof keyword argument specifies the target display.

clipboard_get(**kw)¶

Retrieve data from the clipboard on window’s display.

The window keyword defaults to the root window of the Tkinter application.

The type keyword specifies the form in which the data is to be returned and should be an atom name such as STRING or FILE_NAME. Type defaults to STRING, except on X11, where the default is to try UTF8_STRING and fall back to STRING.

This command is equivalent to:

selection_get(CLIPBOARD)

colormapwindows(*wlist)¶: Store list of window names (WLIST) into WM_COLORMAPWINDOWS property of this widget. This list contains windows whose colormaps differ from their parents. Return current list of widgets if WLIST is empty.

colormodel(value=None)¶: Useless. Not implemented in Tk.

columnconfigure(index, cnf={}, **kw)¶

Configure column INDEX of a grid.

Valid resources are minsize (minimum size of the column), weight (how much does additional space propagate to this column) and pad (how much space to let additionally).

command(value=None)¶: Store VALUE in WM_COMMAND property. It is the command which shall be used to invoke the application. Return current command if VALUE is None.

config(cnf=None, **kw)¶

Configure resources of a widget.

The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method keys.

configure(cnf=None, **kw)¶

Configure resources of a widget.

The values for resources are specified as keyword arguments. To get an overview about the allowed keyword arguments call the method keys.

deiconify()¶: Deiconify this widget. If it was never mapped it will not be mapped. On Windows it will raise this widget and give it the focus.

deletecommand(name)¶

Internal function.

Delete the Tcl command provided in NAME.

destroy()¶: Destroy this and all descendants widgets.

event_add(virtual, *sequences)¶: Bind a virtual event VIRTUAL (of the form <<Name>>) to an event SEQUENCE such that the virtual event is triggered whenever SEQUENCE occurs.

event_delete(virtual, *sequences)¶: Unbind a virtual event VIRTUAL from SEQUENCE.

event_generate(sequence, **kw)¶: Generate an event SEQUENCE. Additional keyword arguments specify parameter of the event (e.g. x, y, rootx, rooty).

event_info(virtual=None)¶: Return a list of all virtual events or the information about the SEQUENCE bound to the virtual event VIRTUAL.

focus()¶

Direct input focus to this widget.

If the application currently does not have the focus this widget will get the focus if the application gets the focus through the window manager.

focus_displayof()¶

Return the widget which has currently the focus on the display where this widget is located.

Return None if the application does not have the focus.

focus_force()¶: Direct input focus to this widget even if the application does not have the focus. Use with caution!

focus_get()¶

Return the widget which has currently the focus in the application.

Use focus_displayof to allow working with several displays. Return None if application does not have the focus.

focus_lastfor()¶: Return the widget which would have the focus if top level for this widget gets the focus from the window manager.

focus_set()¶

Direct input focus to this widget.

If the application currently does not have the focus this widget will get the focus if the application gets the focus through the window manager.

focusmodel(model=None)¶: Set focus model to MODEL. “active” means that this widget will claim the focus itself, “passive” means that the window manager shall give the focus. Return current focus model if MODEL is None.

frame()¶: Return identifier for decorative frame of this widget if present.

geometry(newGeometry=None)¶: Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return current value if None is given.

getboolean(s)¶: Return a boolean value for Tcl boolean values true and false given as parameter.

getdouble¶: alias of __builtin__.float

getint¶: alias of __builtin__.int

getvar(name='PY_VAR')¶: Return value of Tcl variable NAME.

grab_current()¶: Return widget which has currently the grab in this application or None.

grab_release()¶: Release grab for this widget if currently set.

grab_set(timeout=30)¶

grab_set_global()¶

Set global grab for this widget.

A global grab directs all events to this and descendant widgets on the display. Use with caution - other applications do not get events anymore.

grab_status()¶: Return None, “local” or “global” if this widget has no, a local or a global grab.

grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)¶: Instruct the window manager that this widget shall only be resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the number of grid units requested in Tk_GeometryRequest.

grid_bbox(column=None, row=None, col2=None, row2=None)¶

Return a tuple of integer coordinates for the bounding box of this widget controlled by the geometry manager grid.

If COLUMN, ROW is given the bounding box applies from the cell with row and column 0 to the specified cell. If COL2 and ROW2 are given the bounding box starts at that cell.

The returned integers specify the offset of the upper left corner in the master widget and the width and height.

grid_columnconfigure(index, cnf={}, **kw)¶

Configure column INDEX of a grid.

Valid resources are minsize (minimum size of the column), weight (how much does additional space propagate to this column) and pad (how much space to let additionally).

grid_location(x, y)¶: Return a tuple of column and row which identify the cell at which the pixel at position X and Y inside the master widget is located.

grid_propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given, the current setting will be returned.

grid_rowconfigure(index, cnf={}, **kw)¶

Configure row INDEX of a grid.

Valid resources are minsize (minimum size of the row), weight (how much does additional space propagate to this row) and pad (how much space to let additionally).

grid_size()¶: Return a tuple of the number of column and rows in the grid.

grid_slaves(row=None, column=None)¶: Return a list of all slaves of this widget in its packing order.

group(pathName=None)¶: Set the group leader widgets for related widgets to PATHNAME. Return the group leader of this widget if None is given.

iconbitmap(bitmap=None, default=None)¶

Set bitmap for the iconified widget to BITMAP. Return the bitmap if None is given.

Under Windows, the DEFAULT parameter can be used to set the icon for the widget and any descendents that don’t have an icon set explicitly. DEFAULT can be the relative path to a .ico file (example: root.iconbitmap(default=’myicon.ico’) ). See Tk documentation for more information.

iconify()¶: Display widget as icon.

iconmask(bitmap=None)¶: Set mask for the icon bitmap of this widget. Return the mask if None is given.

iconname(newName=None)¶: Set the name of the icon for this widget. Return the name if None is given.

iconposition(x=None, y=None)¶: Set the position of the icon of this widget to X and Y. Return a tuple of the current values of X and X if None is given.

iconwindow(pathName=None)¶: Set widget PATHNAME to be displayed instead of icon. Return the current value if None is given.

image_names()¶: Return a list of all existing image names.

image_types()¶: Return a list of all available image types (e.g. photo bitmap).

keys()¶: Return a list of all resource names of this widget.

lift(aboveThis=None)¶: Raise this widget in the stacking order.

lower(belowThis=None)¶: Lower this widget in the stacking order.

mainloop(n=0)¶: Call the mainloop of Tk.

maxsize(width=None, height=None)¶: Set max WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

minsize(width=None, height=None)¶: Set min WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

nametowidget(name)¶: Return the Tkinter instance of a widget identified by its Tcl name NAME.

option_add(pattern, value, priority=None)¶

Set a VALUE (second parameter) for an option PATTERN (first parameter).

An optional third parameter gives the numeric priority (defaults to 80).

option_clear()¶

Clear the option database.

It will be reloaded if option_add is called.

option_get(name, className)¶

Return the value for an option NAME for this widget with CLASSNAME.

Values with higher priority override lower values.

option_readfile(fileName, priority=None)¶

Read file FILENAME into the option database.

An optional second parameter gives the numeric priority.

overrideredirect(boolean=None)¶: Instruct the window manager to ignore this widget if BOOLEAN is given with 1. Return the current value if None is given.

pack_propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given the current setting will be returned.

pack_slaves()¶: Return a list of all slaves of this widget in its packing order.

place_slaves()¶: Return a list of all slaves of this widget in its packing order.

positionfrom(who=None)¶: Instruct the window manager that the position of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

propagate(flag=['_noarg_'])¶

Set or get the status for propagation of geometry information.

A boolean argument specifies whether the geometry information of the slaves will determine the size of this widget. If no argument is given the current setting will be returned.

protocol(name=None, func=None)¶: Bind function FUNC to command NAME for this widget. Return the function bound to NAME if None is given. NAME could be e.g. “WM_SAVE_YOURSELF” or “WM_DELETE_WINDOW”.

quit()¶: Quit the Tcl interpreter. All widgets will be destroyed.

register(func, subst=None, needcleanup=1)¶: Return a newly created Tcl function. If this function is called, the Python function FUNC will be executed. An optional function SUBST can be given which will be executed before FUNC.

resizable(width=None, height=None)¶: Instruct the window manager whether this width can be resized in WIDTH or HEIGHT. Both values are boolean values.

rowconfigure(index, cnf={}, **kw)¶

Configure row INDEX of a grid.

Valid resources are minsize (minimum size of the row), weight (how much does additional space propagate to this row) and pad (how much space to let additionally).

selection_clear(**kw)¶: Clear the current X selection.

selection_get(**kw)¶

Return the contents of the current X selection.

A keyword parameter selection specifies the name of the selection and defaults to PRIMARY. A keyword parameter displayof specifies a widget on the display to use. A keyword parameter type specifies the form of data to be fetched, defaulting to STRING except on X11, where UTF8_STRING is tried before STRING.

selection_handle(command, **kw)¶

Specify a function COMMAND to call if the X selection owned by this widget is queried by another application.

This function must return the contents of the selection. The function will be called with the arguments OFFSET and LENGTH which allows the chunking of very long selections. The following keyword parameters can be provided: selection - name of the selection (default PRIMARY), type - type of the selection (e.g. STRING, FILE_NAME).

selection_own(**kw)¶

Become owner of X selection.

A keyword parameter selection specifies the name of the selection (default PRIMARY).

selection_own_get(**kw)¶

Return owner of X selection.

The following keyword parameter can be provided: selection - name of the selection (default PRIMARY), type - type of the selection (e.g. STRING, FILE_NAME).

send(interp, cmd, *args)¶: Send Tcl command CMD to different interpreter INTERP to be executed.

setvar(name='PY_VAR', value='1')¶: Set Tcl variable NAME to VALUE.

show()¶

size()¶: Return a tuple of the number of column and rows in the grid.

sizefrom(who=None)¶: Instruct the window manager that the size of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

slaves()¶: Return a list of all slaves of this widget in its packing order.

state(newstate=None)¶: Query or set the state of this widget as one of normal, icon, iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).

title(string=None)¶: Set the title of this widget.

tk_bisque()¶: Change the color scheme to light brown as used in Tk 3.6 and before.

tk_focusFollowsMouse()¶: The widget under mouse will get automatically focus. Can not be disabled easily.

tk_focusNext()¶

Return the next widget in the focus order which follows widget which has currently the focus.

The focus order first goes to the next child, then to the children of the child recursively and then to the next sibling which is higher in the stacking order. A widget is omitted if it has the takefocus resource set to 0.

tk_focusPrev()¶: Return previous widget in the focus order. See tk_focusNext for details.

tk_menuBar(*args)¶: Do not use. Needed in Tk 3.6 and earlier.

tk_setPalette(*args, **kw)¶

Set a new color scheme for all widget elements.

A single color as argument will cause that all colors of Tk widget elements are derived from this. Alternatively several keyword parameters and its associated colors can be given. The following keywords are valid: activeBackground, foreground, selectColor, activeForeground, highlightBackground, selectBackground, background, highlightColor, selectForeground, disabledForeground, insertBackground, troughColor.

tk_strictMotif(boolean=None)¶

Set Tcl internal variable, whether the look and feel should adhere to Motif.

A parameter of 1 means adhere to Motif (e.g. no color change if mouse passes over slider). Returns the set value.

tkraise(aboveThis=None)¶: Raise this widget in the stacking order.

transient(master=None)¶: Instruct the window manager that this widget is transient with regard to widget MASTER.

unbind(sequence, funcid=None)¶: Unbind for this widget for event SEQUENCE the function identified with FUNCID.

unbind_all(sequence)¶: Unbind for all widgets for event SEQUENCE all functions.

unbind_class(className, sequence)¶: Unbind for all widgets with bindtag CLASSNAME for event SEQUENCE all functions.

update()¶: Enter event loop until all pending events have been processed by Tcl.

update_idletasks()¶: Enter event loop until all idle callbacks have been called. This will update the display of windows but not process events caused by the user.

wait_variable(name='PY_VAR')¶

Wait until the variable is modified.

A parameter of type IntVar, StringVar, DoubleVar or BooleanVar must be given.

wait_visibility(window=None)¶

Wait until the visibility of a WIDGET changes (e.g. it appears).

If no parameter is given self is used.

wait_window(window=None)¶

Wait until a WIDGET is destroyed.

If no parameter is given self is used.

waitvar(name='PY_VAR')¶

Wait until the variable is modified.

A parameter of type IntVar, StringVar, DoubleVar or BooleanVar must be given.

winfo_atom(name, displayof=0)¶: Return integer which represents atom NAME.

winfo_atomname(id, displayof=0)¶: Return name of atom with identifier ID.

winfo_cells()¶: Return number of cells in the colormap for this widget.

winfo_children()¶: Return a list of all widgets which are children of this widget.

winfo_class()¶: Return window class name of this widget.

winfo_colormapfull()¶: Return true if at the last color request the colormap was full.

winfo_containing(rootX, rootY, displayof=0)¶: Return the widget which is at the root coordinates ROOTX, ROOTY.

winfo_depth()¶: Return the number of bits per pixel.

winfo_exists()¶: Return true if this widget exists.

winfo_fpixels(number)¶: Return the number of pixels for the given distance NUMBER (e.g. “3c”) as float.

winfo_geometry()¶: Return geometry string for this widget in the form “widthxheight+X+Y”.

winfo_height()¶: Return height of this widget.

winfo_id()¶: Return identifier ID for this widget.

winfo_interps(displayof=0)¶: Return the name of all Tcl interpreters for this display.

winfo_ismapped()¶: Return true if this widget is mapped.

winfo_manager()¶: Return the window manager name for this widget.

winfo_name()¶: Return the name of this widget.

winfo_parent()¶: Return the name of the parent of this widget.

winfo_pathname(id, displayof=0)¶: Return the pathname of the widget given by ID.

winfo_pixels(number)¶: Rounded integer value of winfo_fpixels.

winfo_pointerx()¶: Return the x coordinate of the pointer on the root window.

winfo_pointerxy()¶: Return a tuple of x and y coordinates of the pointer on the root window.

winfo_pointery()¶: Return the y coordinate of the pointer on the root window.

winfo_reqheight()¶: Return requested height of this widget.

winfo_reqwidth()¶: Return requested width of this widget.

winfo_rgb(color)¶: Return tuple of decimal values for red, green, blue for COLOR in this widget.

winfo_rootx()¶: Return x coordinate of upper left corner of this widget on the root window.

winfo_rooty()¶: Return y coordinate of upper left corner of this widget on the root window.

winfo_screen()¶: Return the screen name of this widget.

winfo_screencells()¶: Return the number of the cells in the colormap of the screen of this widget.

winfo_screendepth()¶: Return the number of bits per pixel of the root window of the screen of this widget.

winfo_screenheight()¶: Return the number of pixels of the height of the screen of this widget in pixel.

winfo_screenmmheight()¶: Return the number of pixels of the height of the screen of this widget in mm.

winfo_screenmmwidth()¶: Return the number of pixels of the width of the screen of this widget in mm.

winfo_screenvisual()¶: Return one of the strings directcolor, grayscale, pseudocolor, staticcolor, staticgray, or truecolor for the default colormodel of this screen.

winfo_screenwidth()¶: Return the number of pixels of the width of the screen of this widget in pixel.

winfo_server()¶: Return information of the X-Server of the screen of this widget in the form “XmajorRminor vendor vendorVersion”.

winfo_toplevel()¶: Return the toplevel widget of this widget.

winfo_viewable()¶: Return true if the widget and all its higher ancestors are mapped.

winfo_visual()¶: Return one of the strings directcolor, grayscale, pseudocolor, staticcolor, staticgray, or truecolor for the colormodel of this widget.

winfo_visualid()¶: Return the X identifier for the visual for this widget.

winfo_visualsavailable(includeids=0)¶

Return a list of all visuals available for the screen of this widget.

Each item in the list consists of a visual name (see winfo_visual), a depth and if INCLUDEIDS=1 is given also the X identifier.

winfo_vrootheight()¶: Return the height of the virtual root window associated with this widget in pixels. If there is no virtual root window return the height of the screen.

winfo_vrootwidth()¶: Return the width of the virtual root window associated with this widget in pixel. If there is no virtual root window return the width of the screen.

winfo_vrootx()¶: Return the x offset of the virtual root relative to the root window of the screen of this widget.

winfo_vrooty()¶: Return the y offset of the virtual root relative to the root window of the screen of this widget.

winfo_width()¶: Return the width of this widget.

winfo_x()¶: Return the x coordinate of the upper left corner of this widget in the parent.

winfo_y()¶: Return the y coordinate of the upper left corner of this widget in the parent.

withdraw()¶: Withdraw this widget from the screen such that it is unmapped and forgotten by the window manager. Re-draw it with wm_deiconify.

wm_aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)¶: Instruct the window manager to set the aspect ratio (width/height) of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple of the actual values if no argument is given.

wm_attributes(*args)¶

This subcommand returns or sets platform specific attributes

The first form returns a list of the platform specific flags and their values. The second form returns the value for the specific option. The third form sets one or more of the values. The values are as follows:

On Windows, -disabled gets or sets whether the window is in a disabled state. -toolwindow gets or sets the style of the window to toolwindow (as defined in the MSDN). -topmost gets or sets whether this is a topmost window (displays above all other windows).

On Macintosh, XXXXX

On Unix, there are currently no special attribute values.

wm_client(name=None)¶: Store NAME in WM_CLIENT_MACHINE property of this widget. Return current value.

wm_colormapwindows(*wlist)¶: Store list of window names (WLIST) into WM_COLORMAPWINDOWS property of this widget. This list contains windows whose colormaps differ from their parents. Return current list of widgets if WLIST is empty.

wm_command(value=None)¶: Store VALUE in WM_COMMAND property. It is the command which shall be used to invoke the application. Return current command if VALUE is None.

wm_deiconify()¶: Deiconify this widget. If it was never mapped it will not be mapped. On Windows it will raise this widget and give it the focus.

wm_focusmodel(model=None)¶: Set focus model to MODEL. “active” means that this widget will claim the focus itself, “passive” means that the window manager shall give the focus. Return current focus model if MODEL is None.

wm_frame()¶: Return identifier for decorative frame of this widget if present.

wm_geometry(newGeometry=None)¶: Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return current value if None is given.

wm_grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)¶: Instruct the window manager that this widget shall only be resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the number of grid units requested in Tk_GeometryRequest.

wm_group(pathName=None)¶: Set the group leader widgets for related widgets to PATHNAME. Return the group leader of this widget if None is given.

wm_iconbitmap(bitmap=None, default=None)¶

Set bitmap for the iconified widget to BITMAP. Return the bitmap if None is given.

Under Windows, the DEFAULT parameter can be used to set the icon for the widget and any descendents that don’t have an icon set explicitly. DEFAULT can be the relative path to a .ico file (example: root.iconbitmap(default=’myicon.ico’) ). See Tk documentation for more information.

wm_iconify()¶: Display widget as icon.

wm_iconmask(bitmap=None)¶: Set mask for the icon bitmap of this widget. Return the mask if None is given.

wm_iconname(newName=None)¶: Set the name of the icon for this widget. Return the name if None is given.

wm_iconposition(x=None, y=None)¶: Set the position of the icon of this widget to X and Y. Return a tuple of the current values of X and X if None is given.

wm_iconwindow(pathName=None)¶: Set widget PATHNAME to be displayed instead of icon. Return the current value if None is given.

wm_maxsize(width=None, height=None)¶: Set max WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

wm_minsize(width=None, height=None)¶: Set min WIDTH and HEIGHT for this widget. If the window is gridded the values are given in grid units. Return the current values if None is given.

wm_overrideredirect(boolean=None)¶: Instruct the window manager to ignore this widget if BOOLEAN is given with 1. Return the current value if None is given.

wm_positionfrom(who=None)¶: Instruct the window manager that the position of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

wm_protocol(name=None, func=None)¶: Bind function FUNC to command NAME for this widget. Return the function bound to NAME if None is given. NAME could be e.g. “WM_SAVE_YOURSELF” or “WM_DELETE_WINDOW”.

wm_resizable(width=None, height=None)¶: Instruct the window manager whether this width can be resized in WIDTH or HEIGHT. Both values are boolean values.

wm_sizefrom(who=None)¶: Instruct the window manager that the size of this widget shall be defined by the user if WHO is “user”, and by its own policy if WHO is “program”.

wm_state(newstate=None)¶: Query or set the state of this widget as one of normal, icon, iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).

wm_title(string=None)¶: Set the title of this widget.

wm_transient(master=None)¶: Instruct the window manager that this widget is transient with regard to widget MASTER.

wm_withdraw()¶: Withdraw this widget from the screen such that it is unmapped and forgotten by the window manager. Re-draw it with wm_deiconify.

robot.model package¶

Package with generic, reusable and extensible model classes.

This package contains, for example, TestSuite, TestCase, Keyword and SuiteVisitor base classes. These classes are extended both by execution and result related model objects and used also elsewhere.

This package is considered stable.

Submodules¶

robot.model.body module¶

class robot.model.body.BodyItem[source]¶

Bases: robot.model.modelobject.ModelObject

KEYWORD = 'KEYWORD'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

IF = 'IF'¶

ELSE_IF = 'ELSE IF'¶

ELSE = 'ELSE'¶

MESSAGE = 'MESSAGE'¶

type = None¶

id¶

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

parent¶

repr_args = ()¶

class robot.model.body.Body(parent=None, items=None)[source]¶

Bases: robot.model.itemlist.ItemList

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

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

keyword_class¶: alias of robot.model.keyword.Keyword

for_class¶: alias of robot.model.control.For

if_class¶: alias of robot.model.control.If

classmethod register(item_class)[source]¶

create¶

create_keyword(*args, **kwargs)[source]¶

create_for(*args, **kwargs)[source]¶

create_if(*args, **kwargs)[source]¶

filter(keywords=None, fors=None, ifs=None, predicate=None)[source]¶

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 FOR and IF constructs use body.filter(fors=False, ifs=False). Including and excluding by types at the same time is not supported.

Custom predicate is a calleble 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.

append(item)¶

clear()¶

count(item)¶

extend(items)¶

index(item, *start_and_end)¶

insert(index, item)¶

pop(*index)¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

class robot.model.body.IfBranches(parent=None, items=None)[source]¶

Bases: robot.model.body.Body

if_branch_class¶: alias of robot.model.control.IfBranch

keyword_class = None¶

for_class = None¶

if_class = None¶

create_branch(*args, **kwargs)[source]¶

append(item)¶

clear()¶

count(item)¶

create¶

create_for(*args, **kwargs)¶

create_if(*args, **kwargs)¶

create_keyword(*args, **kwargs)¶

extend(items)¶

filter(keywords=None, fors=None, ifs=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 FOR and IF constructs use body.filter(fors=False, ifs=False). Including and excluding by types at the same time is not supported.

Custom predicate is a calleble 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.

index(item, *start_and_end)¶

insert(index, item)¶

pop(*index)¶

classmethod register(item_class)¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

robot.model.configurer module¶

class robot.model.configurer.SuiteConfigurer(name=None, doc=None, metadata=None, set_tags=None, include_tags=None, exclude_tags=None, include_suites=None, include_tests=None, empty_suite_ok=False)[source]¶

Bases: robot.model.visitor.SuiteVisitor

add_tags¶

remove_tags¶

visit_suite(suite)[source]¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

robot.model.control module¶

class robot.model.control.For(variables=(), flavor='IN', values=(), parent=None)[source]¶

Bases: robot.model.body.BodyItem

type = 'FOR'¶

body_class¶: alias of robot.model.body.Body

repr_args = ('variables', 'flavor', 'values')¶

variables¶

flavor¶

values¶

parent¶

body¶

keywords¶: Deprecated since Robot Framework 4.0. Use body instead.

visit(visitor)[source]¶

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

id¶

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

class robot.model.control.If(parent=None)[source]¶

Bases: robot.model.body.BodyItem

IF/ELSE structure root. Branches are stored in body.

type = 'IF/ELSE ROOT'¶

body_class¶: alias of robot.model.body.IfBranches

parent¶

body¶

id¶: Root IF/ELSE id is always None.

visit(visitor)[source]¶

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

repr_args = ()¶

class robot.model.control.IfBranch(type='IF', condition=None, parent=None)[source]¶

Bases: robot.model.body.BodyItem

body_class¶: alias of robot.model.body.Body

repr_args = ('type', 'condition')¶

type¶

condition¶

parent¶

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

body¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

id¶: Branch id omits the root IF/ELSE object from the parent id part.

visit(visitor)[source]¶

robot.model.filter module¶

class robot.model.filter.EmptySuiteRemover(preserve_direct_children=False)[source]¶

Bases: robot.model.visitor.SuiteVisitor

end_suite(suite)[source]¶: Called when suite ends. Default implementation does nothing.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(kw)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

class robot.model.filter.Filter(include_suites=None, include_tests=None, include_tags=None, exclude_tags=None)[source]¶

Bases: robot.model.filter.EmptySuiteRemover

include_suites¶

include_tests¶

include_tags¶

exclude_tags¶

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

robot.model.fixture module¶

robot.model.fixture.create_fixture(fixture, parent, type)[source]¶

robot.model.itemlist module¶

class robot.model.itemlist.ItemList(item_class, common_attrs=None, items=None)[source]¶

Bases: object

create(*args, **kwargs)[source]¶

append(item)[source]¶

extend(items)[source]¶

insert(index, item)[source]¶

pop(*index)[source]¶

remove(item)[source]¶

index(item, *start_and_end)[source]¶

clear()[source]¶

visit(visitor)[source]¶

count(item)[source]¶

sort()[source]¶

reverse()[source]¶

robot.model.keyword module¶

class robot.model.keyword.Keyword(name='', doc='', args=(), assign=(), tags=(), timeout=None, type='KEYWORD', parent=None)[source]¶

Bases: robot.model.body.BodyItem

Base model for a single keyword.

Extended by robot.running.model.Keyword and robot.result.model.Keyword.

repr_args = ('name', 'args', 'assign')¶

doc¶

args¶

assign¶

timeout¶

type¶

parent¶

name¶

teardown¶

Keyword teardown as a Keyword object.

Teardown can be modified by setting attributes directly:

keyword.teardown.name = 'Example'
keyword.teardown.args = ('First', 'Second')

Alternatively the config() method can be used to set multiple attributes in one call:

keyword.teardown.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole teardown is setting it to None. It will automatically recreate the underlying Keyword object:

keyword.teardown = None

This attribute is a Keyword object also when a keyword has no teardown but in that case its truth value is False. If there is a need to just check does a keyword have a teardown, using the has_teardown attribute avoids creating the Keyword object and is thus more memory efficient.

New in Robot Framework 4.0. Earlier teardown was accessed like keyword.keywords.teardown. has_teardown is new in Robot Framework 4.1.2.

has_teardown¶

Check does a keyword have a teardown without creating a teardown object.

A difference between using if kw.has_teardown: and if kw.teardown: is that accessing the teardown attribute creates a Keyword object representing a teardown even when the keyword actually does not have one. This typically does not matter, but with bigger suite structures having lot of keywords it can have a considerable effect on memory usage.

New in Robot Framework 4.1.2.

tags¶: Keyword tags as a Tags object.

visit(visitor)[source]¶: Visitor interface entry-point.

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

id¶

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

class robot.model.keyword.Keywords(parent=None, keywords=None)[source]¶

Bases: robot.model.itemlist.ItemList

A list-like object representing keywords in a suite, a test or a keyword.

Read-only and deprecated since Robot Framework 4.0.

deprecation_message = "'keywords' attribute is read-only and deprecated since Robot Framework 4.0. Use 'body', 'setup' or 'teardown' instead."¶

setup¶

create_setup(*args, **kwargs)[source]¶

teardown¶

create_teardown(*args, **kwargs)[source]¶

all¶: Iterates over all keywords, including setup and teardown.

normal¶: Iterates over normal keywords, omitting setup and teardown.

create(*args, **kwargs)[source]¶

append(item)[source]¶

extend(items)[source]¶

insert(index, item)[source]¶

pop(*index)[source]¶

remove(item)[source]¶

clear()[source]¶

count(item)¶

index(item, *start_and_end)¶

visit(visitor)¶

sort()[source]¶

reverse()[source]¶

classmethod raise_deprecation_error()[source]¶

robot.model.message module¶

class robot.model.message.Message(message='', level='INFO', html=False, timestamp=None, parent=None)[source]¶

Bases: robot.model.body.BodyItem

A message created during the test execution.

Can be a log message triggered by a keyword, or a warning or an error that occurred during parsing or test execution.

type = 'MESSAGE'¶

repr_args = ('message', 'level')¶

message¶: The message content as a string.

level¶: Severity of the message. Either TRACE, DEBUG, INFO, WARN, ERROR, FAIL or ``SKIP`. The last two are only used with keyword failure messages.

html¶: True if the content is in HTML, False otherwise.

timestamp¶: Timestamp in format %Y%m%d %H:%M:%S.%f.

parent¶: The object this message was triggered by.

html_message¶: Returns the message content as HTML.

id¶

visit(visitor)[source]¶: Visitor interface entry-point.

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

class robot.model.message.Messages(message_class=<class 'robot.model.message.Message'>, parent=None, messages=None)[source]¶

Bases: robot.model.itemlist.ItemList

append(item)¶

clear()¶

count(item)¶

create(*args, **kwargs)¶

extend(items)¶

index(item, *start_and_end)¶

insert(index, item)¶

pop(*index)¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

robot.model.metadata module¶

class robot.model.metadata.Metadata(initial=None)[source]¶

Bases: robot.utils.normalizing.NormalizedDict

clear() → None. Remove all items from D.¶

copy()¶

get(k[, d]) → D[k] if k in D, else d. d defaults to None.¶

items() → list of D's (key, value) pairs, as 2-tuples¶

iteritems() → an iterator over the (key, value) items of D¶

iterkeys() → an iterator over the keys of D¶

itervalues() → an iterator over the values of D¶

keys() → list of D's keys¶

pop(k[, d]) → v, remove specified key and return the corresponding value.¶: If key is not found, d is returned if given, otherwise KeyError is raised.

popitem() → (k, v), remove and return some (key, value) pair¶: as a 2-tuple; but raise KeyError if D is empty.

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D¶

update([E, ]**F) → None. Update D from mapping/iterable E and F.¶: If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

values() → list of D's values¶

robot.model.modelobject module¶

class robot.model.modelobject.ModelObject[source]¶

Bases: object

repr_args = ()¶

config(**attributes)[source]¶

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.

copy(**attributes)[source]¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)[source]¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

robot.model.modifier module¶

class robot.model.modifier.ModelModifier(visitors, empty_suite_ok, logger)[source]¶

Bases: robot.model.visitor.SuiteVisitor

visit_suite(suite)[source]¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

robot.model.namepatterns module¶

class robot.model.namepatterns.SuiteNamePatterns(patterns=None)[source]¶

Bases: robot.model.namepatterns._NamePatterns

match(name, longname=None)¶

class robot.model.namepatterns.TestNamePatterns(patterns=None)[source]¶

Bases: robot.model.namepatterns._NamePatterns

match(name, longname=None)¶

robot.model.statistics module¶

class robot.model.statistics.Statistics(suite, suite_stat_level=-1, tag_stat_include=None, tag_stat_exclude=None, tag_stat_combine=None, tag_doc=None, tag_stat_link=None, rpa=False)[source]¶

Bases: object

Container for total, suite and tag statistics.

Accepted parameters have the same semantics as the matching command line options.

total = None¶: Instance of TotalStatistics.

suite = None¶: Instance of SuiteStatistics.

tags = None¶: Instance of TagStatistics.

visit(visitor)[source]¶

class robot.model.statistics.StatisticsBuilder(total_builder, suite_builder, tag_builder)[source]¶

Bases: robot.model.visitor.SuiteVisitor

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_suite(suite)[source]¶: Called when suite ends. Default implementation does nothing.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(kw)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

robot.model.stats module¶

class robot.model.stats.Stat(name)[source]¶

Bases: robot.utils.sortable.Sortable

Generic statistic object used for storing all the statistic values.

name = None¶: Human readable identifier of the object these statistics belong to. All Tests for TotalStatistics, long name of the suite for SuiteStatistics or name of the tag for TagStatistics

passed = None¶: Number of passed tests.

failed = None¶: Number of failed tests.

skipped = None¶: Number of skipped tests.

elapsed = None¶: Number of milliseconds it took to execute.

get_attributes(include_label=False, include_elapsed=False, exclude_empty=True, values_as_strings=False, html_escape=False)[source]¶

total¶

add_test(test)[source]¶

visit(visitor)[source]¶

class robot.model.stats.TotalStat(name)[source]¶

Bases: robot.model.stats.Stat

Stores statistic values for a test run.

type = 'total'¶

add_test(test)¶

get_attributes(include_label=False, include_elapsed=False, exclude_empty=True, values_as_strings=False, html_escape=False)¶

total¶

visit(visitor)¶

class robot.model.stats.SuiteStat(suite)[source]¶

Bases: robot.model.stats.Stat

Stores statistics values for a single suite.

type = 'suite'¶

id = None¶: Identifier of the suite, e.g. s1-s2.

elapsed = None¶: Number of milliseconds it took to execute this suite, including sub-suites.

add_stat(other)[source]¶

add_test(test)¶

get_attributes(include_label=False, include_elapsed=False, exclude_empty=True, values_as_strings=False, html_escape=False)¶

total¶

visit(visitor)¶

class robot.model.stats.TagStat(name, doc='', links=None, combined=None)[source]¶

Bases: robot.model.stats.Stat

Stores statistic values for a single tag.

type = 'tag'¶

doc = None¶: Documentation of tag as a string.

links = None¶: List of tuples in which the first value is the link URL and the second is the link title. An empty list by default.

combined = None¶: Pattern as a string if the tag is combined, None otherwise.

info¶: Returns additional information of the tag statistics are about. Either combined or an empty string.

add_test(test)¶

get_attributes(include_label=False, include_elapsed=False, exclude_empty=True, values_as_strings=False, html_escape=False)¶

total¶

visit(visitor)¶

class robot.model.stats.CombinedTagStat(pattern, name=None, doc='', links=None)[source]¶

Bases: robot.model.stats.TagStat

match(tags)[source]¶

add_test(test)¶

get_attributes(include_label=False, include_elapsed=False, exclude_empty=True, values_as_strings=False, html_escape=False)¶

info¶: Returns additional information of the tag statistics are about. Either combined or an empty string.

total¶

type = 'tag'¶

visit(visitor)¶

robot.model.suitestatistics module¶

class robot.model.suitestatistics.SuiteStatistics(suite)[source]¶

Bases: object

Container for suite statistics.

stat = None¶: Instance of SuiteStat.

suites = None¶: List of TestSuite objects.

visit(visitor)[source]¶

class robot.model.suitestatistics.SuiteStatisticsBuilder(suite_stat_level)[source]¶

Bases: object

current¶

start_suite(suite)[source]¶

add_test(test)[source]¶

end_suite()[source]¶

robot.model.tags module¶

class robot.model.tags.Tags(tags=None)[source]¶

Bases: object

add(tags)[source]¶

remove(tags)[source]¶

match(tags)[source]¶

class robot.model.tags.TagPatterns(patterns)[source]¶

Bases: object

match(tags)[source]¶

robot.model.tags.TagPattern(pattern)[source]¶

class robot.model.tags.SingleTagPattern(pattern)[source]¶

Bases: object

match(tags)[source]¶

class robot.model.tags.AndTagPattern(patterns)[source]¶

Bases: object

match(tags)[source]¶

class robot.model.tags.OrTagPattern(patterns)[source]¶

Bases: object

match(tags)[source]¶

class robot.model.tags.NotTagPattern(must_match, *must_not_match)[source]¶

Bases: object

match(tags)[source]¶

robot.model.tagsetter module¶

class robot.model.tagsetter.TagSetter(add=None, remove=None)[source]¶

Bases: robot.model.visitor.SuiteVisitor

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(keyword)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

robot.model.tagstatistics module¶

class robot.model.tagstatistics.TagStatistics(combined_stats)[source]¶

Bases: object

Container for tag statistics.

tags = None¶: Dictionary, where key is the name of the tag as a string and value is an instance of TagStat.

combined = None¶: List of CombinedTagStat objects.

visit(visitor)[source]¶

class robot.model.tagstatistics.TagStatisticsBuilder(included=None, excluded=None, combined=None, docs=None, links=None)[source]¶

Bases: object

add_test(test)[source]¶

class robot.model.tagstatistics.TagStatInfo(docs=None, links=None)[source]¶

Bases: object

get_stat(tag)[source]¶

get_combined_stats(combined=None)[source]¶

get_doc(tag)[source]¶

get_links(tag)[source]¶

class robot.model.tagstatistics.TagStatDoc(pattern, doc)[source]¶

Bases: object

match(tag)[source]¶

class robot.model.tagstatistics.TagStatLink(pattern, link, title)[source]¶

Bases: object

match(tag)[source]¶

get_link(tag)[source]¶

robot.model.testcase module¶

class robot.model.testcase.TestCase(name='', doc='', tags=None, timeout=None, parent=None)[source]¶

Bases: robot.model.modelobject.ModelObject

Base model for a single test case.

Extended by robot.running.model.TestCase and robot.result.model.TestCase.

body_class¶: alias of robot.model.body.Body

fixture_class¶: alias of robot.model.keyword.Keyword

repr_args = ('name',)¶

name¶

doc¶

timeout¶

parent¶

body¶: Test case body as a Body object.

tags¶: Test tags as a Tags object.

setup¶

Test setup as a Keyword object.

This attribute is a Keyword object also when a test has no setup but in that case its truth value is False.

Setup can be modified by setting attributes directly:

test.setup.name = 'Example'
test.setup.args = ('First', 'Second')

Alternatively the config() method can be used to set multiple attributes in one call:

test.setup.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole setup is setting it to None. It will automatically recreate the underlying Keyword object:

test.setup = None

New in Robot Framework 4.0. Earlier setup was accessed like test.keywords.setup.

teardown¶

Test teardown as a Keyword object.

See setup for more information.

keywords¶

Deprecated since Robot Framework 4.0

Use body, setup or teardown instead.

id¶

Test case id in format like s1-t3.

See TestSuite.id for more information.

longname¶: Test name prefixed with the long name of the parent suite.

source¶

visit(visitor)[source]¶: Visitor interface entry-point.

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

class robot.model.testcase.TestCases(test_class=<class 'robot.model.testcase.TestCase'>, parent=None, tests=None)[source]¶

Bases: robot.model.itemlist.ItemList

append(item)¶

clear()¶

count(item)¶

create(*args, **kwargs)¶

extend(items)¶

index(item, *start_and_end)¶

insert(index, item)¶

pop(*index)¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

robot.model.testsuite module¶

class robot.model.testsuite.TestSuite(name='', doc='', metadata=None, source=None, rpa=False, parent=None)[source]¶

Bases: robot.model.modelobject.ModelObject

Base model for single suite.

Extended by robot.running.model.TestSuite and robot.result.model.TestSuite.

test_class¶: alias of robot.model.testcase.TestCase

fixture_class¶: alias of robot.model.keyword.Keyword

repr_args = ('name',)¶

doc¶

source¶: Path to the source file or directory.

parent¶: Parent suite. None with the root suite.

rpa¶: True when RPA mode is enabled.

name¶: Test suite name. If not set, constructed from child suite names.

longname¶: Suite name prefixed with the long name of the parent suite.

metadata¶: Free test suite metadata as a dictionary.

suites¶: Child suites as a TestSuites object.

tests¶: Tests as a TestCases object.

setup¶

Suite setup as a Keyword object.

This attribute is a Keyword object also when a suite has no setup but in that case its truth value is False.

Setup can be modified by setting attributes directly:

suite.setup.name = 'Example'
suite.setup.args = ('First', 'Second')

Alternatively the config() method can be used to set multiple attributes in one call:

suite.setup.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole setup is setting it to None. It will automatically recreate the underlying Keyword object:

suite.setup = None

New in Robot Framework 4.0. Earlier setup was accessed like suite.keywords.setup.

teardown¶

Suite teardown as a Keyword object.

See setup for more information.

keywords¶

Deprecated since Robot Framework 4.0

Use setup or teardown instead.

id¶

An automatically generated unique id.

The root suite has id s1, its child suites have ids s1-s1, s1-s2, …, their child suites get ids s1-s1-s1, s1-s1-s2, …, s1-s2-s1, …, and so on.

The first test in a suite has an id like s1-t1, the second has an id s1-t2, and so on. Similarly keywords in suites (setup/teardown) and in tests get ids like s1-k1, s1-t1-k1, and s1-s4-t2-k5.

test_count¶: Number of the tests in this suite, recursively.

has_tests¶

set_tags(add=None, remove=None, persist=False)[source]¶

Add and/or remove specified tags to the tests in this suite.

Parameters:	add – Tags to add as a list or, if adding only one, as a single string. remove – Tags to remove as a list or as a single string. Can be given as patterns where `` and `?` work as wildcards. persist* – Add/remove specified tags also to new tests added to this suite in the future.

filter(included_suites=None, included_tests=None, included_tags=None, excluded_tags=None)[source]¶

Select test cases and remove others from this suite.

Parameters have the same semantics as --suite, --test, --include, and --exclude command line options. All of them can be given as a list of strings, or when selecting only one, as a single string.

Child suites that contain no tests after filtering are automatically removed.

Example:

suite.filter(included_tests=['Test 1', '* Example'],
             included_tags='priority-1')

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.

configure(**options)[source]¶

A shortcut to configure a suite using one method call.

Can only be used with the root test suite.

Parameters:	options – Passed to `SuiteConfigurer` that will then set suite attributes, call `filter()`, etc. as needed.

Not to be confused with config() method that suites, tests, and keywords have to make it possible to set multiple attributes in one call.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

remove_empty_suites(preserve_direct_children=False)[source]¶: Removes all child suites not containing any tests, recursively.

visit(visitor)[source]¶: Visitor interface entry-point.

class robot.model.testsuite.TestSuites(suite_class=<class 'robot.model.testsuite.TestSuite'>, parent=None, suites=None)[source]¶

Bases: robot.model.itemlist.ItemList

append(item)¶

clear()¶

count(item)¶

create(*args, **kwargs)¶

extend(items)¶

index(item, *start_and_end)¶

insert(index, item)¶

pop(*index)¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

robot.model.totalstatistics module¶

class robot.model.totalstatistics.TotalStatistics(rpa=False)[source]¶

Bases: object

Container for total statistics.

visit(visitor)[source]¶

total¶

passed¶

skipped¶

failed¶

add_test(test)[source]¶

message¶

String representation of the statistics.

For example::: 2 tests, 1 passed, 1 failed

class robot.model.totalstatistics.TotalStatisticsBuilder(suite=None, rpa=False)[source]¶

Bases: robot.model.visitor.SuiteVisitor

add_test(test)[source]¶

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(kw)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

robot.model.visitor module¶

Interface to ease traversing through a test suite structure.

Visitors make it easy to modify test suite structures or to collect information from them. They work both with the executable model and the result model, but the objects passed to the visitor methods are slightly different depending on the model they are used with. The main differences are that on the execution side keywords do not have child keywords nor messages, and that only the result objects have status related attributes like status and starttime.

This module contains SuiteVisitor that implements the core logic to visit a test suite structure, and the result package contains ResultVisitor that supports visiting the whole test execution result structure. Both of these visitors should be imported via the robot.api package when used by external code.

Visitor algorithm¶

All suite, test, keyword and message objects have a visit() method that accepts a visitor instance. These methods will then call the correct visitor method visit_suite(), visit_test(), visit_keyword() or visit_message(), depending on the instance where the visit() method exists.

The recommended and definitely easiest way to implement a visitor is extending the SuiteVisitor base class. The default implementation of its visit_x() methods take care of traversing child elements of the object x recursively. A visit_x() method first calls a corresponding start_x() method (e.g. visit_suite() calls start_suite()), then calls visit() for all child objects of the x object, and finally calls the corresponding end_x() method. The default implementations of start_x() and end_x() do nothing.

Visitors extending the SuiteVisitor can stop visiting at a certain level either by overriding suitable visit_x() method or by returning an explicit False from any start_x() method.

Examples¶

The following example visitor modifies the test suite structure it visits. It could be used, for example, with Robot Framework’s --prerunmodifier option to modify test data before execution.

"""Pre-run modifier that selects only every Xth test for execution.

Starts from the first test by default. Tests are selected per suite.
"""

from robot.api import SuiteVisitor


class SelectEveryXthTest(SuiteVisitor):

    def __init__(self, x: int, start: int = 0):
        self.x = x
        self.start = start

    def start_suite(self, suite):
        """Modify suite's tests to contain only every Xth."""
        suite.tests = suite.tests[self.start::self.x]

    def end_suite(self, suite):
        """Remove suites that are empty after removing tests."""
        suite.suites = [s for s in suite.suites if s.test_count > 0]

    def visit_test(self, test):
        """Avoid visiting tests and their keywords to save a little time."""
        pass

For more examples it is possible to look at the source code of visitors used internally by Robot Framework itself. Some good examples are TagSetter and keyword removers.

class robot.model.visitor.SuiteVisitor[source]¶

Bases: object

Abstract class to ease traversing through the test suite structure.

See the module level documentation for more information and an example.

visit_suite(suite)[source]¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_suite(suite)[source]¶: Called when suite ends. Default implementation does nothing.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

start_test(test)[source]¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_test(test)[source]¶: Called when test ends. Default implementation does nothing.

visit_keyword(kw)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

start_keyword(keyword)[source]¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_keyword(keyword)[source]¶: Called when keyword ends. Default implementation does nothing.

visit_for(for_)[source]¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

start_for(for_)[source]¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_for(for_)[source]¶: Called when FOR loop ends. Default implementation does nothing.

visit_for_iteration(iteration)[source]¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

start_for_iteration(iteration)[source]¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_for_iteration(iteration)[source]¶: Called when FOR loop iteration ends. Default implementation does nothing.

visit_if(if_)[source]¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

start_if(if_)[source]¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_if(if_)[source]¶: Called when IF/ELSE structure ends. Default implementation does nothing.

visit_if_branch(branch)[source]¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

start_if_branch(branch)[source]¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_if_branch(branch)[source]¶: Called when IF/ELSE branch ends. Default implementation does nothing.

visit_message(msg)[source]¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

start_message(msg)[source]¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_message(msg)[source]¶: Called when message ends. Default implementation does nothing.

robot.output package¶

Package for internal logging and other output.

Not part of the public API, and also subject to change in the future when test execution is refactored.

Subpackages¶

robot.output.console package¶

robot.output.console.ConsoleOutput(type='verbose', width=78, colors='AUTO', markers='AUTO', stdout=None, stderr=None)[source]¶

Submodules¶

robot.output.console.dotted module¶

class robot.output.console.dotted.DottedOutput(width=78, colors='AUTO', stdout=None, stderr=None)[source]¶

Bases: object

start_suite(suite)[source]¶

end_test(test)[source]¶

end_suite(suite)[source]¶

message(msg)[source]¶

output_file(name, path)[source]¶

class robot.output.console.dotted.StatusReporter(stream, width)[source]¶

Bases: robot.model.visitor.SuiteVisitor

report(suite)[source]¶

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

robot.output.console.highlighting module¶

class robot.output.console.highlighting.HighlightingStream(stream, colors='AUTO')[source]¶

Bases: object

write(text, flush=True)[source]¶

flush()[source]¶

highlight(text, status=None, flush=True)[source]¶

error(message, level)[source]¶

robot.output.console.highlighting.Highlighter(stream)[source]¶

class robot.output.console.highlighting.AnsiHighlighter(stream)[source]¶

Bases: object

green()[source]¶

red()[source]¶

yellow()[source]¶

reset()[source]¶

class robot.output.console.highlighting.NoHighlighting(stream)[source]¶

Bases: robot.output.console.highlighting.AnsiHighlighter

green()¶

red()¶

reset()¶

yellow()¶

class robot.output.console.highlighting.DosHighlighter(stream)[source]¶

Bases: object

green()[source]¶

red()[source]¶

yellow()[source]¶

reset()[source]¶

robot.output.console.quiet module¶

class robot.output.console.quiet.QuietOutput(colors='AUTO', stderr=None)[source]¶

Bases: object

message(msg)[source]¶

class robot.output.console.quiet.NoOutput[source]¶: Bases: object

robot.output.console.verbose module¶

class robot.output.console.verbose.VerboseOutput(width=78, colors='AUTO', markers='AUTO', stdout=None, stderr=None)[source]¶

Bases: object

start_suite(suite)[source]¶

end_suite(suite)[source]¶

start_test(test)[source]¶

end_test(test)[source]¶

start_keyword(kw)[source]¶

end_keyword(kw)[source]¶

message(msg)[source]¶

output_file(name, path)[source]¶

class robot.output.console.verbose.VerboseWriter(width=78, colors='AUTO', markers='AUTO', stdout=None, stderr=None)[source]¶

Bases: object

info(name, doc, start_suite=False)[source]¶

suite_separator()[source]¶

test_separator()[source]¶

status(status, clear=False)[source]¶

message(message)[source]¶

keyword_marker(status)[source]¶

error(message, level, clear=False)[source]¶

output(name, path)[source]¶

class robot.output.console.verbose.KeywordMarker(highlighter, markers)[source]¶

Bases: object

mark(status)[source]¶

reset_count()[source]¶

Submodules¶

robot.output.debugfile module¶

robot.output.debugfile.DebugFile(path)[source]¶

robot.output.filelogger module¶

class robot.output.filelogger.FileLogger(path, level)[source]¶

Bases: robot.output.loggerhelper.AbstractLogger

message(msg)[source]¶

start_suite(suite)[source]¶

end_suite(suite)[source]¶

start_test(test)[source]¶

end_test(test)[source]¶

start_keyword(kw)[source]¶

end_keyword(kw)[source]¶

output_file(name, path)[source]¶

close()[source]¶

debug(msg)¶

error(msg)¶

fail(msg)¶

info(msg)¶

set_level(level)¶

skip(msg)¶

trace(msg)¶

warn(msg)¶

write(message, level, html=False)¶

robot.output.librarylogger module¶

Implementation of the public test library logging API.

This is exposed via robot.api.logger. Implementation must reside here to avoid cyclic imports.

robot.output.librarylogger.write(msg, level, html=False)[source]¶

robot.output.librarylogger.trace(msg, html=False)[source]¶

robot.output.librarylogger.debug(msg, html=False)[source]¶

robot.output.librarylogger.info(msg, html=False, also_console=False)[source]¶

robot.output.librarylogger.warn(msg, html=False)[source]¶

robot.output.librarylogger.error(msg, html=False)[source]¶

robot.output.librarylogger.console(msg, newline=True, stream='stdout')[source]¶

robot.output.listenerarguments module¶

class robot.output.listenerarguments.ListenerArguments(arguments)[source]¶

Bases: object

get_arguments(version)[source]¶

classmethod by_method_name(name, arguments)[source]¶

class robot.output.listenerarguments.MessageArguments(arguments)[source]¶

Bases: robot.output.listenerarguments.ListenerArguments

classmethod by_method_name(name, arguments)¶

get_arguments(version)¶

class robot.output.listenerarguments.StartSuiteArguments(arguments)[source]¶

Bases: robot.output.listenerarguments._ListenerArgumentsFromItem

classmethod by_method_name(name, arguments)¶

get_arguments(version)¶

class robot.output.listenerarguments.EndSuiteArguments(arguments)[source]¶

Bases: robot.output.listenerarguments.StartSuiteArguments

classmethod by_method_name(name, arguments)¶

get_arguments(version)¶

class robot.output.listenerarguments.StartTestArguments(arguments)[source]¶

Bases: robot.output.listenerarguments._ListenerArgumentsFromItem

classmethod by_method_name(name, arguments)¶

get_arguments(version)¶

class robot.output.listenerarguments.EndTestArguments(arguments)[source]¶

Bases: robot.output.listenerarguments.StartTestArguments

classmethod by_method_name(name, arguments)¶

get_arguments(version)¶

class robot.output.listenerarguments.StartKeywordArguments(arguments)[source]¶

Bases: robot.output.listenerarguments._ListenerArgumentsFromItem

classmethod by_method_name(name, arguments)¶

get_arguments(version)¶

class robot.output.listenerarguments.EndKeywordArguments(arguments)[source]¶

Bases: robot.output.listenerarguments.StartKeywordArguments

classmethod by_method_name(name, arguments)¶

get_arguments(version)¶

robot.output.listenermethods module¶

class robot.output.listenermethods.ListenerMethods(method_name, listeners)[source]¶: Bases: object

class robot.output.listenermethods.LibraryListenerMethods(method_name)[source]¶

Bases: object

new_suite_scope()[source]¶

discard_suite_scope()[source]¶

register(listeners, library)[source]¶

unregister(library)[source]¶

class robot.output.listenermethods.ListenerMethod(method, listener, library=None)[source]¶

Bases: object

called = False¶

robot.output.listeners module¶

class robot.output.listeners.Listeners(listeners, log_level='INFO')[source]¶

Bases: object

set_log_level(level)[source]¶

start_keyword(kw)[source]¶

end_keyword(kw)[source]¶

log_message(msg)[source]¶

imported(import_type, name, attrs)[source]¶

output_file(file_type, path)[source]¶

class robot.output.listeners.LibraryListeners(log_level='INFO')[source]¶

Bases: object

register(listeners, library)[source]¶

unregister(library, close=False)[source]¶

new_suite_scope()[source]¶

discard_suite_scope()[source]¶

set_log_level(level)[source]¶

log_message(msg)[source]¶

imported(import_type, name, attrs)[source]¶

output_file(file_type, path)[source]¶

class robot.output.listeners.ListenerProxy(listener, method_names, prefix=None)[source]¶

Bases: robot.output.loggerhelper.AbstractLoggerProxy

classmethod import_listeners(listeners, method_names, prefix=None, raise_on_error=False)[source]¶

robot.output.logger module¶

class robot.output.logger.Logger(register_console_logger=True)[source]¶

Bases: robot.output.loggerhelper.AbstractLogger

A global logger proxy to delegating messages to registered loggers.

Whenever something is written to LOGGER in code, all registered loggers are notified. Messages are also cached and cached messages written to new loggers when they are registered.

NOTE: This API is likely to change in future versions.

start_loggers¶

end_loggers¶

register_console_logger(type='verbose', width=78, colors='AUTO', markers='AUTO', stdout=None, stderr=None)[source]¶

unregister_console_logger()[source]¶

register_syslog(path=None, level='INFO')[source]¶

register_xml_logger(logger)[source]¶

unregister_xml_logger()[source]¶

register_listeners(listeners, library_listeners)[source]¶

register_logger(*loggers)[source]¶

unregister_logger(*loggers)[source]¶

disable_message_cache()[source]¶

register_error_listener(listener)[source]¶

message(msg)[source]¶: Messages about what the framework is doing, warnings, errors, …

cache_only¶

delayed_logging¶

log_message(msg)¶: Messages about what the framework is doing, warnings, errors, …

log_output(output)[source]¶

enable_library_import_logging()[source]¶

disable_library_import_logging()[source]¶

start_suite(suite)[source]¶

end_suite(suite)[source]¶

start_test(test)[source]¶

end_test(test)[source]¶

start_keyword(keyword)[source]¶

end_keyword(keyword)[source]¶

imported(import_type, name, **attrs)[source]¶

output_file(file_type, path)[source]¶: Finished output, report, log, debug, or xunit file

close()[source]¶

debug(msg)¶

error(msg)¶

fail(msg)¶

info(msg)¶

set_level(level)¶

skip(msg)¶

trace(msg)¶

warn(msg)¶

write(message, level, html=False)¶

class robot.output.logger.LoggerProxy(logger, method_names=None, prefix=None)[source]¶

Bases: robot.output.loggerhelper.AbstractLoggerProxy

start_keyword(kw)[source]¶

end_keyword(kw)[source]¶

robot.output.loggerhelper module¶

class robot.output.loggerhelper.AbstractLogger(level='TRACE')[source]¶

Bases: object

set_level(level)[source]¶

trace(msg)[source]¶

debug(msg)[source]¶

info(msg)[source]¶

warn(msg)[source]¶

fail(msg)[source]¶

skip(msg)[source]¶

error(msg)[source]¶

write(message, level, html=False)[source]¶

message(msg)[source]¶

class robot.output.loggerhelper.Message(message, level='INFO', html=False, timestamp=None)[source]¶

Bases: robot.model.message.Message

message¶

resolve_delayed_message()[source]¶

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

html¶

html_message¶: Returns the message content as HTML.

id¶

level¶

parent¶

repr_args = ('message', 'level')¶

timestamp¶

type = 'MESSAGE'¶

visit(visitor)[source]¶: Visitor interface entry-point.

class robot.output.loggerhelper.IsLogged(level)[source]¶

Bases: object

set_level(level)[source]¶

class robot.output.loggerhelper.AbstractLoggerProxy(logger, method_names=None, prefix=None)[source]¶: Bases: object

robot.output.output module¶

class robot.output.output.Output(settings)[source]¶

Bases: robot.output.loggerhelper.AbstractLogger

register_error_listener(listener)[source]¶

close(result)[source]¶

start_suite(suite)[source]¶

end_suite(suite)[source]¶

start_test(test)[source]¶

end_test(test)[source]¶

start_keyword(kw)[source]¶

end_keyword(kw)[source]¶

message(msg)[source]¶

set_log_level(level)[source]¶

debug(msg)¶

error(msg)¶

fail(msg)¶

info(msg)¶

set_level(level)¶

skip(msg)¶

trace(msg)¶

warn(msg)¶

write(message, level, html=False)¶

robot.output.pyloggingconf module¶

robot.output.pyloggingconf.robot_handler_enabled(*args, **kwds)[source]¶

robot.output.pyloggingconf.set_level(level)[source]¶

class robot.output.pyloggingconf.RobotHandler(level=0)[source]¶

Bases: logging.Handler

Initializes the instance - basically setting the formatter to None and the filter list to empty.

emit(record)[source]¶

Do whatever it takes to actually log the specified logging record.

This version is intended to be implemented by subclasses and so raises a NotImplementedError.

acquire()¶: Acquire the I/O thread lock.

addFilter(filter)¶: Add the specified filter to this handler.

close()¶

Tidy up any resources used by the handler.

This version removes the handler from an internal map of handlers, _handlers, which is used for handler lookup by name. Subclasses should ensure that this gets called from overridden close() methods.

createLock()¶: Acquire a thread lock for serializing access to the underlying I/O.

filter(record)¶

Determine if a record is loggable by consulting all the filters.

The default is to allow the record to be logged; any filter can veto this and the record is then dropped. Returns a zero value if a record is to be dropped, else non-zero.

flush()¶

Ensure all logging output has been flushed.

This version does nothing and is intended to be implemented by subclasses.

format(record)¶

Format the specified record.

If a formatter is set, use it. Otherwise, use the default formatter for the module.

get_name()¶

handle(record)¶

Conditionally emit the specified logging record.

Emission depends on filters which may have been added to the handler. Wrap the actual emission of the record with acquisition/release of the I/O thread lock. Returns whether the filter passed the record for emission.

handleError(record)¶

Handle errors which occur during an emit() call.

This method should be called from handlers when an exception is encountered during an emit() call. If raiseExceptions is false, exceptions get silently ignored. This is what is mostly wanted for a logging system - most users will not care about errors in the logging system, they are more interested in application errors. You could, however, replace this with a custom handler if you wish. The record which was being processed is passed in to this method.

name¶

release()¶: Release the I/O thread lock.

removeFilter(filter)¶: Remove the specified filter from this handler.

setFormatter(fmt)¶: Set the formatter for this handler.

setLevel(level)¶: Set the logging level of this handler.

set_name(name)¶

robot.output.stdoutlogsplitter module¶

class robot.output.stdoutlogsplitter.StdoutLogSplitter(output)[source]¶

Bases: object

Splits messages logged through stdout (or stderr) into Message objects

robot.output.xmllogger module¶

class robot.output.xmllogger.XmlLogger(path, log_level='TRACE', rpa=False, generator='Robot')[source]¶

Bases: robot.result.visitor.ResultVisitor

close()[source]¶

set_log_level(level)[source]¶

message(msg)[source]¶

log_message(msg)[source]¶

start_keyword(kw)[source]¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_keyword(kw)[source]¶: Called when keyword ends. Default implementation does nothing.

start_if(if_)[source]¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_if(if_)[source]¶: Called when IF/ELSE structure ends. Default implementation does nothing.

start_if_branch(branch)[source]¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_if_branch(branch)[source]¶: Called when IF/ELSE branch ends. Default implementation does nothing.

start_for(for_)[source]¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_for(for_)[source]¶: Called when FOR loop ends. Default implementation does nothing.

start_for_iteration(iteration)[source]¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_for_iteration(iteration)[source]¶: Called when FOR loop iteration ends. Default implementation does nothing.

start_test(test)[source]¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_test(test)[source]¶: Called when test ends. Default implementation does nothing.

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_suite(suite)[source]¶: Called when suite ends. Default implementation does nothing.

start_statistics(stats)[source]¶

end_statistics(stats)[source]¶

start_total_statistics(total_stats)[source]¶

end_total_statistics(total_stats)[source]¶

start_tag_statistics(tag_stats)[source]¶

end_tag_statistics(tag_stats)[source]¶

start_suite_statistics(tag_stats)[source]¶

end_suite_statistics(tag_stats)[source]¶

visit_stat(stat)[source]¶

start_errors(errors=None)[source]¶

end_errors(errors=None)[source]¶

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_result(result)¶

end_stat(stat)¶

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_result(result)¶

start_stat(stat)¶

visit_errors(errors)¶

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_result(result)¶

visit_statistics(stats)¶

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_suite_statistics(stats)¶

visit_tag_statistics(stats)¶

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_total_statistics(stats)¶

robot.parsing package¶

Module implementing test data parsing.

Public API is exposed via the robot.api.parsing module. See its documentation for more information and examples. If external code needs to import something from this module directly, issue should be submitted about exposing it explicitly via robot.api.parsing.

Subpackages¶

robot.parsing.lexer package¶

Submodules¶

robot.parsing.lexer.blocklexers module¶

class robot.parsing.lexer.blocklexers.BlockLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.Lexer

accepts_more(statement)[source]¶

input(statement)[source]¶

lexer_for(statement)[source]¶

lexer_classes()[source]¶

lex()[source]¶

handles(statement)¶

class robot.parsing.lexer.blocklexers.FileLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.BlockLexer

lex()[source]¶

lexer_classes()[source]¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.SectionLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.BlockLexer

accepts_more(statement)[source]¶

handles(statement)¶

input(statement)¶

lex()¶

lexer_classes()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.SettingSectionLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.SectionLexer

handles(statement)[source]¶

lexer_classes()[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.VariableSectionLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.SectionLexer

handles(statement)[source]¶

lexer_classes()[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.TestCaseSectionLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.SectionLexer

handles(statement)[source]¶

lexer_classes()[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.KeywordSectionLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.SettingSectionLexer

handles(statement)[source]¶

lexer_classes()[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.CommentSectionLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.SectionLexer

handles(statement)[source]¶

lexer_classes()[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.ImplicitCommentSectionLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.SectionLexer

handles(statement)[source]¶

lexer_classes()[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.ErrorSectionLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.SectionLexer

handles(statement)[source]¶

lexer_classes()[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.TestOrKeywordLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.BlockLexer

name_type = NotImplemented¶

accepts_more(statement)[source]¶

input(statement)[source]¶

lexer_classes()[source]¶

handles(statement)¶

lex()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.TestCaseLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.TestOrKeywordLexer

name_type = 'TESTCASE NAME'¶

lex()[source]¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

lexer_classes()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.KeywordLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.TestOrKeywordLexer

name_type = 'KEYWORD NAME'¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

lex()¶

lexer_classes()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.NestedBlockLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.BlockLexer

accepts_more(statement)[source]¶

input(statement)[source]¶

handles(statement)¶

lex()¶

lexer_classes()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.ForLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.NestedBlockLexer

handles(statement)[source]¶

lexer_classes()[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

lexer_for(statement)¶

class robot.parsing.lexer.blocklexers.IfLexer(ctx)[source]¶

Bases: robot.parsing.lexer.blocklexers.NestedBlockLexer

handles(statement)[source]¶

lexer_classes()[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

lexer_for(statement)¶

robot.parsing.lexer.context module¶

class robot.parsing.lexer.context.LexingContext(settings=None)[source]¶

Bases: object

settings_class = None¶

lex_setting(statement)[source]¶

class robot.parsing.lexer.context.FileContext(settings=None)[source]¶

Bases: robot.parsing.lexer.context.LexingContext

sections_class = None¶

setting_section(statement)[source]¶

variable_section(statement)[source]¶

test_case_section(statement)[source]¶

keyword_section(statement)[source]¶

comment_section(statement)[source]¶

keyword_context()[source]¶

lex_invalid_section(statement)[source]¶

lex_setting(statement)¶

settings_class = None¶

class robot.parsing.lexer.context.TestCaseFileContext(settings=None)[source]¶

Bases: robot.parsing.lexer.context.FileContext

sections_class¶: alias of robot.parsing.lexer.sections.TestCaseFileSections

settings_class¶: alias of robot.parsing.lexer.settings.TestCaseFileSettings

test_case_context()[source]¶

comment_section(statement)¶

keyword_context()¶

keyword_section(statement)¶

lex_invalid_section(statement)¶

lex_setting(statement)¶

setting_section(statement)¶

test_case_section(statement)¶

variable_section(statement)¶

class robot.parsing.lexer.context.ResourceFileContext(settings=None)[source]¶

Bases: robot.parsing.lexer.context.FileContext

sections_class¶: alias of robot.parsing.lexer.sections.ResourceFileSections

settings_class¶: alias of robot.parsing.lexer.settings.ResourceFileSettings

comment_section(statement)¶

keyword_context()¶

keyword_section(statement)¶

lex_invalid_section(statement)¶

lex_setting(statement)¶

setting_section(statement)¶

test_case_section(statement)¶

variable_section(statement)¶

class robot.parsing.lexer.context.InitFileContext(settings=None)[source]¶

Bases: robot.parsing.lexer.context.FileContext

sections_class¶: alias of robot.parsing.lexer.sections.InitFileSections

settings_class¶: alias of robot.parsing.lexer.settings.InitFileSettings

comment_section(statement)¶

keyword_context()¶

keyword_section(statement)¶

lex_invalid_section(statement)¶

lex_setting(statement)¶

setting_section(statement)¶

test_case_section(statement)¶

variable_section(statement)¶

class robot.parsing.lexer.context.TestCaseContext(settings=None)[source]¶

Bases: robot.parsing.lexer.context.LexingContext

template_set¶

lex_setting(statement)¶

settings_class = None¶

class robot.parsing.lexer.context.KeywordContext(settings=None)[source]¶

Bases: robot.parsing.lexer.context.LexingContext

template_set¶

lex_setting(statement)¶

settings_class = None¶

robot.parsing.lexer.lexer module¶

robot.parsing.lexer.lexer.get_tokens(source, data_only=False, tokenize_variables=False)[source]¶

Parses the given source to tokens.

Parameters:

source – The source where to read the data. Can be a path to a source file as a string or as pathlib.Path object, an already opened file object, or Unicode text containing the date directly. Source files must be UTF-8 encoded.
data_only – When False (default), returns all tokens. When set to True, omits separators, comments, continuation markers, and other non-data tokens.
tokenize_variables – When True, possible variables in keyword arguments and elsewhere are tokenized. See the tokenize_variables() method for details.

Returns a generator that yields Token instances.

robot.parsing.lexer.lexer.get_resource_tokens(source, data_only=False, tokenize_variables=False)[source]¶

Parses the given source to resource file tokens.

Otherwise same as get_tokens() but the source is considered to be a resource file. This affects, for example, what settings are valid.

robot.parsing.lexer.lexer.get_init_tokens(source, data_only=False, tokenize_variables=False)[source]¶

Parses the given source to init file tokens.

Otherwise same as get_tokens() but the source is considered to be a suite initialization file. This affects, for example, what settings are valid.

class robot.parsing.lexer.lexer.Lexer(ctx, data_only=False, tokenize_variables=False)[source]¶

Bases: object

input(source)[source]¶

get_tokens()[source]¶

robot.parsing.lexer.sections module¶

class robot.parsing.lexer.sections.Sections[source]¶

Bases: object

setting_markers = ('Settings', 'Setting')¶

variable_markers = ('Variables', 'Variable')¶

test_case_markers = ('Test Cases', 'Test Case', 'Tasks', 'Task')¶

keyword_markers = ('Keywords', 'Keyword')¶

comment_markers = ('Comments', 'Comment')¶

setting(statement)[source]¶

variable(statement)[source]¶

test_case(statement)[source]¶

keyword(statement)[source]¶

comment(statement)[source]¶

lex_invalid(statement)[source]¶

class robot.parsing.lexer.sections.TestCaseFileSections[source]¶

Bases: robot.parsing.lexer.sections.Sections

test_case(statement)[source]¶

comment(statement)¶

comment_markers = ('Comments', 'Comment')¶

keyword(statement)¶

keyword_markers = ('Keywords', 'Keyword')¶

lex_invalid(statement)¶

setting(statement)¶

setting_markers = ('Settings', 'Setting')¶

test_case_markers = ('Test Cases', 'Test Case', 'Tasks', 'Task')¶

variable(statement)¶

variable_markers = ('Variables', 'Variable')¶

class robot.parsing.lexer.sections.ResourceFileSections[source]¶

Bases: robot.parsing.lexer.sections.Sections

comment(statement)¶

comment_markers = ('Comments', 'Comment')¶

keyword(statement)¶

keyword_markers = ('Keywords', 'Keyword')¶

lex_invalid(statement)¶

setting(statement)¶

setting_markers = ('Settings', 'Setting')¶

test_case(statement)¶

test_case_markers = ('Test Cases', 'Test Case', 'Tasks', 'Task')¶

variable(statement)¶

variable_markers = ('Variables', 'Variable')¶

class robot.parsing.lexer.sections.InitFileSections[source]¶

Bases: robot.parsing.lexer.sections.Sections

comment(statement)¶

comment_markers = ('Comments', 'Comment')¶

keyword(statement)¶

keyword_markers = ('Keywords', 'Keyword')¶

lex_invalid(statement)¶

setting(statement)¶

setting_markers = ('Settings', 'Setting')¶

test_case(statement)¶

test_case_markers = ('Test Cases', 'Test Case', 'Tasks', 'Task')¶

variable(statement)¶

variable_markers = ('Variables', 'Variable')¶

robot.parsing.lexer.settings module¶

class robot.parsing.lexer.settings.Settings[source]¶

Bases: object

names = ()¶

aliases = {}¶

multi_use = ('Metadata', 'Library', 'Resource', 'Variables')¶

single_value = ('Resource', 'Test Timeout', 'Test Template', 'Timeout', 'Template')¶

name_and_arguments = ('Metadata', 'Suite Setup', 'Suite Teardown', 'Test Setup', 'Test Teardown', 'Test Template', 'Setup', 'Teardown', 'Template', 'Resource', 'Variables')¶

name_arguments_and_with_name = ('Library',)¶

lex(statement)[source]¶

class robot.parsing.lexer.settings.TestCaseFileSettings[source]¶

Bases: robot.parsing.lexer.settings.Settings

names = ('Documentation', 'Metadata', 'Suite Setup', 'Suite Teardown', 'Test Setup', 'Test Teardown', 'Test Template', 'Test Timeout', 'Force Tags', 'Default Tags', 'Library', 'Resource', 'Variables')¶

aliases = {'Task Setup': 'Test Setup', 'Task Teardown': 'Test Teardown', 'Task Template': 'Test Template', 'Task Timeout': 'Test Timeout'}¶

lex(statement)¶

multi_use = ('Metadata', 'Library', 'Resource', 'Variables')¶

name_and_arguments = ('Metadata', 'Suite Setup', 'Suite Teardown', 'Test Setup', 'Test Teardown', 'Test Template', 'Setup', 'Teardown', 'Template', 'Resource', 'Variables')¶

name_arguments_and_with_name = ('Library',)¶

single_value = ('Resource', 'Test Timeout', 'Test Template', 'Timeout', 'Template')¶

class robot.parsing.lexer.settings.InitFileSettings[source]¶

Bases: robot.parsing.lexer.settings.Settings

names = ('Documentation', 'Metadata', 'Suite Setup', 'Suite Teardown', 'Test Setup', 'Test Teardown', 'Test Timeout', 'Force Tags', 'Library', 'Resource', 'Variables')¶

aliases = {}¶

lex(statement)¶

multi_use = ('Metadata', 'Library', 'Resource', 'Variables')¶

name_and_arguments = ('Metadata', 'Suite Setup', 'Suite Teardown', 'Test Setup', 'Test Teardown', 'Test Template', 'Setup', 'Teardown', 'Template', 'Resource', 'Variables')¶

name_arguments_and_with_name = ('Library',)¶

single_value = ('Resource', 'Test Timeout', 'Test Template', 'Timeout', 'Template')¶

class robot.parsing.lexer.settings.ResourceFileSettings[source]¶

Bases: robot.parsing.lexer.settings.Settings

names = ('Documentation', 'Library', 'Resource', 'Variables')¶

aliases = {}¶

lex(statement)¶

multi_use = ('Metadata', 'Library', 'Resource', 'Variables')¶

name_and_arguments = ('Metadata', 'Suite Setup', 'Suite Teardown', 'Test Setup', 'Test Teardown', 'Test Template', 'Setup', 'Teardown', 'Template', 'Resource', 'Variables')¶

name_arguments_and_with_name = ('Library',)¶

single_value = ('Resource', 'Test Timeout', 'Test Template', 'Timeout', 'Template')¶

class robot.parsing.lexer.settings.TestCaseSettings(parent)[source]¶

Bases: robot.parsing.lexer.settings.Settings

names = ('Documentation', 'Tags', 'Setup', 'Teardown', 'Template', 'Timeout')¶

template_set¶

aliases = {}¶

lex(statement)¶

multi_use = ('Metadata', 'Library', 'Resource', 'Variables')¶

name_and_arguments = ('Metadata', 'Suite Setup', 'Suite Teardown', 'Test Setup', 'Test Teardown', 'Test Template', 'Setup', 'Teardown', 'Template', 'Resource', 'Variables')¶

name_arguments_and_with_name = ('Library',)¶

single_value = ('Resource', 'Test Timeout', 'Test Template', 'Timeout', 'Template')¶

class robot.parsing.lexer.settings.KeywordSettings[source]¶

Bases: robot.parsing.lexer.settings.Settings

names = ('Documentation', 'Arguments', 'Teardown', 'Timeout', 'Tags', 'Return')¶

aliases = {}¶

lex(statement)¶

multi_use = ('Metadata', 'Library', 'Resource', 'Variables')¶

name_and_arguments = ('Metadata', 'Suite Setup', 'Suite Teardown', 'Test Setup', 'Test Teardown', 'Test Template', 'Setup', 'Teardown', 'Template', 'Resource', 'Variables')¶

name_arguments_and_with_name = ('Library',)¶

single_value = ('Resource', 'Test Timeout', 'Test Template', 'Timeout', 'Template')¶

robot.parsing.lexer.statementlexers module¶

class robot.parsing.lexer.statementlexers.Lexer(ctx)[source]¶

Bases: object

Base class for lexers.

handles(statement)[source]¶

accepts_more(statement)[source]¶

input(statement)[source]¶

lex()[source]¶

class robot.parsing.lexer.statementlexers.StatementLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.Lexer

token_type = None¶

accepts_more(statement)[source]¶

input(statement)[source]¶

lex()[source]¶

handles(statement)¶

class robot.parsing.lexer.statementlexers.SectionHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.StatementLexer

handles(statement)[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

token_type = None¶

class robot.parsing.lexer.statementlexers.SettingSectionHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.SectionHeaderLexer

token_type = 'SETTING HEADER'¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

lex()¶

class robot.parsing.lexer.statementlexers.VariableSectionHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.SectionHeaderLexer

token_type = 'VARIABLE HEADER'¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

lex()¶

class robot.parsing.lexer.statementlexers.TestCaseSectionHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.SectionHeaderLexer

token_type = 'TESTCASE HEADER'¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

lex()¶

class robot.parsing.lexer.statementlexers.KeywordSectionHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.SectionHeaderLexer

token_type = 'KEYWORD HEADER'¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

lex()¶

class robot.parsing.lexer.statementlexers.CommentSectionHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.SectionHeaderLexer

token_type = 'COMMENT HEADER'¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

lex()¶

class robot.parsing.lexer.statementlexers.ErrorSectionHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.SectionHeaderLexer

lex()[source]¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

token_type = None¶

class robot.parsing.lexer.statementlexers.CommentLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.StatementLexer

token_type = 'COMMENT'¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

lex()¶

class robot.parsing.lexer.statementlexers.SettingLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.StatementLexer

lex()[source]¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

token_type = None¶

class robot.parsing.lexer.statementlexers.TestOrKeywordSettingLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.SettingLexer

handles(statement)[source]¶

accepts_more(statement)¶

input(statement)¶

lex()¶

token_type = None¶

class robot.parsing.lexer.statementlexers.VariableLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.StatementLexer

lex()[source]¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

token_type = None¶

class robot.parsing.lexer.statementlexers.KeywordCallLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.StatementLexer

lex()[source]¶

accepts_more(statement)¶

handles(statement)¶

input(statement)¶

token_type = None¶

class robot.parsing.lexer.statementlexers.ForHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.StatementLexer

separators = ('IN', 'IN RANGE', 'IN ENUMERATE', 'IN ZIP')¶

handles(statement)[source]¶

lex()[source]¶

accepts_more(statement)¶

input(statement)¶

token_type = None¶

class robot.parsing.lexer.statementlexers.IfHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.StatementLexer

handles(statement)[source]¶

lex()[source]¶

accepts_more(statement)¶

input(statement)¶

token_type = None¶

class robot.parsing.lexer.statementlexers.ElseIfHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.StatementLexer

handles(statement)[source]¶

lex()[source]¶

accepts_more(statement)¶

input(statement)¶

token_type = None¶

class robot.parsing.lexer.statementlexers.ElseHeaderLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.StatementLexer

handles(statement)[source]¶

lex()[source]¶

accepts_more(statement)¶

input(statement)¶

token_type = None¶

class robot.parsing.lexer.statementlexers.EndLexer(ctx)[source]¶

Bases: robot.parsing.lexer.statementlexers.StatementLexer

handles(statement)[source]¶

lex()[source]¶

accepts_more(statement)¶

input(statement)¶

token_type = None¶

robot.parsing.lexer.tokenizer module¶

class robot.parsing.lexer.tokenizer.Tokenizer[source]¶

Bases: object

tokenize(data, data_only=False)[source]¶

robot.parsing.lexer.tokens module¶

class robot.parsing.lexer.tokens.Token(type=None, value=None, lineno=-1, col_offset=-1, error=None)[source]¶

Bases: object

Token representing piece of Robot Framework data.

Each token has type, value, line number, column offset and end column offset in type, value, lineno, col_offset and end_col_offset attributes, respectively. Tokens representing error also have their error message in error attribute.

Token types are declared as class attributes such as SETTING_HEADER and EOL. Values of these constants have changed slightly in Robot Framework 4.0 and they may change again in the future. It is thus safer to use the constants, not their values, when types are needed. For example, use Token(Token.EOL) instead of Token('EOL') and token.type == Token.EOL instead of token.type == 'EOL'.

If value is not given when Token is initialized and type is IF, ELSE_IF, ELSE, FOR, END, WITH_NAME or CONTINUATION, the value is automatically set to the correct marker value like 'IF' or 'ELSE IF'. If type is EOL in this case, the value is set to '\n'.

SETTING_HEADER = 'SETTING HEADER'¶

VARIABLE_HEADER = 'VARIABLE HEADER'¶

TESTCASE_HEADER = 'TESTCASE HEADER'¶

KEYWORD_HEADER = 'KEYWORD HEADER'¶

COMMENT_HEADER = 'COMMENT HEADER'¶

TESTCASE_NAME = 'TESTCASE NAME'¶

KEYWORD_NAME = 'KEYWORD NAME'¶

DOCUMENTATION = 'DOCUMENTATION'¶

SUITE_SETUP = 'SUITE SETUP'¶

SUITE_TEARDOWN = 'SUITE TEARDOWN'¶

METADATA = 'METADATA'¶

TEST_SETUP = 'TEST SETUP'¶

TEST_TEARDOWN = 'TEST TEARDOWN'¶

TEST_TEMPLATE = 'TEST TEMPLATE'¶

TEST_TIMEOUT = 'TEST TIMEOUT'¶

FORCE_TAGS = 'FORCE TAGS'¶

DEFAULT_TAGS = 'DEFAULT TAGS'¶

LIBRARY = 'LIBRARY'¶

RESOURCE = 'RESOURCE'¶

VARIABLES = 'VARIABLES'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

TEMPLATE = 'TEMPLATE'¶

TIMEOUT = 'TIMEOUT'¶

TAGS = 'TAGS'¶

ARGUMENTS = 'ARGUMENTS'¶

RETURN = 'RETURN'¶

NAME = 'NAME'¶

VARIABLE = 'VARIABLE'¶

ARGUMENT = 'ARGUMENT'¶

ASSIGN = 'ASSIGN'¶

KEYWORD = 'KEYWORD'¶

WITH_NAME = 'WITH NAME'¶

FOR = 'FOR'¶

FOR_SEPARATOR = 'FOR SEPARATOR'¶

END = 'END'¶

IF = 'IF'¶

ELSE_IF = 'ELSE IF'¶

ELSE = 'ELSE'¶

SEPARATOR = 'SEPARATOR'¶

COMMENT = 'COMMENT'¶

CONTINUATION = 'CONTINUATION'¶

EOL = 'EOL'¶

EOS = 'EOS'¶

ERROR = 'ERROR'¶

FATAL_ERROR = 'FATAL ERROR'¶

NON_DATA_TOKENS = frozenset(['COMMENT', 'CONTINUATION', 'SEPARATOR', 'EOS', 'EOL'])¶

SETTING_TOKENS = frozenset(['RESOURCE', 'TEMPLATE', 'SETUP', 'TAGS', 'SUITE SETUP', 'TEST SETUP', 'SUITE TEARDOWN', 'DOCUMENTATION', 'LIBRARY', 'TEARDOWN', 'TEST TIMEOUT', 'DEFAULT TAGS', 'TIMEOUT', 'ARGUMENTS', 'FORCE TAGS', 'TEST TEARDOWN', 'RETURN', 'TEST TEMPLATE', 'VARIABLES', 'METADATA'])¶

HEADER_TOKENS = frozenset(['VARIABLE HEADER', 'TESTCASE HEADER', 'KEYWORD HEADER', 'COMMENT HEADER', 'SETTING HEADER'])¶

ALLOW_VARIABLES = frozenset(['KEYWORD NAME', 'TESTCASE NAME', 'NAME', 'ARGUMENT'])¶

type¶

value¶

lineno¶

col_offset¶

error¶

end_col_offset¶

set_error(error, fatal=False)[source]¶

tokenize_variables()[source]¶

Tokenizes possible variables in token value.

Yields the token itself if the token does not allow variables (see Token.ALLOW_VARIABLES) or its value does not contain variables. Otherwise yields variable tokens as well as tokens before, after, or between variables so that they have the same type as the original token.

class robot.parsing.lexer.tokens.EOS(lineno=-1, col_offset=-1)[source]¶

Bases: robot.parsing.lexer.tokens.Token

Token representing end of a statement.

classmethod from_token(token)[source]¶

ALLOW_VARIABLES = frozenset(['KEYWORD NAME', 'TESTCASE NAME', 'NAME', 'ARGUMENT'])¶

ARGUMENT = 'ARGUMENT'¶

ARGUMENTS = 'ARGUMENTS'¶

ASSIGN = 'ASSIGN'¶

COMMENT = 'COMMENT'¶

COMMENT_HEADER = 'COMMENT HEADER'¶

CONTINUATION = 'CONTINUATION'¶

DEFAULT_TAGS = 'DEFAULT TAGS'¶

DOCUMENTATION = 'DOCUMENTATION'¶

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

END = 'END'¶

EOL = 'EOL'¶

EOS = 'EOS'¶

ERROR = 'ERROR'¶

FATAL_ERROR = 'FATAL ERROR'¶

FOR = 'FOR'¶

FORCE_TAGS = 'FORCE TAGS'¶

FOR_SEPARATOR = 'FOR SEPARATOR'¶

HEADER_TOKENS = frozenset(['VARIABLE HEADER', 'TESTCASE HEADER', 'KEYWORD HEADER', 'COMMENT HEADER', 'SETTING HEADER'])¶

IF = 'IF'¶

KEYWORD = 'KEYWORD'¶

KEYWORD_HEADER = 'KEYWORD HEADER'¶

KEYWORD_NAME = 'KEYWORD NAME'¶

LIBRARY = 'LIBRARY'¶

METADATA = 'METADATA'¶

NAME = 'NAME'¶

NON_DATA_TOKENS = frozenset(['COMMENT', 'CONTINUATION', 'SEPARATOR', 'EOS', 'EOL'])¶

RESOURCE = 'RESOURCE'¶

RETURN = 'RETURN'¶

SEPARATOR = 'SEPARATOR'¶

SETTING_HEADER = 'SETTING HEADER'¶

SETTING_TOKENS = frozenset(['RESOURCE', 'TEMPLATE', 'SETUP', 'TAGS', 'SUITE SETUP', 'TEST SETUP', 'SUITE TEARDOWN', 'DOCUMENTATION', 'LIBRARY', 'TEARDOWN', 'TEST TIMEOUT', 'DEFAULT TAGS', 'TIMEOUT', 'ARGUMENTS', 'FORCE TAGS', 'TEST TEARDOWN', 'RETURN', 'TEST TEMPLATE', 'VARIABLES', 'METADATA'])¶

SETUP = 'SETUP'¶

SUITE_SETUP = 'SUITE SETUP'¶

SUITE_TEARDOWN = 'SUITE TEARDOWN'¶

TAGS = 'TAGS'¶

TEARDOWN = 'TEARDOWN'¶

TEMPLATE = 'TEMPLATE'¶

TESTCASE_HEADER = 'TESTCASE HEADER'¶

TESTCASE_NAME = 'TESTCASE NAME'¶

TEST_SETUP = 'TEST SETUP'¶

TEST_TEARDOWN = 'TEST TEARDOWN'¶

TEST_TEMPLATE = 'TEST TEMPLATE'¶

TEST_TIMEOUT = 'TEST TIMEOUT'¶

TIMEOUT = 'TIMEOUT'¶

VARIABLE = 'VARIABLE'¶

VARIABLES = 'VARIABLES'¶

VARIABLE_HEADER = 'VARIABLE HEADER'¶

WITH_NAME = 'WITH NAME'¶

col_offset¶

end_col_offset¶

error¶

lineno¶

set_error(error, fatal=False)¶

tokenize_variables()¶

Tokenizes possible variables in token value.

Yields the token itself if the token does not allow variables (see Token.ALLOW_VARIABLES) or its value does not contain variables. Otherwise yields variable tokens as well as tokens before, after, or between variables so that they have the same type as the original token.

type¶

value¶

robot.parsing.model package¶

Submodules¶

robot.parsing.model.blocks module¶

class robot.parsing.model.blocks.Block[source]¶

Bases: _ast.AST

errors = ()¶

lineno¶

col_offset¶

end_lineno¶

end_col_offset¶

validate_model()[source]¶

validate()[source]¶

class robot.parsing.model.blocks.File(sections=None, source=None)[source]¶

Bases: robot.parsing.model.blocks.Block

save(output=None)[source]¶

Save model to the given output or to the original source file.

The output can be a path to a file or an already opened file object. If output is not given, the original source file will be overwritten.

col_offset¶

end_col_offset¶

end_lineno¶

errors = ()¶

lineno¶

validate()¶

validate_model()¶

class robot.parsing.model.blocks.Section(header=None, body=None)[source]¶

Bases: robot.parsing.model.blocks.Block

col_offset¶

end_col_offset¶

end_lineno¶

errors = ()¶

lineno¶

validate()¶

validate_model()¶

class robot.parsing.model.blocks.SettingSection(header=None, body=None)[source]¶

Bases: robot.parsing.model.blocks.Section

col_offset¶

end_col_offset¶

end_lineno¶

errors = ()¶

lineno¶

validate()¶

validate_model()¶

class robot.parsing.model.blocks.VariableSection(header=None, body=None)[source]¶

Bases: robot.parsing.model.blocks.Section

col_offset¶

end_col_offset¶

end_lineno¶

errors = ()¶

lineno¶

validate()¶

validate_model()¶

class robot.parsing.model.blocks.TestCaseSection(header=None, body=None)[source]¶

Bases: robot.parsing.model.blocks.Section

tasks¶

col_offset¶

end_col_offset¶

end_lineno¶

errors = ()¶

lineno¶

validate()¶

validate_model()¶

class robot.parsing.model.blocks.KeywordSection(header=None, body=None)[source]¶

Bases: robot.parsing.model.blocks.Section

col_offset¶

end_col_offset¶

end_lineno¶

errors = ()¶

lineno¶

validate()¶

validate_model()¶

class robot.parsing.model.blocks.CommentSection(header=None, body=None)[source]¶

Bases: robot.parsing.model.blocks.Section

col_offset¶

end_col_offset¶

end_lineno¶

errors = ()¶

lineno¶

validate()¶

validate_model()¶

class robot.parsing.model.blocks.TestCase(header, body=None)[source]¶

Bases: robot.parsing.model.blocks.Block

name¶

col_offset¶

end_col_offset¶

end_lineno¶

errors = ()¶

lineno¶

validate()¶

validate_model()¶

class robot.parsing.model.blocks.Keyword(header, body=None)[source]¶

Bases: robot.parsing.model.blocks.Block

name¶

col_offset¶

end_col_offset¶

end_lineno¶

errors = ()¶

lineno¶

validate()¶

validate_model()¶

class robot.parsing.model.blocks.If(header, body=None, orelse=None, end=None, errors=())[source]¶

Bases: robot.parsing.model.blocks.Block

Represents IF structures in the model.

Used with IF, ELSE_IF and ELSE nodes. The type attribute specifies the type.

errors = ()¶

type¶

condition¶

validate()[source]¶

col_offset¶

end_col_offset¶

end_lineno¶

lineno¶

validate_model()¶

class robot.parsing.model.blocks.For(header, body=None, end=None, errors=())[source]¶

Bases: robot.parsing.model.blocks.Block

errors = ()¶

variables¶

values¶

flavor¶

validate()[source]¶

col_offset¶

end_col_offset¶

end_lineno¶

lineno¶

validate_model()¶

class robot.parsing.model.blocks.ModelWriter(output)[source]¶

Bases: robot.parsing.model.visitor.ModelVisitor

write(model)[source]¶

visit_Statement(statement)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.parsing.model.blocks.ModelValidator[source]¶

Bases: robot.parsing.model.visitor.ModelVisitor

visit_Block(node)[source]¶

visit_Statement(node)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.parsing.model.blocks.FirstStatementFinder[source]¶

Bases: robot.parsing.model.visitor.ModelVisitor

classmethod find_from(model)[source]¶

visit_Statement(statement)[source]¶

generic_visit(node)[source]¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.parsing.model.blocks.LastStatementFinder[source]¶

Bases: robot.parsing.model.visitor.ModelVisitor

classmethod find_from(model)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

visit_Statement(statement)[source]¶

robot.parsing.model.statements module¶

class robot.parsing.model.statements.Statement(tokens, errors=())[source]¶

Bases: _ast.AST

type = None¶

handles_types = ()¶

lineno¶

col_offset¶

end_lineno¶

end_col_offset¶

classmethod register(subcls)[source]¶

classmethod from_tokens(tokens)[source]¶

classmethod from_params(*args, **kwargs)[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

data_tokens¶

get_token(*types)[source]¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)[source]¶: Return tokens having any of the given types.

get_value(type, default=None)[source]¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)[source]¶: Return values of tokens having any of the given types.

lines¶

validate()[source]¶

class robot.parsing.model.statements.DocumentationOrMetadata(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_params(*args, **kwargs)¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

type = None¶

validate()¶

class robot.parsing.model.statements.SingleValue(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

value¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_params(*args, **kwargs)¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

type = None¶

validate()¶

class robot.parsing.model.statements.MultiValue(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

values¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_params(*args, **kwargs)¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

type = None¶

validate()¶

class robot.parsing.model.statements.Fixture(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

name¶

args¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_params(*args, **kwargs)¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

type = None¶

validate()¶

class robot.parsing.model.statements.SectionHeader(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

handles_types = ('SETTING HEADER', 'VARIABLE HEADER', 'TESTCASE HEADER', 'KEYWORD HEADER', 'COMMENT HEADER')¶

classmethod from_params(type, name=None, eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

type¶

name¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.LibraryImport(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'LIBRARY'¶

classmethod from_params(name, args=(), alias=None, separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

name¶

args¶

alias¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.ResourceImport(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'RESOURCE'¶

classmethod from_params(name, separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

name¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.VariablesImport(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'VARIABLES'¶

classmethod from_params(name, args=(), separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

name¶

args¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.Documentation(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.DocumentationOrMetadata

type = 'DOCUMENTATION'¶

classmethod from_params(value, indent=' ', separator=' ', eol='\n', settings_section=True)[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

value¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.Metadata(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.DocumentationOrMetadata

type = 'METADATA'¶

classmethod from_params(name, value, separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

name¶

value¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.ForceTags(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.MultiValue

type = 'FORCE TAGS'¶

classmethod from_params(values, separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

values¶

class robot.parsing.model.statements.DefaultTags(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.MultiValue

type = 'DEFAULT TAGS'¶

classmethod from_params(values, separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

values¶

class robot.parsing.model.statements.SuiteSetup(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Fixture

type = 'SUITE SETUP'¶

classmethod from_params(name, args=(), separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

args¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

name¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.SuiteTeardown(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Fixture

type = 'SUITE TEARDOWN'¶

classmethod from_params(name, args=(), separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

args¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

name¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.TestSetup(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Fixture

type = 'TEST SETUP'¶

classmethod from_params(name, args=(), separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

args¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

name¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.TestTeardown(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Fixture

type = 'TEST TEARDOWN'¶

classmethod from_params(name, args=(), separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

args¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

name¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.TestTemplate(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.SingleValue

type = 'TEST TEMPLATE'¶

classmethod from_params(value, separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

value¶

class robot.parsing.model.statements.TestTimeout(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.SingleValue

type = 'TEST TIMEOUT'¶

classmethod from_params(value, separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

value¶

class robot.parsing.model.statements.Variable(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'VARIABLE'¶

classmethod from_params(name, value, separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

name¶

value¶

validate()[source]¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

class robot.parsing.model.statements.TestCaseName(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'TESTCASE NAME'¶

classmethod from_params(name, eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

name¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.KeywordName(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'KEYWORD NAME'¶

classmethod from_params(name, eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

name¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.Setup(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Fixture

type = 'SETUP'¶

classmethod from_params(name, args=(), indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

args¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

name¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.Teardown(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Fixture

type = 'TEARDOWN'¶

classmethod from_params(name, args=(), indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

args¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

name¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.Tags(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.MultiValue

type = 'TAGS'¶

classmethod from_params(values, indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

values¶

class robot.parsing.model.statements.Template(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.SingleValue

type = 'TEMPLATE'¶

classmethod from_params(value, indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

value¶

class robot.parsing.model.statements.Timeout(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.SingleValue

type = 'TIMEOUT'¶

classmethod from_params(value, indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

value¶

class robot.parsing.model.statements.Arguments(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.MultiValue

type = 'ARGUMENTS'¶

classmethod from_params(args, indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

validate()[source]¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

values¶

class robot.parsing.model.statements.Return(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.MultiValue

type = 'RETURN'¶

classmethod from_params(args, indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

values¶

class robot.parsing.model.statements.KeywordCall(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'KEYWORD'¶

handles_types = ('KEYWORD', 'ASSIGN')¶

classmethod from_params(name, assign=(), args=(), indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

keyword¶

args¶

assign¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.TemplateArguments(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'ARGUMENT'¶

classmethod from_params(args, indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

args¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.ForHeader(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'FOR'¶

classmethod from_params(variables, values, flavor='IN', indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

variables¶

values¶

flavor¶

validate()[source]¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

class robot.parsing.model.statements.IfHeader(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'IF'¶

classmethod from_params(condition, indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

condition¶

validate()[source]¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

class robot.parsing.model.statements.ElseIfHeader(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.IfHeader

type = 'ELSE IF'¶

classmethod from_params(condition, indent=' ', separator=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

col_offset¶

condition¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.ElseHeader(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'ELSE'¶

classmethod from_params(indent=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

condition¶

validate()[source]¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

class robot.parsing.model.statements.End(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'END'¶

classmethod from_params(indent=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

validate()[source]¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

class robot.parsing.model.statements.Comment(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'COMMENT'¶

classmethod from_params(comment, indent=' ', eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.Error(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'ERROR'¶

handles_types = ('ERROR', 'FATAL ERROR')¶

errors¶

Errors got from the underlying ERROR and FATAL_ERROR tokens.

Errors can be set also explicitly. When accessing errors, they are returned along with errors got from tokens.

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_params(*args, **kwargs)¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

class robot.parsing.model.statements.EmptyLine(tokens, errors=())[source]¶

Bases: robot.parsing.model.statements.Statement

type = 'EOL'¶

col_offset¶

data_tokens¶

end_col_offset¶

end_lineno¶

classmethod from_params(eol='\n')[source]¶

Create statement from passed parameters.

Required and optional arguments should match class properties. Values are used to create matching tokens.

There is one notable difference for Documentation statement where settings_header flag is used to determine if statement belongs to settings header or test/keyword.

Most implementations support following general properties: - separator whitespace inserted between each token. Default is four spaces. - indent whitespace inserted before first token. Default is four spaces. - eol end of line sign. Default is '\n'.

classmethod from_tokens(tokens)¶

get_token(*types)¶

Return a token with the given type.

If there are no matches, return None. If there are multiple matches, return the first match.

get_tokens(*types)¶: Return tokens having any of the given types.

get_value(type, default=None)¶

Return value of a token with the given type.

If there are no matches, return default. If there are multiple matches, return the value of the first match.

get_values(*types)¶: Return values of tokens having any of the given types.

handles_types = ()¶

lineno¶

lines¶

classmethod register(subcls)¶

validate()¶

robot.parsing.model.visitor module¶

class robot.parsing.model.visitor.VisitorFinder[source]¶: Bases: object

class robot.parsing.model.visitor.ModelVisitor[source]¶

Bases: ast.NodeVisitor, robot.parsing.model.visitor.VisitorFinder

NodeVisitor that supports matching nodes based on their base classes.

Otherwise identical to the standard ast.NodeVisitor, but allows creating visit_ClassName methods so that the ClassName is one of the base classes of the node. For example, this visitor method matches all statements:

def visit_Statement(self, node):
    # ...

visit(node)[source]¶: Visit a node.

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

class robot.parsing.model.visitor.ModelTransformer[source]¶

Bases: ast.NodeTransformer, robot.parsing.model.visitor.VisitorFinder

NodeTransformer that supports matching nodes based on their base classes.

See ModelVisitor for explanation how this is different compared to the standard ast.NodeTransformer.

visit(node)[source]¶: Visit a node.

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

robot.parsing.parser package¶

Submodules¶

robot.parsing.parser.blockparsers module¶

class robot.parsing.parser.blockparsers.Parser(model)[source]¶

Bases: object

Base class for parsers.

handles(statement)[source]¶

parse(statement)[source]¶

class robot.parsing.parser.blockparsers.BlockParser(model)[source]¶

Bases: robot.parsing.parser.blockparsers.Parser

unhandled_tokens = frozenset(['TESTCASE HEADER', 'TESTCASE NAME', 'SETTING HEADER', 'VARIABLE HEADER', 'KEYWORD HEADER', 'COMMENT HEADER', 'KEYWORD NAME'])¶

handles(statement)[source]¶

parse(statement)[source]¶

class robot.parsing.parser.blockparsers.TestCaseParser(header)[source]¶

Bases: robot.parsing.parser.blockparsers.BlockParser

handles(statement)¶

parse(statement)¶

unhandled_tokens = frozenset(['TESTCASE HEADER', 'TESTCASE NAME', 'SETTING HEADER', 'VARIABLE HEADER', 'KEYWORD HEADER', 'COMMENT HEADER', 'KEYWORD NAME'])¶

class robot.parsing.parser.blockparsers.KeywordParser(header)[source]¶

Bases: robot.parsing.parser.blockparsers.BlockParser

handles(statement)¶

parse(statement)¶

unhandled_tokens = frozenset(['TESTCASE HEADER', 'TESTCASE NAME', 'SETTING HEADER', 'VARIABLE HEADER', 'KEYWORD HEADER', 'COMMENT HEADER', 'KEYWORD NAME'])¶

class robot.parsing.parser.blockparsers.NestedBlockParser(model)[source]¶

Bases: robot.parsing.parser.blockparsers.BlockParser

handles(statement)[source]¶

parse(statement)[source]¶

unhandled_tokens = frozenset(['TESTCASE HEADER', 'TESTCASE NAME', 'SETTING HEADER', 'VARIABLE HEADER', 'KEYWORD HEADER', 'COMMENT HEADER', 'KEYWORD NAME'])¶

class robot.parsing.parser.blockparsers.ForParser(header)[source]¶

Bases: robot.parsing.parser.blockparsers.NestedBlockParser

handles(statement)¶

parse(statement)¶

unhandled_tokens = frozenset(['TESTCASE HEADER', 'TESTCASE NAME', 'SETTING HEADER', 'VARIABLE HEADER', 'KEYWORD HEADER', 'COMMENT HEADER', 'KEYWORD NAME'])¶

class robot.parsing.parser.blockparsers.IfParser(header)[source]¶

Bases: robot.parsing.parser.blockparsers.NestedBlockParser

parse(statement)[source]¶

handles(statement)¶

unhandled_tokens = frozenset(['TESTCASE HEADER', 'TESTCASE NAME', 'SETTING HEADER', 'VARIABLE HEADER', 'KEYWORD HEADER', 'COMMENT HEADER', 'KEYWORD NAME'])¶

class robot.parsing.parser.blockparsers.OrElseParser(header)[source]¶

Bases: robot.parsing.parser.blockparsers.IfParser

handles(statement)[source]¶

parse(statement)¶

unhandled_tokens = frozenset(['TESTCASE HEADER', 'TESTCASE NAME', 'SETTING HEADER', 'VARIABLE HEADER', 'KEYWORD HEADER', 'COMMENT HEADER', 'KEYWORD NAME'])¶

robot.parsing.parser.fileparser module¶

class robot.parsing.parser.fileparser.FileParser(source=None)[source]¶

Bases: robot.parsing.parser.blockparsers.Parser

handles(statement)[source]¶

parse(statement)[source]¶

class robot.parsing.parser.fileparser.SectionParser(header)[source]¶

Bases: robot.parsing.parser.blockparsers.Parser

model_class = None¶

handles(statement)[source]¶

parse(statement)[source]¶

class robot.parsing.parser.fileparser.SettingSectionParser(header)[source]¶

Bases: robot.parsing.parser.fileparser.SectionParser

model_class¶: alias of robot.parsing.model.blocks.SettingSection

handles(statement)¶

parse(statement)¶

class robot.parsing.parser.fileparser.VariableSectionParser(header)[source]¶

Bases: robot.parsing.parser.fileparser.SectionParser

model_class¶: alias of robot.parsing.model.blocks.VariableSection

handles(statement)¶

parse(statement)¶

class robot.parsing.parser.fileparser.CommentSectionParser(header)[source]¶

Bases: robot.parsing.parser.fileparser.SectionParser

model_class¶: alias of robot.parsing.model.blocks.CommentSection

handles(statement)¶

parse(statement)¶

class robot.parsing.parser.fileparser.ImplicitCommentSectionParser(header)[source]¶

Bases: robot.parsing.parser.fileparser.SectionParser

model_class(statement)[source]¶

handles(statement)¶

parse(statement)¶

class robot.parsing.parser.fileparser.TestCaseSectionParser(header)[source]¶

Bases: robot.parsing.parser.fileparser.SectionParser

model_class¶: alias of robot.parsing.model.blocks.TestCaseSection

parse(statement)[source]¶

handles(statement)¶

class robot.parsing.parser.fileparser.KeywordSectionParser(header)[source]¶

Bases: robot.parsing.parser.fileparser.SectionParser

model_class¶: alias of robot.parsing.model.blocks.KeywordSection

parse(statement)[source]¶

handles(statement)¶

robot.parsing.parser.parser module¶

robot.parsing.parser.parser.get_model(source, data_only=False, curdir=None)[source]¶

Parses the given source to a model represented as an AST.

How to use the model is explained more thoroughly in the general documentation of the robot.parsing module.

Parameters:

source – The source where to read the data. Can be a path to a source file as a string or as pathlib.Path object, an already opened file object, or Unicode text containing the date directly. Source files must be UTF-8 encoded.
data_only – When False (default), returns all tokens. When set to True, omits separators, comments, continuation markers, and other non-data tokens. Model like this cannot be saved back to file system.
curdir – Directory where the source file exists. This path is used to set the value of the built-in ${CURDIR} variable during parsing. When not given, the variable is left as-is. Should only be given only if the model will be executed afterwards. If the model is saved back to disk, resolving ${CURDIR} is typically not a good idea.

Use get_resource_model() or get_init_model() when parsing resource or suite initialization files, respectively.

robot.parsing.parser.parser.get_resource_model(source, data_only=False, curdir=None)[source]¶

Parses the given source to a resource file model.

Otherwise same as get_model() but the source is considered to be a resource file. This affects, for example, what settings are valid.

robot.parsing.parser.parser.get_init_model(source, data_only=False, curdir=None)[source]¶

Parses the given source to a init file model.

Otherwise same as get_model() but the source is considered to be a suite initialization file. This affects, for example, what settings are valid.

Submodules¶

robot.parsing.suitestructure module¶

class robot.parsing.suitestructure.SuiteStructure(source=None, init_file=None, children=None)[source]¶

Bases: object

is_directory¶

visit(visitor)[source]¶

class robot.parsing.suitestructure.SuiteStructureBuilder(included_extensions=('robot', ), included_suites=None)[source]¶

Bases: object

ignored_prefixes = ('_', '.')¶

ignored_dirs = ('CVS',)¶

build(paths)[source]¶

class robot.parsing.suitestructure.SuiteStructureVisitor[source]¶

Bases: object

visit_file(structure)[source]¶

visit_directory(structure)[source]¶

start_directory(structure)[source]¶

end_directory(structure)[source]¶

robot.reporting package¶

Implements report, log, output XML, and xUnit file generation.

The public API of this package is the ResultWriter class. It can write result files based on XML output files on the file system, as well as based on the result objects returned by the ExecutionResult() factory method or an executed TestSuite.

It is highly recommended to use the public API via the robot.api package.

This package is considered stable.

Submodules¶

robot.reporting.expandkeywordmatcher module¶

class robot.reporting.expandkeywordmatcher.ExpandKeywordMatcher(expand_keywords)[source]¶

Bases: object

match(kw)[source]¶

robot.reporting.jsbuildingcontext module¶

class robot.reporting.jsbuildingcontext.JsBuildingContext(log_path=None, split_log=False, expand_keywords=None, prune_input=False)[source]¶

Bases: object

string(string, escape=True, attr=False)[source]¶

html(string)[source]¶

relative_source(source)[source]¶

timestamp(time)[source]¶

message_level(level)[source]¶

create_link_target(msg)[source]¶

check_expansion(kw)[source]¶

expand_keywords¶

link(msg)[source]¶

strings¶

start_splitting_if_needed(split=False)[source]¶

end_splitting(model)[source]¶

prune_input(**kwds)[source]¶

robot.reporting.jsexecutionresult module¶

class robot.reporting.jsexecutionresult.JsExecutionResult(suite, statistics, errors, strings, basemillis=None, split_results=None, min_level=None, expand_keywords=None)[source]¶

Bases: object

remove_data_not_needed_in_report()[source]¶

robot.reporting.jsmodelbuilders module¶

class robot.reporting.jsmodelbuilders.JsModelBuilder(log_path=None, split_log=False, expand_keywords=None, prune_input_to_save_memory=False)[source]¶

Bases: object

build_from(result_from_xml)[source]¶

class robot.reporting.jsmodelbuilders.SuiteBuilder(context)[source]¶

Bases: robot.reporting.jsmodelbuilders._Builder

build(suite)[source]¶

class robot.reporting.jsmodelbuilders.TestBuilder(context)[source]¶

Bases: robot.reporting.jsmodelbuilders._Builder

build(test)[source]¶

class robot.reporting.jsmodelbuilders.KeywordBuilder(context)[source]¶

Bases: robot.reporting.jsmodelbuilders._Builder

build(item, split=False)[source]¶

build_keyword(kw, split=False)[source]¶

class robot.reporting.jsmodelbuilders.MessageBuilder(context)[source]¶

Bases: robot.reporting.jsmodelbuilders._Builder

build(msg)[source]¶

class robot.reporting.jsmodelbuilders.StatisticsBuilder[source]¶

Bases: object

build(statistics)[source]¶

class robot.reporting.jsmodelbuilders.ErrorsBuilder(context)[source]¶

Bases: robot.reporting.jsmodelbuilders._Builder

build(errors)[source]¶

class robot.reporting.jsmodelbuilders.ErrorMessageBuilder(context)[source]¶

Bases: robot.reporting.jsmodelbuilders.MessageBuilder

build(msg)[source]¶

robot.reporting.jswriter module¶

class robot.reporting.jswriter.JsResultWriter(output, start_block='<script type="text/javascript">n', end_block='</script>n', split_threshold=9500)[source]¶

Bases: object

write(result, settings)[source]¶

class robot.reporting.jswriter.SuiteWriter(write_json, split_threshold)[source]¶

Bases: object

write(suite, variable)[source]¶

class robot.reporting.jswriter.SplitLogWriter(output)[source]¶

Bases: object

write(keywords, strings, index, notify)[source]¶

robot.reporting.logreportwriters module¶

class robot.reporting.logreportwriters.LogWriter(js_model)[source]¶

Bases: robot.reporting.logreportwriters._LogReportWriter

usage = 'log'¶

write(path, config)[source]¶

class robot.reporting.logreportwriters.ReportWriter(js_model)[source]¶

Bases: robot.reporting.logreportwriters._LogReportWriter

usage = 'report'¶

write(path, config)[source]¶

class robot.reporting.logreportwriters.RobotModelWriter(output, model, config)[source]¶

Bases: robot.htmldata.htmlfilewriter.ModelWriter

write(line)[source]¶

handles(line)¶

robot.reporting.outputwriter module¶

class robot.reporting.outputwriter.OutputWriter(output, rpa=False)[source]¶

Bases: robot.output.xmllogger.XmlLogger

start_message(msg)[source]¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

close()[source]¶

end_result(result)[source]¶

end_errors(errors=None)¶

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(kw)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_stat(stat)¶

end_statistics(stats)¶

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_suite_statistics(tag_stats)¶

end_tag_statistics(tag_stats)¶

end_test(test)¶: Called when test ends. Default implementation does nothing.

end_total_statistics(total_stats)¶

log_message(msg)¶

message(msg)¶

set_log_level(level)¶

start_errors(errors=None)¶

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(kw)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_result(result)¶

start_stat(stat)¶

start_statistics(stats)¶

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite_statistics(tag_stats)¶

start_tag_statistics(tag_stats)¶

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_total_statistics(total_stats)¶

visit_errors(errors)¶

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_result(result)¶

visit_stat(stat)¶

visit_statistics(stats)¶

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_suite_statistics(stats)¶

visit_tag_statistics(stats)¶

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_total_statistics(stats)¶

robot.reporting.resultwriter module¶

class robot.reporting.resultwriter.ResultWriter(*sources)[source]¶

Bases: object

A class to create log, report, output XML and xUnit files.

Parameters:	sources – Either one `Result` object, or one or more paths to existing output XML files.

By default writes report.html and log.html, but no output XML or xUnit files. Custom file names can be given and results disabled or enabled using settings or options passed to the write_results() method. The latter is typically more convenient:

writer = ResultWriter(result)
writer.write_results(report='custom.html', log=None, xunit='xunit.xml')

write_results(settings=None, **options)[source]¶

Writes results based on the given settings or options.

Parameters:	settings – `RebotSettings` object to configure result writing. options – Used to construct new `RebotSettings` object if `settings` are not given.

class robot.reporting.resultwriter.Results(settings, *sources)[source]¶

Bases: object

result¶

js_result¶

robot.reporting.stringcache module¶

class robot.reporting.stringcache.StringIndex[source]¶

Bases: int

bit_length() → int¶: Number of bits necessary to represent self in binary. >>> bin(37) ‘0b100101’ >>> (37).bit_length() 6

conjugate()¶: Returns self, the complex conjugate of any int.

denominator¶: the denominator of a rational number in lowest terms

imag¶: the imaginary part of a complex number

numerator¶: the numerator of a rational number in lowest terms

real¶: the real part of a complex number

class robot.reporting.stringcache.StringCache[source]¶

Bases: object

add(text)[source]¶

dump()[source]¶

robot.reporting.xunitwriter module¶

class robot.reporting.xunitwriter.XUnitWriter(execution_result)[source]¶

Bases: object

write(output)[source]¶

class robot.reporting.xunitwriter.XUnitFileWriter(xml_writer)[source]¶

Bases: robot.result.visitor.ResultVisitor

Provides an xUnit-compatible result file.

Attempts to adhere to the de facto schema guessed by Peter Reilly, see: http://marc.info/?l=ant-dev&m=123551933508682

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_suite(suite)[source]¶: Called when suite ends. Default implementation does nothing.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(kw)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_statistics(stats)[source]¶

visit_errors(errors)[source]¶

end_result(result)[source]¶

end_errors(errors)¶

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_stat(stat)¶

end_statistics(stats)¶

end_suite_statistics(suite_stats)¶

end_tag_statistics(stats)¶

end_test(test)¶: Called when test ends. Default implementation does nothing.

end_total_statistics(stats)¶

start_errors(errors)¶

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_result(result)¶

start_stat(stat)¶

start_statistics(stats)¶

start_suite_statistics(stats)¶

start_tag_statistics(stats)¶

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_total_statistics(stats)¶

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_result(result)¶

visit_stat(stat)¶

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_suite_statistics(stats)¶

visit_tag_statistics(stats)¶

visit_total_statistics(stats)¶

robot.result package¶

Implements parsing execution results from XML output files.

The main public API of this package consists of the ExecutionResult() factory method, that returns Result objects, and of the ResultVisitor abstract class, that eases further processing the results.

The model objects in the model module can also be considered to be part of the public API, because they can be found inside the Result object. They can also be inspected and modified as part of the normal test execution by pre-Rebot modifiers and listeners.

It is highly recommended to import the public entry-points via the robot.api package like in the example below. In those rare cases where the aforementioned model objects are needed directly, they can be imported from this package.

This package is considered stable.

Example¶

#!/usr/bin/env python

"""Usage: check_test_times.py seconds inpath [outpath]

Reads test execution result from an output XML file and checks that no test
took longer than given amount of seconds to execute.

Optional `outpath` specifies where to write processed results. If not given,
results are written over the original file.
"""

import sys
from robot.api import ExecutionResult, ResultVisitor


class ExecutionTimeChecker(ResultVisitor):

    def __init__(self, max_seconds):
        self.max_milliseconds = max_seconds * 1000

    def visit_test(self, test):
        if test.status == 'PASS' and test.elapsedtime > self.max_milliseconds:
            test.status = 'FAIL'
            test.message = 'Test execution took too long.'


def check_tests(seconds, inpath, outpath=None):
    result = ExecutionResult(inpath)
    result.visit(ExecutionTimeChecker(float(seconds)))
    result.save(outpath)


if __name__ == '__main__':
    try:
        check_tests(*sys.argv[1:])
    except TypeError:
        print(__doc__)

Submodules¶

robot.result.configurer module¶

class robot.result.configurer.SuiteConfigurer(remove_keywords=None, log_level=None, start_time=None, end_time=None, **base_config)[source]¶

Bases: robot.model.configurer.SuiteConfigurer

Result suite configured.

Calls suite’s remove_keywords() and filter_messages() methods and sets its start and end time based on the given named parameters.

base_config is forwarded to robot.model.SuiteConfigurer that will do further configuration based on them.

visit_suite(suite)[source]¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

add_tags¶

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

remove_tags¶

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

robot.result.executionerrors module¶

class robot.result.executionerrors.ExecutionErrors(messages=None)[source]¶

Bases: object

Represents errors occurred during the execution of tests.

An error might be, for example, that importing a library has failed.

id = 'errors'¶

messages¶: A list-like object of Message instances.

add(other)[source]¶

visit(visitor)[source]¶

robot.result.executionresult module¶

class robot.result.executionresult.Result(source=None, root_suite=None, errors=None, rpa=None)[source]¶

Bases: object

Test execution results.

Can be created based on XML output files using the ExecutionResult() factory method. Also returned by the robot.running.TestSuite.run method.

source = None¶: Path to the XML file where results are read from.

suite = None¶: Hierarchical execution results as a TestSuite object.

errors = None¶: Execution errors as an ExecutionErrors object.

statistics¶

Test execution statistics.

Statistics are an instance of Statistics that is created based on the contained suite and possible configuration.

Statistics are created every time this property is accessed. Saving them to a variable is thus often a good idea to avoid re-creating them unnecessarily:

from robot.api import ExecutionResult

result = ExecutionResult('output.xml')
result.configure(stat_config={'suite_stat_level': 2,
                              'tag_stat_combine': 'tagANDanother'})
stats = result.statistics
print(stats.total.failed)
print(stats.total.passed)
print(stats.tags.combined[0].total)

return_code¶

Return code (integer) of test execution.

By default returns the number of failed tests (max 250), but can be configured to always return 0.

configure(status_rc=True, suite_config=None, stat_config=None)[source]¶

Configures the result object and objects it contains.

Parameters:	status_rc – If set to `False`, `return_code` always returns 0. suite_config – A dictionary of configuration options passed to `configure()` method of the contained `suite`. stat_config – A dictionary of configuration options used when creating `statistics`.

save(path=None)[source]¶

Save results as a new output XML file.

Parameters:	path – Path to save results to. If omitted, overwrites the original file.

visit(visitor)[source]¶

An entry point to visit the whole result object.

Parameters:	visitor – An instance of `ResultVisitor`.

Visitors can gather information, modify results, etc. See result package for a simple usage example.

Notice that it is also possible to call result.suite.visit if there is no need to visit the contained statistics or errors.

handle_suite_teardown_failures()[source]¶: Internal usage only.

set_execution_mode(other)[source]¶: Set execution mode based on other result. Internal usage only.

class robot.result.executionresult.CombinedResult(results=None)[source]¶

Bases: robot.result.executionresult.Result

Combined results of multiple test executions.

add_result(other)[source]¶

configure(status_rc=True, suite_config=None, stat_config=None)¶

Configures the result object and objects it contains.

Parameters:	status_rc – If set to `False`, `return_code` always returns 0. suite_config – A dictionary of configuration options passed to `configure()` method of the contained `suite`. stat_config – A dictionary of configuration options used when creating `statistics`.

handle_suite_teardown_failures()¶: Internal usage only.

return_code¶

Return code (integer) of test execution.

By default returns the number of failed tests (max 250), but can be configured to always return 0.

save(path=None)¶

Save results as a new output XML file.

Parameters:	path – Path to save results to. If omitted, overwrites the original file.

set_execution_mode(other)¶: Set execution mode based on other result. Internal usage only.

statistics¶

Test execution statistics.

Statistics are an instance of Statistics that is created based on the contained suite and possible configuration.

Statistics are created every time this property is accessed. Saving them to a variable is thus often a good idea to avoid re-creating them unnecessarily:

from robot.api import ExecutionResult

result = ExecutionResult('output.xml')
result.configure(stat_config={'suite_stat_level': 2,
                              'tag_stat_combine': 'tagANDanother'})
stats = result.statistics
print(stats.total.failed)
print(stats.total.passed)
print(stats.tags.combined[0].total)

visit(visitor)¶

An entry point to visit the whole result object.

Parameters:	visitor – An instance of `ResultVisitor`.

Visitors can gather information, modify results, etc. See result package for a simple usage example.

Notice that it is also possible to call result.suite.visit if there is no need to visit the contained statistics or errors.

robot.result.flattenkeywordmatcher module¶

robot.result.flattenkeywordmatcher.validate_flatten_keyword(options)[source]¶

class robot.result.flattenkeywordmatcher.FlattenByTypeMatcher(flatten)[source]¶

Bases: object

match(tag)[source]¶

class robot.result.flattenkeywordmatcher.FlattenByNameMatcher(flatten)[source]¶

Bases: object

match(kwname, libname=None)[source]¶

class robot.result.flattenkeywordmatcher.FlattenByTagMatcher(flatten)[source]¶

Bases: object

match(kwtags)[source]¶

robot.result.keywordremover module¶

robot.result.keywordremover.KeywordRemover(how)[source]¶

class robot.result.keywordremover.AllKeywordsRemover[source]¶

Bases: robot.result.keywordremover._KeywordRemover

visit_keyword(keyword)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_for(for_)[source]¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_if_branch(branch)[source]¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

class robot.result.keywordremover.PassedKeywordRemover[source]¶

Bases: robot.result.keywordremover._KeywordRemover

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(keyword)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

class robot.result.keywordremover.ByNameKeywordRemover(pattern)[source]¶

Bases: robot.result.keywordremover._KeywordRemover

start_keyword(kw)[source]¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

class robot.result.keywordremover.ByTagKeywordRemover(pattern)[source]¶

Bases: robot.result.keywordremover._KeywordRemover

start_keyword(kw)[source]¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

class robot.result.keywordremover.ForLoopItemsRemover[source]¶

Bases: robot.result.keywordremover._KeywordRemover

start_for(for_)[source]¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

class robot.result.keywordremover.WaitUntilKeywordSucceedsRemover[source]¶

Bases: robot.result.keywordremover._KeywordRemover

start_keyword(kw)[source]¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

class robot.result.keywordremover.WarningAndErrorFinder[source]¶

Bases: robot.model.visitor.SuiteVisitor

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)[source]¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)[source]¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_message(msg)[source]¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

class robot.result.keywordremover.RemovalMessage(message)[source]¶

Bases: object

set_if_removed(kw, len_before)[source]¶

set(kw, message=None)[source]¶

robot.result.merger module¶

class robot.result.merger.Merger(result, rpa=False)[source]¶

Bases: robot.model.visitor.SuiteVisitor

merge(merged)[source]¶

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_suite(suite)[source]¶: Called when suite ends. Default implementation does nothing.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

robot.result.messagefilter module¶

class robot.result.messagefilter.MessageFilter(log_level=None)[source]¶

Bases: robot.model.visitor.SuiteVisitor

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)[source]¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

robot.result.model module¶

Module implementing result related model objects.

During test execution these objects are created internally by various runners. At that time they can inspected and modified by listeners.

When results are parsed from XML output files after execution to be able to create logs and reports, these objects are created by the ExecutionResult() factory method. At that point they can be inspected and modified by pre-Rebot modifiers.

The ExecutionResult() factory method can also be used by custom scripts and tools. In such usage it is often easiest to inspect and modify these objects using the visitor interface.

class robot.result.model.Body(parent=None, items=None)[source]¶

Bases: robot.model.body.Body

message_class¶: alias of Message

create_message(*args, **kwargs)[source]¶

filter(keywords=None, fors=None, ifs=None, messages=None, predicate=None)[source]¶

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 FOR and IF constructs use body.filter(fors=False, ifs=False). Including and excluding by types at the same time is not supported.

Custom predicate is a calleble 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.

append(item)¶

clear()¶

count(item)¶

create¶

create_for(*args, **kwargs)[source]¶

create_if(*args, **kwargs)[source]¶

create_keyword(*args, **kwargs)[source]¶

extend(items)¶

for_class¶: alias of For

if_class¶: alias of If

index(item, *start_and_end)¶

insert(index, item)¶

keyword_class¶: alias of Keyword

pop(*index)¶

classmethod register(item_class)[source]¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

class robot.result.model.ForIterations(parent=None, items=None)[source]¶

Bases: robot.result.model.Body

for_iteration_class¶: alias of ForIteration

if_class = None¶

for_class = None¶

create_iteration(*args, **kwargs)[source]¶

append(item)¶

clear()¶

count(item)¶

create¶

create_for(*args, **kwargs)¶

create_if(*args, **kwargs)¶

create_keyword(*args, **kwargs)¶

create_message(*args, **kwargs)¶

extend(items)¶

filter(keywords=None, fors=None, ifs=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 FOR and IF constructs use body.filter(fors=False, ifs=False). Including and excluding by types at the same time is not supported.

Custom predicate is a calleble 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.

index(item, *start_and_end)¶

insert(index, item)¶

keyword_class¶: alias of Keyword

message_class¶: alias of Message

pop(*index)¶

classmethod register(item_class)¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

class robot.result.model.IfBranches(parent=None, items=None)[source]¶

Bases: robot.result.model.Body, robot.model.body.IfBranches

append(item)¶

clear()¶

count(item)¶

create¶

create_branch(*args, **kwargs)[source]¶

create_for(*args, **kwargs)¶

create_if(*args, **kwargs)¶

create_keyword(*args, **kwargs)¶

create_message(*args, **kwargs)¶

extend(items)¶

filter(keywords=None, fors=None, ifs=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 FOR and IF constructs use body.filter(fors=False, ifs=False). Including and excluding by types at the same time is not supported.

Custom predicate is a calleble 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.

for_class¶: alias of For

if_branch_class¶: alias of IfBranch

if_class¶: alias of If

index(item, *start_and_end)¶

insert(index, item)¶

keyword_class¶: alias of Keyword

message_class¶: alias of Message

pop(*index)¶

classmethod register(item_class)¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

class robot.result.model.Message(message='', level='INFO', html=False, timestamp=None, parent=None)[source]¶

Bases: robot.model.message.Message

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

html¶

html_message¶: Returns the message content as HTML.

id¶

level¶

message¶

parent¶

repr_args = ('message', 'level')¶

timestamp¶

type = 'MESSAGE'¶

visit(visitor)[source]¶: Visitor interface entry-point.

class robot.result.model.StatusMixin[source]¶

Bases: object

PASS = 'PASS'¶

FAIL = 'FAIL'¶

SKIP = 'SKIP'¶

NOT_RUN = 'NOT RUN'¶

NOT_SET = 'NOT SET'¶

elapsedtime¶: Total execution time in milliseconds.

passed¶: True when status is ‘PASS’, False otherwise.

failed¶: True when status is ‘FAIL’, False otherwise.

skipped¶

True when status is ‘SKIP’, False otherwise.

Setting to False value is ambiguous and raises an exception.

not_run¶

True when status is ‘NOT RUN’, False otherwise.

Setting to False value is ambiguous and raises an exception.

class robot.result.model.ForIteration(variables=None, status='FAIL', starttime=None, endtime=None, doc='', parent=None)[source]¶

Bases: robot.model.body.BodyItem, robot.result.model.StatusMixin, robot.result.modeldeprecation.DeprecatedAttributesMixin

type = 'FOR ITERATION'¶

body_class¶: alias of Body

repr_args = ('variables',)¶

variables¶

parent¶

status¶

starttime¶

endtime¶

doc¶

body¶

visit(visitor)[source]¶

name¶: Deprecated.

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FAIL = 'FAIL'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

NOT_RUN = 'NOT RUN'¶

NOT_SET = 'NOT SET'¶

PASS = 'PASS'¶

SETUP = 'SETUP'¶

SKIP = 'SKIP'¶

TEARDOWN = 'TEARDOWN'¶

args¶: Deprecated.

assign¶: Deprecated.

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

elapsedtime¶: Total execution time in milliseconds.

failed¶: True when status is ‘FAIL’, False otherwise.

id¶

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

kwname¶: Deprecated.

libname¶: Deprecated.

message¶: Deprecated.

not_run¶

True when status is ‘NOT RUN’, False otherwise.

Setting to False value is ambiguous and raises an exception.

passed¶: True when status is ‘PASS’, False otherwise.

skipped¶

True when status is ‘SKIP’, False otherwise.

Setting to False value is ambiguous and raises an exception.

tags¶: Deprecated.

timeout¶: Deprecated.

class robot.result.model.For(variables=(), flavor='IN', values=(), status='FAIL', starttime=None, endtime=None, doc='', parent=None)[source]¶

Bases: robot.model.control.For, robot.result.model.StatusMixin, robot.result.modeldeprecation.DeprecatedAttributesMixin

body_class¶: alias of ForIterations

status¶

starttime¶

endtime¶

doc¶

name¶: Deprecated.

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FAIL = 'FAIL'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

NOT_RUN = 'NOT RUN'¶

NOT_SET = 'NOT SET'¶

PASS = 'PASS'¶

SETUP = 'SETUP'¶

SKIP = 'SKIP'¶

TEARDOWN = 'TEARDOWN'¶

args¶: Deprecated.

assign¶: Deprecated.

body¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

elapsedtime¶: Total execution time in milliseconds.

failed¶: True when status is ‘FAIL’, False otherwise.

flavor¶

id¶

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

keywords¶: Deprecated since Robot Framework 4.0. Use body instead.

kwname¶: Deprecated.

libname¶: Deprecated.

message¶: Deprecated.

not_run¶

True when status is ‘NOT RUN’, False otherwise.

Setting to False value is ambiguous and raises an exception.

parent¶

passed¶: True when status is ‘PASS’, False otherwise.

repr_args = ('variables', 'flavor', 'values')¶

skipped¶

True when status is ‘SKIP’, False otherwise.

Setting to False value is ambiguous and raises an exception.

tags¶: Deprecated.

timeout¶: Deprecated.

type = 'FOR'¶

values¶

variables¶

visit(visitor)[source]¶

class robot.result.model.If(parent=None, status='FAIL', starttime=None, endtime=None, doc='')[source]¶

Bases: robot.model.control.If, robot.result.model.StatusMixin, robot.result.modeldeprecation.DeprecatedAttributesMixin

body_class¶: alias of IfBranches

status¶

starttime¶

endtime¶

doc¶

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FAIL = 'FAIL'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

NOT_RUN = 'NOT RUN'¶

NOT_SET = 'NOT SET'¶

PASS = 'PASS'¶

SETUP = 'SETUP'¶

SKIP = 'SKIP'¶

TEARDOWN = 'TEARDOWN'¶

args¶: Deprecated.

assign¶: Deprecated.

body¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

elapsedtime¶: Total execution time in milliseconds.

failed¶: True when status is ‘FAIL’, False otherwise.

id¶: Root IF/ELSE id is always None.

kwname¶: Deprecated.

libname¶: Deprecated.

message¶: Deprecated.

name¶: Deprecated.

not_run¶

True when status is ‘NOT RUN’, False otherwise.

Setting to False value is ambiguous and raises an exception.

parent¶

passed¶: True when status is ‘PASS’, False otherwise.

repr_args = ()¶

skipped¶

True when status is ‘SKIP’, False otherwise.

Setting to False value is ambiguous and raises an exception.

tags¶: Deprecated.

timeout¶: Deprecated.

type = 'IF/ELSE ROOT'¶

visit(visitor)[source]¶

class robot.result.model.IfBranch(type='IF', condition=None, status='FAIL', starttime=None, endtime=None, doc='', parent=None)[source]¶

Bases: robot.model.control.IfBranch, robot.result.model.StatusMixin, robot.result.modeldeprecation.DeprecatedAttributesMixin

body_class¶: alias of Body

status¶

starttime¶

endtime¶

doc¶

name¶: Deprecated.

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FAIL = 'FAIL'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

NOT_RUN = 'NOT RUN'¶

NOT_SET = 'NOT SET'¶

PASS = 'PASS'¶

SETUP = 'SETUP'¶

SKIP = 'SKIP'¶

TEARDOWN = 'TEARDOWN'¶

args¶: Deprecated.

assign¶: Deprecated.

body¶

condition¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

elapsedtime¶: Total execution time in milliseconds.

failed¶: True when status is ‘FAIL’, False otherwise.

id¶: Branch id omits the root IF/ELSE object from the parent id part.

kwname¶: Deprecated.

libname¶: Deprecated.

message¶: Deprecated.

not_run¶

True when status is ‘NOT RUN’, False otherwise.

Setting to False value is ambiguous and raises an exception.

parent¶

passed¶: True when status is ‘PASS’, False otherwise.

repr_args = ('type', 'condition')¶

skipped¶

True when status is ‘SKIP’, False otherwise.

Setting to False value is ambiguous and raises an exception.

tags¶: Deprecated.

timeout¶: Deprecated.

type¶

visit(visitor)[source]¶

class robot.result.model.Keyword(kwname='', libname='', doc='', args=(), assign=(), tags=(), timeout=None, type='KEYWORD', status='FAIL', starttime=None, endtime=None, parent=None, sourcename=None)[source]¶

Bases: robot.model.keyword.Keyword, robot.result.model.StatusMixin

Represents results of a single keyword.

See the base class for documentation of attributes not documented here.

body_class¶: alias of Body

kwname¶: Name of the keyword without library or resource name.

libname¶: Name of the library or resource containing this keyword.

status¶: Execution status as a string. PASS, FAIL, SKIP or NOT RUN.

starttime¶: Keyword execution start time in format %Y%m%d %H:%M:%S.%f.

endtime¶: Keyword execution end time in format %Y%m%d %H:%M:%S.%f.

message¶: Keyword status message. Used only if suite teardowns fails.

sourcename¶: Original name of keyword with embedded arguments.

body¶: Child keywords and messages as a Body object.

keywords¶

Deprecated since Robot Framework 4.0.

Use body or teardown instead.

messages¶

Keyword’s messages.

Starting from Robot Framework 4.0 this is a list generated from messages in body.

children¶

List of child keywords and messages in creation order.

Deprecated since Robot Framework 4.0. Use :att:`body` instead.

name¶

Keyword name in format libname.kwname.

Just kwname if libname is empty. In practice that is the case only with user keywords in the same file as the executed test case or test suite.

Cannot be set directly. Set libname and kwname separately instead.

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FAIL = 'FAIL'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

NOT_RUN = 'NOT RUN'¶

NOT_SET = 'NOT SET'¶

PASS = 'PASS'¶

SETUP = 'SETUP'¶

SKIP = 'SKIP'¶

TEARDOWN = 'TEARDOWN'¶

args¶

assign¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

doc¶

elapsedtime¶: Total execution time in milliseconds.

failed¶: True when status is ‘FAIL’, False otherwise.

has_teardown¶

Check does a keyword have a teardown without creating a teardown object.

A difference between using if kw.has_teardown: and if kw.teardown: is that accessing the teardown attribute creates a Keyword object representing a teardown even when the keyword actually does not have one. This typically does not matter, but with bigger suite structures having lot of keywords it can have a considerable effect on memory usage.

New in Robot Framework 4.1.2.

id¶

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

not_run¶

True when status is ‘NOT RUN’, False otherwise.

Setting to False value is ambiguous and raises an exception.

parent¶

passed¶: True when status is ‘PASS’, False otherwise.

repr_args = ('name', 'args', 'assign')¶

skipped¶

True when status is ‘SKIP’, False otherwise.

Setting to False value is ambiguous and raises an exception.

tags¶: Keyword tags as a Tags object.

teardown¶

Keyword teardown as a Keyword object.

Teardown can be modified by setting attributes directly:

keyword.teardown.name = 'Example'
keyword.teardown.args = ('First', 'Second')

Alternatively the config() method can be used to set multiple attributes in one call:

keyword.teardown.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole teardown is setting it to None. It will automatically recreate the underlying Keyword object:

keyword.teardown = None

This attribute is a Keyword object also when a keyword has no teardown but in that case its truth value is False. If there is a need to just check does a keyword have a teardown, using the has_teardown attribute avoids creating the Keyword object and is thus more memory efficient.

New in Robot Framework 4.0. Earlier teardown was accessed like keyword.keywords.teardown. has_teardown is new in Robot Framework 4.1.2.

timeout¶

type¶

visit(visitor)[source]¶: Visitor interface entry-point.

class robot.result.model.TestCase(name='', doc='', tags=None, timeout=None, status='FAIL', message='', starttime=None, endtime=None)[source]¶

Bases: robot.model.testcase.TestCase, robot.result.model.StatusMixin

Represents results of a single test case.

See the base class for documentation of attributes not documented here.

body_class¶: alias of Body

fixture_class¶: alias of Keyword

status¶: Status as a string PASS or FAIL. See also passed.

message¶: Test message. Typically a failure message but can be set also when test passes.

starttime¶: Test case execution start time in format %Y%m%d %H:%M:%S.%f.

endtime¶: Test case execution end time in format %Y%m%d %H:%M:%S.%f.

not_run¶

critical¶

FAIL = 'FAIL'¶

NOT_RUN = 'NOT RUN'¶

NOT_SET = 'NOT SET'¶

PASS = 'PASS'¶

SKIP = 'SKIP'¶

body¶: Test case body as a Body object.

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

doc¶

elapsedtime¶: Total execution time in milliseconds.

failed¶: True when status is ‘FAIL’, False otherwise.

id¶

Test case id in format like s1-t3.

See TestSuite.id for more information.

keywords¶

Deprecated since Robot Framework 4.0

Use body, setup or teardown instead.

longname¶: Test name prefixed with the long name of the parent suite.

name¶

parent¶

passed¶: True when status is ‘PASS’, False otherwise.

repr_args = ('name',)¶

setup¶

Test setup as a Keyword object.

This attribute is a Keyword object also when a test has no setup but in that case its truth value is False.

Setup can be modified by setting attributes directly:

test.setup.name = 'Example'
test.setup.args = ('First', 'Second')

Alternatively the config() method can be used to set multiple attributes in one call:

test.setup.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole setup is setting it to None. It will automatically recreate the underlying Keyword object:

test.setup = None

New in Robot Framework 4.0. Earlier setup was accessed like test.keywords.setup.

skipped¶

True when status is ‘SKIP’, False otherwise.

Setting to False value is ambiguous and raises an exception.

source¶

tags¶: Test tags as a Tags object.

teardown¶

Test teardown as a Keyword object.

See setup for more information.

timeout¶

visit(visitor)[source]¶: Visitor interface entry-point.

class robot.result.model.TestSuite(name='', doc='', metadata=None, source=None, message='', starttime=None, endtime=None, rpa=False)[source]¶

Bases: robot.model.testsuite.TestSuite, robot.result.model.StatusMixin

Represents results of a single test suite.

See the base class for documentation of attributes not documented here.

test_class¶: alias of TestCase

fixture_class¶: alias of Keyword

message¶: Possible suite setup or teardown error message.

starttime¶: Suite execution start time in format %Y%m%d %H:%M:%S.%f.

endtime¶: Suite execution end time in format %Y%m%d %H:%M:%S.%f.

passed¶: True if no test has failed but some have passed, False otherwise.

failed¶: True if any test has failed, False otherwise.

skipped¶: True if there are no passed or failed tests, False otherwise.

not_run¶

status¶

‘PASS’, ‘FAIL’ or ‘SKIP’ depending on test statuses.

If any test has failed, status is ‘FAIL’.
If no test has failed but at least some test has passed, status is ‘PASS’.
If there are no failed or passed tests, status is ‘SKIP’. This covers both the case when all tests have been skipped and when there are no tests.

statistics¶

Suite statistics as a TotalStatistics object.

Recreated every time this property is accessed, so saving the results to a variable and inspecting it is often a good idea:

stats = suite.statistics
print(stats.failed)
print(stats.total)
print(stats.message)

full_message¶: Combination of message and stat_message.

FAIL = 'FAIL'¶

NOT_RUN = 'NOT RUN'¶

NOT_SET = 'NOT SET'¶

PASS = 'PASS'¶

SKIP = 'SKIP'¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

doc¶

filter(included_suites=None, included_tests=None, included_tags=None, excluded_tags=None)[source]¶

Select test cases and remove others from this suite.

Parameters have the same semantics as --suite, --test, --include, and --exclude command line options. All of them can be given as a list of strings, or when selecting only one, as a single string.

Child suites that contain no tests after filtering are automatically removed.

Example:

suite.filter(included_tests=['Test 1', '* Example'],
             included_tags='priority-1')

has_tests¶

id¶

An automatically generated unique id.

The root suite has id s1, its child suites have ids s1-s1, s1-s2, …, their child suites get ids s1-s1-s1, s1-s1-s2, …, s1-s2-s1, …, and so on.

The first test in a suite has an id like s1-t1, the second has an id s1-t2, and so on. Similarly keywords in suites (setup/teardown) and in tests get ids like s1-k1, s1-t1-k1, and s1-s4-t2-k5.

keywords¶

Deprecated since Robot Framework 4.0

Use setup or teardown instead.

longname¶: Suite name prefixed with the long name of the parent suite.

metadata¶: Free test suite metadata as a dictionary.

name¶: Test suite name. If not set, constructed from child suite names.

parent¶

remove_empty_suites(preserve_direct_children=False)[source]¶: Removes all child suites not containing any tests, recursively.

repr_args = ('name',)¶

rpa¶

set_tags(add=None, remove=None, persist=False)[source]¶

Add and/or remove specified tags to the tests in this suite.

Parameters:	add – Tags to add as a list or, if adding only one, as a single string. remove – Tags to remove as a list or as a single string. Can be given as patterns where `` and `?` work as wildcards. persist* – Add/remove specified tags also to new tests added to this suite in the future.

setup¶

Suite setup as a Keyword object.

This attribute is a Keyword object also when a suite has no setup but in that case its truth value is False.

Setup can be modified by setting attributes directly:

suite.setup.name = 'Example'
suite.setup.args = ('First', 'Second')

Alternatively the config() method can be used to set multiple attributes in one call:

suite.setup.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole setup is setting it to None. It will automatically recreate the underlying Keyword object:

suite.setup = None

New in Robot Framework 4.0. Earlier setup was accessed like suite.keywords.setup.

source¶

stat_message¶: String representation of the statistics.

suites¶: Child suites as a TestSuites object.

teardown¶

Suite teardown as a Keyword object.

See setup for more information.

test_count¶: Number of the tests in this suite, recursively.

tests¶: Tests as a TestCases object.

visit(visitor)[source]¶: Visitor interface entry-point.

elapsedtime¶: Total execution time in milliseconds.

remove_keywords(how)[source]¶

Remove keywords based on the given condition.

Parameters:	how – What approach to use when removing keywords. Either `ALL`, `PASSED`, `FOR`, `WUKS`, or `NAME:<pattern>`.

For more information about the possible values see the documentation of the --removekeywords command line option.

filter_messages(log_level='TRACE')[source]¶: Remove log messages below the specified log_level.

configure(**options)[source]¶

A shortcut to configure a suite using one method call.

Can only be used with the root test suite.

Parameters:	options – Passed to `SuiteConfigurer` that will then set suite attributes, call `filter()`, etc. as needed.

Example:

suite.configure(remove_keywords='PASSED',
                doc='Smoke test results.')

Not to be confused with config() method that suites, tests, and keywords have to make it possible to set multiple attributes in one call.

handle_suite_teardown_failures()[source]¶: Internal usage only.

suite_teardown_failed(error)[source]¶: Internal usage only.

suite_teardown_skipped(message)[source]¶: Internal usage only.

robot.result.modeldeprecation module¶

robot.result.modeldeprecation.deprecated(method)[source]¶

class robot.result.modeldeprecation.DeprecatedAttributesMixin[source]¶

Bases: object

name¶: Deprecated.

kwname¶: Deprecated.

libname¶: Deprecated.

args¶: Deprecated.

assign¶: Deprecated.

tags¶: Deprecated.

timeout¶: Deprecated.

message¶: Deprecated.

robot.result.resultbuilder module¶

robot.result.resultbuilder.ExecutionResult(*sources, **options)[source]¶

Factory method to constructs Result objects.

Parameters:

sources – XML source(s) containing execution results. Can be specified as paths, opened file objects, or strings/bytes containing XML directly. Support for bytes is new in RF 3.2.
options – Configuration options. Using merge=True causes multiple results to be combined so that tests in the latter results replace the ones in the original. Setting rpa either to True (RPA mode) or False (test automation) sets execution mode explicitly. By default it is got from processed output files and conflicting modes cause an error. Other options are passed directly to the ExecutionResultBuilder object used internally.

Returns:

Result instance.

Should be imported by external code via the robot.api package. See the robot.result package for a usage example.

class robot.result.resultbuilder.ExecutionResultBuilder(source, include_keywords=True, flattened_keywords=None)[source]¶

Bases: object

Builds Result objects based on output files.

Instead of using this builder directly, it is recommended to use the ExecutionResult() factory method.

Parameters:

source – Path to the XML output file to build Result objects from.
include_keywords – Boolean controlling whether to include keyword information in the result or not. Keywords are not needed when generating only report. Although the the option name has word “keyword”, it controls also including FOR and IF structures.
flatten_keywords – List of patterns controlling what keywords to flatten. See the documentation of --flattenkeywords option for more details.

build(result)[source]¶

class robot.result.resultbuilder.RemoveKeywords[source]¶

Bases: robot.model.visitor.SuiteVisitor

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

robot.result.suiteteardownfailed module¶

class robot.result.suiteteardownfailed.SuiteTeardownFailureHandler[source]¶

Bases: robot.model.visitor.SuiteVisitor

end_suite(suite)[source]¶: Called when suite ends. Default implementation does nothing.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(keyword)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

class robot.result.suiteteardownfailed.SuiteTeardownFailed(message, skipped=False)[source]¶

Bases: robot.model.visitor.SuiteVisitor

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(keyword)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

robot.result.visitor module¶

Visitors can be used to easily traverse result structures.

This module contains ResultVisitor for traversing the whole Result object. It extends SuiteVisitor that contains visiting logic for the test suite structure.

class robot.result.visitor.ResultVisitor[source]¶

Bases: robot.model.visitor.SuiteVisitor

Abstract class to conveniently travel Result objects.

A visitor implementation can be given to the visit() method of a result object. This will cause the result object to be traversed and the visitor’s visit_x(), start_x(), and end_x() methods to be called for each suite, test, keyword and message, as well as for errors, statistics, and other information in the result object. See methods below for a full list of available visitor methods.

See the result package level documentation for more information about handling results and a concrete visitor example. For more information about the visitor algorithm see documentation in robot.model.visitor module.

visit_result(result)[source]¶

start_result(result)[source]¶

end_result(result)[source]¶

visit_statistics(stats)[source]¶

start_statistics(stats)[source]¶

end_statistics(stats)[source]¶

visit_total_statistics(stats)[source]¶

start_total_statistics(stats)[source]¶

end_total_statistics(stats)[source]¶

visit_tag_statistics(stats)[source]¶

start_tag_statistics(stats)[source]¶

end_tag_statistics(stats)[source]¶

visit_suite_statistics(stats)[source]¶

start_suite_statistics(stats)[source]¶

end_suite_statistics(suite_stats)[source]¶

visit_stat(stat)[source]¶

start_stat(stat)[source]¶

end_stat(stat)[source]¶

visit_errors(errors)[source]¶

start_errors(errors)[source]¶

end_errors(errors)[source]¶

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_suite(suite)¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

visit_test(test)¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

robot.result.xmlelementhandlers module¶

class robot.result.xmlelementhandlers.XmlElementHandler(execution_result, root_handler=None)[source]¶

Bases: object

start(elem)[source]¶

end(elem)[source]¶

class robot.result.xmlelementhandlers.ElementHandler[source]¶

Bases: object

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

tag = None¶

children = frozenset([])¶

classmethod register(handler)[source]¶

get_child_handler(tag)[source]¶

start(elem, result)[source]¶

end(elem, result)[source]¶

class robot.result.xmlelementhandlers.RootHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

children = frozenset(['robot'])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

tag = None¶

class robot.result.xmlelementhandlers.RobotHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'robot'¶

children = frozenset(['suite', 'statistics', 'errors'])¶

start(elem, result)[source]¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

class robot.result.xmlelementhandlers.SuiteHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'suite'¶

children = frozenset(['status', 'doc', 'meta', 'kw', 'test', 'suite', 'metadata'])¶

start(elem, result)[source]¶

get_child_handler(tag)[source]¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

classmethod register(handler)¶

class robot.result.xmlelementhandlers.TestHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'test'¶

children = frozenset(['status', 'for', 'tags', 'doc', 'tag', 'kw', 'timeout', 'msg', 'if'])¶

start(elem, result)[source]¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

class robot.result.xmlelementhandlers.KeywordHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'kw'¶

children = frozenset(['status', 'for', 'tags', 'doc', 'msg', 'tag', 'kw', 'arguments', 'timeout', 'arg', 'var', 'assign', 'if'])¶

start(elem, result)[source]¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

class robot.result.xmlelementhandlers.ForHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'for'¶

children = frozenset(['status', 'doc', 'iter', 'msg', 'kw', 'value', 'var'])¶

start(elem, result)[source]¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

class robot.result.xmlelementhandlers.ForIterationHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'iter'¶

children = frozenset(['status', 'for', 'doc', 'msg', 'kw', 'var', 'if'])¶

start(elem, result)[source]¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

class robot.result.xmlelementhandlers.IfHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'if'¶

children = frozenset(['status', 'msg', 'branch', 'doc'])¶

start(elem, result)[source]¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

class robot.result.xmlelementhandlers.IfBranchHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'branch'¶

children = frozenset(['status', 'for', 'doc', 'kw', 'msg', 'if'])¶

start(elem, result)[source]¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

class robot.result.xmlelementhandlers.MessageHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'msg'¶

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.StatusHandler(set_status=True)[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'status'¶

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.DocHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'doc'¶

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.MetadataHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'metadata'¶

children = frozenset(['item'])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.MetadataItemHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'item'¶

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.MetaHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'meta'¶

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.TagsHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'tags'¶

children = frozenset(['tag'])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.TagHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'tag'¶

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.TimeoutHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'timeout'¶

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.AssignHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'assign'¶

children = frozenset(['var'])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.VarHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'var'¶

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.ArgumentsHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'arguments'¶

children = frozenset(['arg'])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.ArgumentHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'arg'¶

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.ValueHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'value'¶

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

class robot.result.xmlelementhandlers.ErrorsHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'errors'¶

start(elem, result)[source]¶

get_child_handler(tag)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

classmethod register(handler)¶

class robot.result.xmlelementhandlers.ErrorMessageHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

end(elem, result)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

get_child_handler(tag)¶

classmethod register(handler)¶

start(elem, result)¶

tag = None¶

class robot.result.xmlelementhandlers.StatisticsHandler[source]¶

Bases: robot.result.xmlelementhandlers.ElementHandler

tag = 'statistics'¶

get_child_handler(tag)[source]¶

children = frozenset([])¶

element_handlers = {'arg': <robot.result.xmlelementhandlers.ArgumentHandler object>, 'arguments': <robot.result.xmlelementhandlers.ArgumentsHandler object>, 'assign': <robot.result.xmlelementhandlers.AssignHandler object>, 'branch': <robot.result.xmlelementhandlers.IfBranchHandler object>, 'doc': <robot.result.xmlelementhandlers.DocHandler object>, 'errors': <robot.result.xmlelementhandlers.ErrorsHandler object>, 'for': <robot.result.xmlelementhandlers.ForHandler object>, 'if': <robot.result.xmlelementhandlers.IfHandler object>, 'item': <robot.result.xmlelementhandlers.MetadataItemHandler object>, 'iter': <robot.result.xmlelementhandlers.ForIterationHandler object>, 'kw': <robot.result.xmlelementhandlers.KeywordHandler object>, 'meta': <robot.result.xmlelementhandlers.MetaHandler object>, 'metadata': <robot.result.xmlelementhandlers.MetadataHandler object>, 'msg': <robot.result.xmlelementhandlers.MessageHandler object>, 'robot': <robot.result.xmlelementhandlers.RobotHandler object>, 'statistics': <robot.result.xmlelementhandlers.StatisticsHandler object>, 'status': <robot.result.xmlelementhandlers.StatusHandler object>, 'suite': <robot.result.xmlelementhandlers.SuiteHandler object>, 'tag': <robot.result.xmlelementhandlers.TagHandler object>, 'tags': <robot.result.xmlelementhandlers.TagsHandler object>, 'test': <robot.result.xmlelementhandlers.TestHandler object>, 'timeout': <robot.result.xmlelementhandlers.TimeoutHandler object>, 'value': <robot.result.xmlelementhandlers.ValueHandler object>, 'var': <robot.result.xmlelementhandlers.VarHandler object>}¶

end(elem, result)¶

classmethod register(handler)¶

start(elem, result)¶

robot.running package¶

Implements the core test execution logic.

The main public entry points of this package are of the following two classes:

TestSuiteBuilder for creating executable test suites based on existing test case files and directories.
TestSuite for creating an executable test suite structure programmatically.

It is recommended to import both of these classes via the robot.api package like in the examples below. Also TestCase and Keyword classes used internally by the TestSuite class are part of the public API. In those rare cases where these classes are needed directly, they can be imported from this package.

Examples¶

First, let’s assume we have the following test suite in file activate_skynet.robot:

*** Settings ***
Library    OperatingSystem

*** Test Cases ***
Should Activate Skynet
    [Tags]    smoke
    [Setup]    Set Environment Variable    SKYNET    activated
    Environment Variable Should Be Set    SKYNET

We can easily parse and create an executable test suite based on the above file using the TestSuiteBuilder class as follows:

from robot.api import TestSuiteBuilder

suite = TestSuiteBuilder().build('path/to/activate_skynet.robot')

That was easy. Let’s next generate the same test suite from scratch using the TestSuite class:

from robot.api import TestSuite

suite = TestSuite('Activate Skynet')
suite.resource.imports.library('OperatingSystem')
test = suite.tests.create('Should Activate Skynet', tags=['smoke'])
test.setup.config('Set Environment Variable', args=['SKYNET', 'activated'])
test.keywords.create('Environment Variable Should Be Set', args=['SKYNET'])

Not that complicated either, especially considering the flexibility. Notice that the suite created based on the file could also be edited further using the same API.

Now that we have a test suite ready, let’s execute it and verify that the returned Result object contains correct information:

result = suite.run(output='skynet.xml')

assert result.return_code == 0
assert result.suite.name == 'Activate Skynet'
test = result.suite.tests[0]
assert test.name == 'Should Activate Skynet'
assert test.passed
stats = result.suite.statistics
assert stats.total == 1 and stats.failed == 0

Running the suite generates a normal output XML file, unless it is disabled by using output=None. Generating log, report, and xUnit files based on the results is possible using the ResultWriter class:

from robot.api import ResultWriter

# Report and xUnit files can be generated based on the result object.
ResultWriter(result).write_results(report='skynet.html', log=None)
# Generating log files requires processing the earlier generated output XML.
ResultWriter('skynet.xml').write_results()

Subpackages¶

robot.running.arguments package¶

Submodules¶

robot.running.arguments.argumentconverter module¶

class robot.running.arguments.argumentconverter.ArgumentConverter(argspec, dry_run=False)[source]¶

Bases: object

convert(positional, named)[source]¶

robot.running.arguments.argumentmapper module¶

class robot.running.arguments.argumentmapper.ArgumentMapper(argspec)[source]¶

Bases: object

map(positional, named, replace_defaults=True)[source]¶

class robot.running.arguments.argumentmapper.KeywordCallTemplate(argspec)[source]¶

Bases: object

fill_positional(positional)[source]¶

fill_named(named)[source]¶

replace_defaults()[source]¶

class robot.running.arguments.argumentmapper.DefaultValue(value)[source]¶

Bases: object

resolve(variables)[source]¶

robot.running.arguments.argumentparser module¶

class robot.running.arguments.argumentparser.JavaArgumentParser(type='Keyword')[source]¶

Bases: robot.running.arguments.argumentparser._ArgumentParser

parse(signatures, name=None)[source]¶

class robot.running.arguments.argumentparser.DynamicArgumentParser(type='Keyword', error_reporter=None)[source]¶

Bases: robot.running.arguments.argumentparser._ArgumentSpecParser

parse(argspec, name=None)¶

class robot.running.arguments.argumentparser.UserKeywordArgumentParser(type='Keyword', error_reporter=None)[source]¶

Bases: robot.running.arguments.argumentparser._ArgumentSpecParser

parse(argspec, name=None)¶

robot.running.arguments.argumentresolver module¶

class robot.running.arguments.argumentresolver.ArgumentResolver(argspec, resolve_named=True, resolve_variables_until=None, dict_to_kwargs=False)[source]¶

Bases: object

resolve(arguments, variables=None)[source]¶

class robot.running.arguments.argumentresolver.NamedArgumentResolver(argspec)[source]¶

Bases: object

resolve(arguments, variables=None)[source]¶

class robot.running.arguments.argumentresolver.NullNamedArgumentResolver[source]¶

Bases: object

resolve(arguments, variables=None)[source]¶

class robot.running.arguments.argumentresolver.DictToKwargs(argspec, enabled=False)[source]¶

Bases: object

handle(positional, named)[source]¶

class robot.running.arguments.argumentresolver.VariableReplacer(resolve_until=None)[source]¶

Bases: object

replace(positional, named, variables=None)[source]¶

robot.running.arguments.argumentspec module¶

class robot.running.arguments.argumentspec.Enum[source]¶: Bases: object

class robot.running.arguments.argumentspec.ArgumentSpec(name=None, type='Keyword', positional_only=None, positional_or_named=None, var_positional=None, named_only=None, var_named=None, defaults=None, types=None)[source]¶

Bases: object

types¶

positional¶

minargs¶

maxargs¶

argument_names¶

resolve(arguments, variables=None, resolve_named=True, resolve_variables_until=None, dict_to_kwargs=False)[source]¶

map(positional, named, replace_defaults=True)[source]¶

class robot.running.arguments.argumentspec.ArgInfo(kind, name='', types=<object object>, default=<object object>)[source]¶

Bases: object

NOTSET = <object object>¶

POSITIONAL_ONLY = 'POSITIONAL_ONLY'¶

POSITIONAL_ONLY_MARKER = 'POSITIONAL_ONLY_MARKER'¶

POSITIONAL_OR_NAMED = 'POSITIONAL_OR_NAMED'¶

VAR_POSITIONAL = 'VAR_POSITIONAL'¶

NAMED_ONLY_MARKER = 'NAMED_ONLY_MARKER'¶

NAMED_ONLY = 'NAMED_ONLY'¶

VAR_NAMED = 'VAR_NAMED'¶

types¶

required¶

types_reprs¶

default_repr¶

robot.running.arguments.argumentvalidator module¶

class robot.running.arguments.argumentvalidator.ArgumentValidator(argspec)[source]¶

Bases: object

validate(positional, named, dryrun=False)[source]¶

robot.running.arguments.embedded module¶

class robot.running.arguments.embedded.EmbeddedArguments(name)[source]¶: Bases: object

class robot.running.arguments.embedded.EmbeddedArgumentParser[source]¶

Bases: object

parse(string)[source]¶

robot.running.arguments.javaargumentcoercer module¶

robot.running.arguments.py2argumentparser module¶

class robot.running.arguments.py2argumentparser.PythonArgumentParser(type='Keyword')[source]¶

Bases: object

parse(handler, name=None)[source]¶

robot.running.arguments.py3argumentparser module¶

robot.running.arguments.typeconverters module¶

class robot.running.arguments.typeconverters.Enum[source]¶: Bases: object

class robot.running.arguments.typeconverters.TypeConverter(used_type)[source]¶

Bases: object

type = None¶

type_name = None¶

abc = None¶

aliases = ()¶

value_types = (<type 'unicode'>,)¶

classmethod register(converter)[source]¶

classmethod converter_for(type_)[source]¶

classmethod handles(type_)[source]¶

convert(name, value, explicit_type=True, strict=True)[source]¶

no_conversion_needed(value)[source]¶

class robot.running.arguments.typeconverters.EnumConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of Enum

type_name¶

value_types¶

abc = None¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.StringConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.unicode

type_name = 'string'¶

aliases = ('string', 'str', 'unicode')¶

abc = None¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

value_types = (<type 'unicode'>,)¶

class robot.running.arguments.typeconverters.BooleanConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

value_types = (<type 'unicode'>, <type 'int'>, <type 'float'>, <type 'NoneType'>)¶

type¶: alias of __builtin__.bool

type_name = 'boolean'¶

aliases = ('bool',)¶

abc = None¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.IntegerConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.int

abc¶: alias of numbers.Integral

type_name = 'integer'¶

aliases = ('int', 'long')¶

value_types = (<type 'unicode'>, <type 'float'>)¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.FloatConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.float

abc¶: alias of numbers.Real

type_name = 'float'¶

aliases = ('double',)¶

value_types = (<type 'unicode'>, <class 'numbers.Real'>)¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.DecimalConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of decimal.Decimal

type_name = 'decimal'¶

value_types = (<type 'unicode'>, <type 'int'>, <type 'float'>)¶

abc = None¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.BytesConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.str

abc = None¶

type_name = 'bytes'¶

value_types = (<type 'unicode'>, <type 'bytearray'>)¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.ByteArrayConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.bytearray

type_name = 'bytearray'¶

value_types = (<type 'unicode'>, <type 'str'>)¶

abc = None¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.DateTimeConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of datetime.datetime

type_name = 'datetime'¶

value_types = (<type 'unicode'>, <type 'int'>, <type 'float'>)¶

abc = None¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.DateConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of datetime.date

type_name = 'date'¶

abc = None¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

value_types = (<type 'unicode'>,)¶

class robot.running.arguments.typeconverters.TimeDeltaConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of datetime.timedelta

type_name = 'timedelta'¶

value_types = (<type 'unicode'>, <type 'int'>, <type 'float'>)¶

abc = None¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.NoneConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.NoneType

type_name = 'None'¶

classmethod handles(type_)[source]¶

abc = None¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

value_types = (<type 'unicode'>,)¶

class robot.running.arguments.typeconverters.ListConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.list

type_name = 'list'¶

abc¶: alias of _abcoll.Sequence

value_types = (<type 'unicode'>, <type 'tuple'>)¶

no_conversion_needed(value)[source]¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.TupleConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.tuple

type_name = 'tuple'¶

value_types = (<type 'unicode'>, <type 'list'>)¶

abc = None¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.DictionaryConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.dict

abc¶: alias of _abcoll.Mapping

type_name = 'dictionary'¶

aliases = ('dict', 'map')¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

value_types = (<type 'unicode'>,)¶

class robot.running.arguments.typeconverters.SetConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.set

type_name = 'set'¶

value_types = (<type 'unicode'>, <type 'frozenset'>, <type 'list'>, <type 'tuple'>, <class '_abcoll.Mapping'>)¶

abc¶: alias of _abcoll.Set

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.FrozenSetConverter(used_type)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type¶: alias of __builtin__.frozenset

type_name = 'frozenset'¶

value_types = (<type 'unicode'>, <type 'set'>, <type 'list'>, <type 'tuple'>, <class '_abcoll.Mapping'>)¶

abc = None¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod handles(type_)¶

no_conversion_needed(value)¶

classmethod register(converter)¶

class robot.running.arguments.typeconverters.CombinedConverter(union)[source]¶

Bases: robot.running.arguments.typeconverters.TypeConverter

type = typing.Union¶

type_name¶

classmethod handles(type_)[source]¶

no_conversion_needed(value)[source]¶

abc = None¶

aliases = ()¶

convert(name, value, explicit_type=True, strict=True)¶

classmethod converter_for(type_)¶

classmethod register(converter)¶

value_types = (<type 'unicode'>,)¶

robot.running.arguments.typevalidator module¶

class robot.running.arguments.typevalidator.TypeValidator(argspec)[source]¶

Bases: object

validate(types)[source]¶

validate_type_dict(types)[source]¶

convert_type_list_to_dict(types)[source]¶

robot.running.builder package¶

Submodules¶

robot.running.builder.builders module¶

class robot.running.builder.builders.TestSuiteBuilder(included_suites=None, included_extensions=('robot', ), rpa=None, allow_empty_suite=False, process_curdir=True)[source]¶

Bases: object

Builder to construct TestSuite objects based on data on the disk.

The build() method constructs executable TestSuite objects based on test data files or directories. There are two main use cases for this API:

Execute the created suite by using its run() method. The suite can be can be modified before execution if needed.
Inspect the suite to see, for example, what tests it has or what tags tests have. This can be more convenient than using the lower level parsing APIs but does not allow saving modified data back to the disk.

Both modifying the suite and inspecting what data it contains are easiest done by using the visitor interface.

This class is part of the public API and should be imported via the robot.api package.

Parameters:

include_suites – List of suite names to include. If None or an empty list, all suites are included. Same as using --suite on the command line.
included_extensions – List of extensions of files to parse. Same as --extension. This parameter was named extension before RF 3.2.
rpa – Explicit test execution mode. True for RPA and False for test automation. By default mode is got from test data headers and possible conflicting headers cause an error. Same as --rpa or --norpa.
allow_empty_suite – Specify is it an error if the built suite contains no tests. Same as --runemptysuite. New in RF 3.2.
process_curdir – Control processing the special ${CURDIR} variable. It is resolved already at parsing time by default, but that can be changed by giving this argument False value. New in RF 3.2.

build(*paths)[source]¶

Parameters:	paths – Paths to test data files or directories.
Returns:	`TestSuite` instance.

class robot.running.builder.builders.SuiteStructureParser(included_extensions, rpa=None, process_curdir=True)[source]¶

Bases: robot.parsing.suitestructure.SuiteStructureVisitor

parse(structure)[source]¶

visit_file(structure)[source]¶

start_directory(structure)[source]¶

end_directory(structure)[source]¶

visit_directory(structure)¶

class robot.running.builder.builders.ResourceFileBuilder(process_curdir=True)[source]¶

Bases: object

build(source)[source]¶

robot.running.builder.parsers module¶

class robot.running.builder.parsers.BaseParser[source]¶

Bases: object

parse_init_file(source, defaults=None)[source]¶

parse_suite_file(source, defaults=None)[source]¶

parse_resource_file(source)[source]¶

class robot.running.builder.parsers.RobotParser(process_curdir=True)[source]¶

Bases: robot.running.builder.parsers.BaseParser

parse_init_file(source, defaults=None)[source]¶

parse_suite_file(source, defaults=None)[source]¶

build_suite(model, name=None, defaults=None)[source]¶

parse_resource_file(source)[source]¶

class robot.running.builder.parsers.RestParser(process_curdir=True)[source]¶

Bases: robot.running.builder.parsers.RobotParser

build_suite(model, name=None, defaults=None)¶

parse_init_file(source, defaults=None)¶

parse_resource_file(source)¶

parse_suite_file(source, defaults=None)¶

class robot.running.builder.parsers.NoInitFileDirectoryParser[source]¶

Bases: robot.running.builder.parsers.BaseParser

parse_init_file(source, defaults=None)[source]¶

parse_resource_file(source)¶

parse_suite_file(source, defaults=None)¶

robot.running.builder.parsers.format_name(source)[source]¶

class robot.running.builder.parsers.ErrorReporter(source)[source]¶

Bases: ast.NodeVisitor

visit_Error(node)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

robot.running.builder.testsettings module¶

class robot.running.builder.testsettings.TestDefaults(parent=None)[source]¶

Bases: object

setup¶

teardown¶

force_tags¶

timeout¶

class robot.running.builder.testsettings.TestSettings(defaults)[source]¶

Bases: object

setup¶

teardown¶

timeout¶

template¶

tags¶

robot.running.builder.transformers module¶

class robot.running.builder.transformers.SettingsBuilder(suite, test_defaults)[source]¶

Bases: ast.NodeVisitor

visit_Documentation(node)[source]¶

visit_Metadata(node)[source]¶

visit_SuiteSetup(node)[source]¶

visit_SuiteTeardown(node)[source]¶

visit_TestSetup(node)[source]¶

visit_TestTeardown(node)[source]¶

visit_TestTimeout(node)[source]¶

visit_DefaultTags(node)[source]¶

visit_ForceTags(node)[source]¶

visit_TestTemplate(node)[source]¶

visit_ResourceImport(node)[source]¶

visit_LibraryImport(node)[source]¶

visit_VariablesImport(node)[source]¶

visit_VariableSection(node)[source]¶

visit_TestCaseSection(node)[source]¶

visit_KeywordSection(node)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.running.builder.transformers.SuiteBuilder(suite, test_defaults)[source]¶

Bases: ast.NodeVisitor

visit_SettingSection(node)[source]¶

visit_Variable(node)[source]¶

visit_TestCase(node)[source]¶

visit_Keyword(node)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.running.builder.transformers.ResourceBuilder(resource)[source]¶

Bases: ast.NodeVisitor

visit_Documentation(node)[source]¶

visit_LibraryImport(node)[source]¶

visit_ResourceImport(node)[source]¶

visit_VariablesImport(node)[source]¶

visit_Variable(node)[source]¶

visit_Keyword(node)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.running.builder.transformers.TestCaseBuilder(suite, defaults)[source]¶

Bases: ast.NodeVisitor

visit_TestCase(node)[source]¶

visit_For(node)[source]¶

visit_If(node)[source]¶

visit_TemplateArguments(node)[source]¶

visit_Documentation(node)[source]¶

visit_Setup(node)[source]¶

visit_Teardown(node)[source]¶

visit_Timeout(node)[source]¶

visit_Tags(node)[source]¶

visit_Template(node)[source]¶

visit_KeywordCall(node)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.running.builder.transformers.KeywordBuilder(resource)[source]¶

Bases: ast.NodeVisitor

visit_Keyword(node)[source]¶

visit_Documentation(node)[source]¶

visit_Arguments(node)[source]¶

visit_Tags(node)[source]¶

visit_Return(node)[source]¶

visit_Timeout(node)[source]¶

visit_Teardown(node)[source]¶

visit_KeywordCall(node)[source]¶

visit_For(node)[source]¶

visit_If(node)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.running.builder.transformers.ForBuilder(parent)[source]¶

Bases: ast.NodeVisitor

build(node)[source]¶

visit_KeywordCall(node)[source]¶

visit_TemplateArguments(node)[source]¶

visit_For(node)[source]¶

visit_If(node)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.running.builder.transformers.IfBuilder(parent)[source]¶

Bases: ast.NodeVisitor

build(node)[source]¶

visit_KeywordCall(node)[source]¶

visit_TemplateArguments(node)[source]¶

visit_If(node)[source]¶

visit_For(node)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

robot.running.builder.transformers.format_error(errors)[source]¶

robot.running.timeouts package¶

class robot.running.timeouts.TestTimeout(timeout=None, variables=None, rpa=False)[source]¶

Bases: robot.running.timeouts._Timeout

type = 'Test'¶

set_keyword_timeout(timeout_occurred)[source]¶

any_timeout_occurred()[source]¶

active¶

get_message()¶

replace_variables(variables)¶

run(runnable, args=None, kwargs=None)¶

start()¶

time_left()¶

timed_out()¶

class robot.running.timeouts.KeywordTimeout(timeout=None, variables=None)[source]¶

Bases: robot.running.timeouts._Timeout

active¶

get_message()¶

replace_variables(variables)¶

run(runnable, args=None, kwargs=None)¶

start()¶

time_left()¶

timed_out()¶

type = 'Keyword'¶

Submodules¶

robot.running.timeouts.ironpython module¶

robot.running.timeouts.jython module¶

robot.running.timeouts.posix module¶

class robot.running.timeouts.posix.Timeout(timeout, error)[source]¶

Bases: object

execute(runnable)[source]¶

robot.running.timeouts.windows module¶

class robot.running.timeouts.windows.Timeout(timeout, error)[source]¶

Bases: object

execute(runnable)[source]¶

Submodules¶

robot.running.bodyrunner module¶

class robot.running.bodyrunner.BodyRunner(context, run=True, templated=False)[source]¶

Bases: object

run(body)[source]¶

class robot.running.bodyrunner.KeywordRunner(context, run=True)[source]¶

Bases: object

run(step, name=None)[source]¶

class robot.running.bodyrunner.IfRunner(context, run=True, templated=False)[source]¶

Bases: object

run(data)[source]¶

robot.running.bodyrunner.ForRunner(context, flavor='IN', run=True, templated=False)[source]¶

class robot.running.bodyrunner.ForInRunner(context, run=True, templated=False)[source]¶

Bases: object

flavor = 'IN'¶

run(data)[source]¶

class robot.running.bodyrunner.ForInRangeRunner(context, run=True, templated=False)[source]¶

Bases: robot.running.bodyrunner.ForInRunner

flavor = 'IN RANGE'¶

run(data)¶

class robot.running.bodyrunner.ForInZipRunner(context, run=True, templated=False)[source]¶

Bases: robot.running.bodyrunner.ForInRunner

flavor = 'IN ZIP'¶

run(data)¶

class robot.running.bodyrunner.ForInEnumerateRunner(context, run=True, templated=False)[source]¶

Bases: robot.running.bodyrunner.ForInRunner

flavor = 'IN ENUMERATE'¶

run(data)¶

robot.running.context module¶

class robot.running.context.ExecutionContexts[source]¶

Bases: object

current¶

top¶

namespaces¶

start_suite(suite, namespace, output, dry_run=False)[source]¶

end_suite()[source]¶

robot.running.dynamicmethods module¶

robot.running.dynamicmethods.no_dynamic_method(*args)[source]¶

class robot.running.dynamicmethods.GetKeywordNames(lib)[source]¶

Bases: robot.running.dynamicmethods._DynamicMethod

name¶

class robot.running.dynamicmethods.RunKeyword(lib)[source]¶

Bases: robot.running.dynamicmethods._DynamicMethod

supports_kwargs¶

name¶

class robot.running.dynamicmethods.GetKeywordDocumentation(lib)[source]¶

Bases: robot.running.dynamicmethods._DynamicMethod

name¶

class robot.running.dynamicmethods.GetKeywordArguments(lib)[source]¶

Bases: robot.running.dynamicmethods._DynamicMethod

name¶

class robot.running.dynamicmethods.GetKeywordTypes(lib)[source]¶

Bases: robot.running.dynamicmethods._DynamicMethod

name¶

class robot.running.dynamicmethods.GetKeywordTags(lib)[source]¶

Bases: robot.running.dynamicmethods._DynamicMethod

name¶

class robot.running.dynamicmethods.GetKeywordSource(lib)[source]¶

Bases: robot.running.dynamicmethods._DynamicMethod

name¶

robot.running.handlers module¶

robot.running.handlers.Handler(library, name, method)[source]¶

robot.running.handlers.DynamicHandler(library, name, method, doc, argspec, tags=None)[source]¶

robot.running.handlers.InitHandler(library, method=None, docgetter=None)[source]¶

class robot.running.handlers.EmbeddedArgumentsHandler(name_regexp, orig_handler)[source]¶

Bases: object

library¶

matches(name)[source]¶

create_runner(name)[source]¶

robot.running.handlerstore module¶

class robot.running.handlerstore.HandlerStore(source, source_type)[source]¶

Bases: object

TEST_LIBRARY_TYPE = 'Test library'¶

TEST_CASE_FILE_TYPE = 'Test case file'¶

RESOURCE_FILE_TYPE = 'Resource file'¶

add(handler, embedded=False)[source]¶

create_runner(name)[source]¶

robot.running.importer module¶

class robot.running.importer.Importer[source]¶

Bases: object

reset()[source]¶

close_global_library_listeners()[source]¶

import_library(name, args, alias, variables)[source]¶

import_resource(path)[source]¶

class robot.running.importer.ImportCache[source]¶

Bases: object

Keeps track on and optionally caches imported items.

Handles paths in keys case-insensitively on case-insensitive OSes. Unlike dicts, this storage accepts mutable values in keys.

add(key, item=None)[source]¶

values()[source]¶

robot.running.librarykeywordrunner module¶

class robot.running.librarykeywordrunner.LibraryKeywordRunner(handler, name=None)[source]¶

Bases: object

library¶

libname¶

longname¶

run(kw, context, run=True)[source]¶

dry_run(kw, context)[source]¶

class robot.running.librarykeywordrunner.EmbeddedArgumentsRunner(handler, name)[source]¶

Bases: robot.running.librarykeywordrunner.LibraryKeywordRunner

dry_run(kw, context)¶

libname¶

library¶

longname¶

run(kw, context, run=True)¶

class robot.running.librarykeywordrunner.RunKeywordRunner(handler, default_dry_run_keywords=False)[source]¶

Bases: robot.running.librarykeywordrunner.LibraryKeywordRunner

dry_run(kw, context)¶

libname¶

library¶

longname¶

run(kw, context, run=True)¶

robot.running.libraryscopes module¶

robot.running.libraryscopes.LibraryScope(libcode, library)[source]¶

class robot.running.libraryscopes.GlobalScope(library)[source]¶

Bases: object

is_global = True¶

start_suite()[source]¶

end_suite()[source]¶

start_test()[source]¶

end_test()[source]¶

class robot.running.libraryscopes.TestSuiteScope(library)[source]¶

Bases: robot.running.libraryscopes.GlobalScope

is_global = False¶

start_suite()[source]¶

end_suite()[source]¶

end_test()¶

start_test()¶

class robot.running.libraryscopes.TestCaseScope(library)[source]¶

Bases: robot.running.libraryscopes.TestSuiteScope

start_test()[source]¶

end_test()[source]¶

end_suite()¶

is_global = False¶

start_suite()¶

robot.running.model module¶

Module implementing test execution related model objects.

When tests are executed normally, these objects are created based on the test data on the file system by TestSuiteBuilder, but external tools can also create an executable test suite model structure directly. Regardless the approach to create it, the model is executed by calling run() method of the root test suite. See the robot.running package level documentation for more information and examples.

The most important classes defined in this module are TestSuite, TestCase and Keyword. When tests are executed, these objects can be inspected and modified by pre-run modifiers and listeners. The aforementioned objects are considered stable, but other objects in this module may still be changed in the future major releases.

class robot.running.model.Body(parent=None, items=None)[source]¶

Bases: robot.model.body.Body

append(item)¶

clear()¶

count(item)¶

create¶

create_for(*args, **kwargs)[source]¶

create_if(*args, **kwargs)[source]¶

create_keyword(*args, **kwargs)[source]¶

extend(items)¶

filter(keywords=None, fors=None, ifs=None, predicate=None)[source]¶

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 FOR and IF constructs use body.filter(fors=False, ifs=False). Including and excluding by types at the same time is not supported.

Custom predicate is a calleble 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.

for_class¶: alias of For

if_class¶: alias of If

index(item, *start_and_end)¶

insert(index, item)¶

keyword_class¶: alias of Keyword

pop(*index)¶

classmethod register(item_class)[source]¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

class robot.running.model.IfBranches(parent=None, items=None)[source]¶

Bases: robot.model.body.IfBranches

append(item)¶

clear()¶

count(item)¶

create¶

create_branch(*args, **kwargs)[source]¶

create_for(*args, **kwargs)¶

create_if(*args, **kwargs)¶

create_keyword(*args, **kwargs)¶

extend(items)¶

filter(keywords=None, fors=None, ifs=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 FOR and IF constructs use body.filter(fors=False, ifs=False). Including and excluding by types at the same time is not supported.

Custom predicate is a calleble 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.

for_class = None¶

if_branch_class¶: alias of IfBranch

if_class = None¶

index(item, *start_and_end)¶

insert(index, item)¶

keyword_class = None¶

pop(*index)¶

classmethod register(item_class)¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

class robot.running.model.Keyword(name='', doc='', args=(), assign=(), tags=(), timeout=None, type='KEYWORD', parent=None, lineno=None)[source]¶

Bases: robot.model.keyword.Keyword

Represents a single executable keyword.

These keywords never have child keywords or messages. The actual keyword that is executed depends on the context where this model is executed.

See the base class for documentation of attributes not documented here.

lineno¶

source¶

run(context, run=True, templated=None)[source]¶

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

args¶

assign¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

doc¶

has_teardown¶

Check does a keyword have a teardown without creating a teardown object.

A difference between using if kw.has_teardown: and if kw.teardown: is that accessing the teardown attribute creates a Keyword object representing a teardown even when the keyword actually does not have one. This typically does not matter, but with bigger suite structures having lot of keywords it can have a considerable effect on memory usage.

New in Robot Framework 4.1.2.

id¶

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

name¶

parent¶

repr_args = ('name', 'args', 'assign')¶

tags¶: Keyword tags as a Tags object.

teardown¶

Keyword teardown as a Keyword object.

Teardown can be modified by setting attributes directly:

keyword.teardown.name = 'Example'
keyword.teardown.args = ('First', 'Second')

Alternatively the config() method can be used to set multiple attributes in one call:

keyword.teardown.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole teardown is setting it to None. It will automatically recreate the underlying Keyword object:

keyword.teardown = None

This attribute is a Keyword object also when a keyword has no teardown but in that case its truth value is False. If there is a need to just check does a keyword have a teardown, using the has_teardown attribute avoids creating the Keyword object and is thus more memory efficient.

New in Robot Framework 4.0. Earlier teardown was accessed like keyword.keywords.teardown. has_teardown is new in Robot Framework 4.1.2.

timeout¶

type¶

visit(visitor)[source]¶: Visitor interface entry-point.

class robot.running.model.For(variables, flavor, values, parent=None, lineno=None, error=None)[source]¶

Bases: robot.model.control.For

body_class¶: alias of Body

lineno¶

error¶

source¶

run(context, run=True, templated=False)[source]¶

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

body¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

flavor¶

id¶

Item id in format like s1-t3-k1.

See TestSuite.id for more information.

keywords¶: Deprecated since Robot Framework 4.0. Use body instead.

parent¶

repr_args = ('variables', 'flavor', 'values')¶

type = 'FOR'¶

values¶

variables¶

visit(visitor)[source]¶

class robot.running.model.If(parent=None, lineno=None, error=None)[source]¶

Bases: robot.model.control.If

body_class¶: alias of IfBranches

lineno¶

error¶

source¶

run(context, run=True, templated=False)[source]¶

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

body¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

id¶: Root IF/ELSE id is always None.

parent¶

repr_args = ()¶

type = 'IF/ELSE ROOT'¶

visit(visitor)[source]¶

class robot.running.model.IfBranch(type='IF', condition=None, parent=None, lineno=None)[source]¶

Bases: robot.model.control.IfBranch

body_class¶: alias of Body

lineno¶

source¶

ELSE = 'ELSE'¶

ELSE_IF = 'ELSE IF'¶

FOR = 'FOR'¶

FOR_ITERATION = 'FOR ITERATION'¶

IF = 'IF'¶

IF_ELSE_ROOT = 'IF/ELSE ROOT'¶

KEYWORD = 'KEYWORD'¶

MESSAGE = 'MESSAGE'¶

SETUP = 'SETUP'¶

TEARDOWN = 'TEARDOWN'¶

body¶

condition¶

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

id¶: Branch id omits the root IF/ELSE object from the parent id part.

parent¶

repr_args = ('type', 'condition')¶

type¶

visit(visitor)[source]¶

class robot.running.model.TestCase(name='', doc='', tags=None, timeout=None, template=None, lineno=None)[source]¶

Bases: robot.model.testcase.TestCase

Represents a single executable test case.

See the base class for documentation of attributes not documented here.

body_class¶

Internal usage only.

alias of Body

fixture_class¶

Internal usage only.

alias of Keyword

template¶

lineno¶

source¶

body¶: Test case body as a Body object.

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

doc¶

id¶

Test case id in format like s1-t3.

See TestSuite.id for more information.

keywords¶

Deprecated since Robot Framework 4.0

Use body, setup or teardown instead.

longname¶: Test name prefixed with the long name of the parent suite.

name¶

parent¶

repr_args = ('name',)¶

setup¶

Test setup as a Keyword object.

This attribute is a Keyword object also when a test has no setup but in that case its truth value is False.

Setup can be modified by setting attributes directly:

test.setup.name = 'Example'
test.setup.args = ('First', 'Second')

Alternatively the config() method can be used to set multiple attributes in one call:

test.setup.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole setup is setting it to None. It will automatically recreate the underlying Keyword object:

test.setup = None

New in Robot Framework 4.0. Earlier setup was accessed like test.keywords.setup.

tags¶: Test tags as a Tags object.

teardown¶

Test teardown as a Keyword object.

See setup for more information.

timeout¶

visit(visitor)[source]¶: Visitor interface entry-point.

class robot.running.model.TestSuite(name='', doc='', metadata=None, source=None, rpa=None)[source]¶

Bases: robot.model.testsuite.TestSuite

Represents a single executable test suite.

See the base class for documentation of attributes not documented here.

test_class¶

Internal usage only.

alias of TestCase

fixture_class¶

Internal usage only.

alias of Keyword

resource¶: ResourceFile instance containing imports, variables and keywords the suite owns. When data is parsed from the file system, this data comes from the same test case file that creates the suite.

classmethod from_file_system(*paths, **config)[source]¶

Create a TestSuite object based on the given paths.

paths are file or directory paths where to read the data from.

Internally utilizes the TestSuiteBuilder class and config can be used to configure how it is initialized.

New in Robot Framework 3.2.

classmethod from_model(model, name=None)[source]¶

Create a TestSuite object based on the given model.

The model can be created by using the get_model() function and possibly modified by other tooling in the robot.parsing module.

New in Robot Framework 3.2.

configure(randomize_suites=False, randomize_tests=False, randomize_seed=None, **options)[source]¶

A shortcut to configure a suite using one method call.

Can only be used with the root test suite.

Parameters:	randomize_xxx – Passed to `randomize()`. options – Passed to `SuiteConfigurer` that will then set suite attributes, call `filter()`, etc. as needed.

Example:

suite.configure(included_tags=['smoke'],
                doc='Smoke test results.')

Not to be confused with config() method that suites, tests, and keywords have to make it possible to set multiple attributes in one call.

randomize(suites=True, tests=True, seed=None)[source]¶

Randomizes the order of suites and/or tests, recursively.

Parameters:	suites – Boolean controlling should suites be randomized. tests – Boolean controlling should tests be randomized. seed – Random seed. Can be given if previous random order needs to be re-created. Seed value is always shown in logs and reports.

run(settings=None, **options)[source]¶

Executes the suite based based the given settings or options.

Parameters:	settings – `RobotSettings` object to configure test execution. options – Used to construct new `RobotSettings` object if `settings` are not given.
Returns:	`Result` object with information about executed suites and tests.

If options are used, their names are the same as long command line options except without hyphens. Some options are ignored (see below), but otherwise they have the same semantics as on the command line. Options that can be given on the command line multiple times can be passed as lists like variable=['VAR1:value1', 'VAR2:value2']. If such an option is used only once, it can be given also as a single string like variable='VAR:value'.

Additionally listener option allows passing object directly instead of listener name, e.g. run('tests.robot', listener=Listener()).

To capture stdout and/or stderr streams, pass open file objects in as special keyword arguments stdout and stderr, respectively.

Only options related to the actual test execution have an effect. For example, options related to selecting or modifying test cases or suites (e.g. --include, --name, --prerunmodifier) or creating logs and reports are silently ignored. The output XML generated as part of the execution can be configured, though. This includes disabling it with output=None.

Example:

stdout = StringIO()
result = suite.run(variable='EXAMPLE:value',
                   output='example.xml',
                   exitonfailure=True,
                   stdout=stdout)
print(result.return_code)

To save memory, the returned Result object does not have any information about the executed keywords. If that information is needed, the created output XML file needs to be read using the ExecutionResult factory method.

See the package level documentation for more examples, including how to construct executable test suites and how to create logs and reports based on the execution results.

See the robot.run function for a higher-level API for executing tests in files or directories.

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.

copy(**attributes)¶

Return shallow copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.copy(name='New name')`.

See also deepcopy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

deepcopy(**attributes)¶

Return deep copy of this object.

Parameters:	attributes – Attributes to be set for the returned copy automatically. For example, `test.deepcopy(name='New name')`.

See also copy(). The difference between these two is the same as with the standard copy.copy and copy.deepcopy functions that these methods also use internally.

doc¶

filter(included_suites=None, included_tests=None, included_tags=None, excluded_tags=None)[source]¶

Select test cases and remove others from this suite.

Parameters have the same semantics as --suite, --test, --include, and --exclude command line options. All of them can be given as a list of strings, or when selecting only one, as a single string.

Child suites that contain no tests after filtering are automatically removed.

Example:

suite.filter(included_tests=['Test 1', '* Example'],
             included_tags='priority-1')

has_tests¶

id¶

An automatically generated unique id.

The root suite has id s1, its child suites have ids s1-s1, s1-s2, …, their child suites get ids s1-s1-s1, s1-s1-s2, …, s1-s2-s1, …, and so on.

The first test in a suite has an id like s1-t1, the second has an id s1-t2, and so on. Similarly keywords in suites (setup/teardown) and in tests get ids like s1-k1, s1-t1-k1, and s1-s4-t2-k5.

keywords¶

Deprecated since Robot Framework 4.0

Use setup or teardown instead.

longname¶: Suite name prefixed with the long name of the parent suite.

metadata¶: Free test suite metadata as a dictionary.

name¶: Test suite name. If not set, constructed from child suite names.

parent¶

remove_empty_suites(preserve_direct_children=False)[source]¶: Removes all child suites not containing any tests, recursively.

repr_args = ('name',)¶

rpa¶

set_tags(add=None, remove=None, persist=False)[source]¶

Add and/or remove specified tags to the tests in this suite.

Parameters:	add – Tags to add as a list or, if adding only one, as a single string. remove – Tags to remove as a list or as a single string. Can be given as patterns where `` and `?` work as wildcards. persist* – Add/remove specified tags also to new tests added to this suite in the future.

setup¶

Suite setup as a Keyword object.

This attribute is a Keyword object also when a suite has no setup but in that case its truth value is False.

Setup can be modified by setting attributes directly:

suite.setup.name = 'Example'
suite.setup.args = ('First', 'Second')

Alternatively the config() method can be used to set multiple attributes in one call:

suite.setup.config(name='Example', args=('First', 'Second'))

The easiest way to reset the whole setup is setting it to None. It will automatically recreate the underlying Keyword object:

suite.setup = None

New in Robot Framework 4.0. Earlier setup was accessed like suite.keywords.setup.

source¶

suites¶: Child suites as a TestSuites object.

teardown¶

Suite teardown as a Keyword object.

See setup for more information.

test_count¶: Number of the tests in this suite, recursively.

tests¶: Tests as a TestCases object.

visit(visitor)[source]¶: Visitor interface entry-point.

class robot.running.model.Variable(name, value, source=None, lineno=None, error=None)[source]¶

Bases: object

report_invalid_syntax(message, level='ERROR')[source]¶

class robot.running.model.ResourceFile(doc='', source=None)[source]¶

Bases: object

imports¶

keywords¶

variables¶

class robot.running.model.UserKeyword(name, args=(), doc='', tags=(), return_=None, timeout=None, lineno=None, parent=None, error=None)[source]¶

Bases: object

body¶: Child keywords as a Body object.

keywords¶

Deprecated since Robot Framework 4.0.

Use body or teardown instead.

teardown¶

tags¶

source¶

class robot.running.model.Import(type, name, args=(), alias=None, source=None, lineno=None)[source]¶

Bases: object

ALLOWED_TYPES = ('Library', 'Resource', 'Variables')¶

directory¶

report_invalid_syntax(message, level='ERROR')[source]¶

class robot.running.model.Imports(source, imports=None)[source]¶

Bases: robot.model.itemlist.ItemList

append(item)¶

clear()¶

count(item)¶

create(*args, **kwargs)¶

extend(items)¶

index(item, *start_and_end)¶

insert(index, item)¶

pop(*index)¶

remove(item)¶

reverse()¶

sort()¶

visit(visitor)¶

library(name, args=(), alias=None, lineno=None)[source]¶

resource(path, lineno=None)[source]¶

variables(path, args=(), lineno=None)[source]¶

robot.running.modelcombiner module¶

class robot.running.modelcombiner.ModelCombiner(data, result, **priority)[source]¶

Bases: object

data¶

result¶

priority¶

robot.running.namespace module¶

class robot.running.namespace.Namespace(variables, suite, resource)[source]¶

Bases: object

libraries¶

handle_imports()[source]¶

import_resource(name, overwrite=True)[source]¶

import_variables(name, args, overwrite=False)[source]¶

import_library(name, args=(), alias=None, notify=True)[source]¶

set_search_order(new_order)[source]¶

start_test()[source]¶

end_test()[source]¶

start_suite()[source]¶

end_suite(suite)[source]¶

start_user_keyword()[source]¶

end_user_keyword()[source]¶

get_library_instance(libname)[source]¶

get_library_instances()[source]¶

reload_library(libname_or_instance)[source]¶

get_runner(name)[source]¶

class robot.running.namespace.KeywordStore(resource)[source]¶

Bases: object

get_library(name_or_instance)[source]¶

get_runner(name)[source]¶

class robot.running.namespace.KeywordRecommendationFinder(user_keywords, libraries, resources)[source]¶

Bases: object

recommend_similar_keywords(name)[source]¶: Return keyword names similar to name.

static format_recommendations(message, recommendations)[source]¶

robot.running.outputcapture module¶

class robot.running.outputcapture.OutputCapturer(library_import=False)[source]¶: Bases: object

class robot.running.outputcapture.PythonCapturer(stdout=True)[source]¶

Bases: object

release()[source]¶

class robot.running.outputcapture.JavaCapturer(stdout=True)[source]¶

Bases: object

release()[source]¶

robot.running.randomizer module¶

class robot.running.randomizer.Randomizer(randomize_suites=True, randomize_tests=True, seed=None)[source]¶

Bases: robot.model.visitor.SuiteVisitor

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

visit_keyword(kw)[source]¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_suite(suite)¶: Called when suite ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

robot.running.runkwregister module¶

robot.running.signalhandler module¶

robot.running.status module¶

class robot.running.status.Failure[source]¶: Bases: object

class robot.running.status.Exit(failure_mode=False, error_mode=False, skip_teardown_mode=False)[source]¶

Bases: object

failure_occurred(failure=None)[source]¶

error_occurred()[source]¶

teardown_allowed¶

class robot.running.status.SuiteStatus(parent=None, exit_on_failure_mode=False, exit_on_error_mode=False, skip_teardown_on_exit_mode=False)[source]¶

Bases: robot.running.status._ExecutionStatus

error_occurred()¶

failed¶

failure_occurred()¶

message¶

setup_executed(failure=None)¶

status¶

teardown_allowed¶

teardown_executed(failure=None)¶

class robot.running.status.TestStatus(parent, test, skip_on_failure=None, critical_tags=None, rpa=False)[source]¶

Bases: robot.running.status._ExecutionStatus

test_failed(failure)[source]¶

test_skipped(reason)[source]¶

skip_if_needed()[source]¶

error_occurred()¶

failed¶

failure_occurred()¶

message¶

setup_executed(failure=None)¶

status¶

teardown_allowed¶

teardown_executed(failure=None)¶

class robot.running.status.TestMessage(status)[source]¶

Bases: robot.running.status._Message

setup_message = 'Setup failed:\n%s'¶

teardown_message = 'Teardown failed:\n%s'¶

setup_skipped_message = '%s'¶

teardown_skipped_message = '%s'¶

also_teardown_message = '%s\n\nAlso teardown failed:\n%s'¶

also_teardown_skip_message = 'Skipped in teardown:\n%s\n\nEarlier message:\n%s'¶

exit_on_fatal_message = 'Test execution stopped due to a fatal error.'¶

exit_on_failure_message = 'Failure occurred and exit-on-failure mode is in use.'¶

exit_on_error_message = 'Error occurred and exit-on-error mode is in use.'¶

message¶

class robot.running.status.SuiteMessage(status)[source]¶

Bases: robot.running.status._Message

setup_message = 'Suite setup failed:\n%s'¶

setup_skipped_message = 'Skipped in suite setup:\n%s'¶

teardown_skipped_message = 'Skipped in suite teardown:\n%s'¶

teardown_message = 'Suite teardown failed:\n%s'¶

also_teardown_message = '%s\n\nAlso suite teardown failed:\n%s'¶

also_teardown_skip_message = 'Skipped in suite teardown:\n%s\n\nEarlier message:\n%s'¶

message¶

class robot.running.status.ParentMessage(status)[source]¶

Bases: robot.running.status.SuiteMessage

setup_message = 'Parent suite setup failed:\n%s'¶

setup_skipped_message = 'Skipped in parent suite setup:\n%s'¶

teardown_skipped_message = 'Skipped in parent suite teardown:\n%s'¶

teardown_message = 'Parent suite teardown failed:\n%s'¶

also_teardown_message = '%s\n\nAlso parent suite teardown failed:\n%s'¶

also_teardown_skip_message = 'Skipped in suite teardown:\n%s\n\nEarlier message:\n%s'¶

message¶

robot.running.statusreporter module¶

class robot.running.statusreporter.StatusReporter(data, result, context, run=True)[source]¶: Bases: object

robot.running.suiterunner module¶

class robot.running.suiterunner.SuiteRunner(output, settings)[source]¶

Bases: robot.model.visitor.SuiteVisitor

start_suite(suite)[source]¶

Called when suite starts. Default implementation does nothing.

Can return explicit False to stop visiting.

end_suite(suite)[source]¶: Called when suite ends. Default implementation does nothing.

visit_test(test)[source]¶

Implements traversing through tests.

Can be overridden to allow modifying the passed in test without calling start_test() or end_test() nor visiting keywords.

end_for(for_)¶: Called when FOR loop ends. Default implementation does nothing.

end_for_iteration(iteration)¶: Called when FOR loop iteration ends. Default implementation does nothing.

end_if(if_)¶: Called when IF/ELSE structure ends. Default implementation does nothing.

end_if_branch(branch)¶: Called when IF/ELSE branch ends. Default implementation does nothing.

end_keyword(keyword)¶: Called when keyword ends. Default implementation does nothing.

end_message(msg)¶: Called when message ends. Default implementation does nothing.

end_test(test)¶: Called when test ends. Default implementation does nothing.

start_for(for_)¶

Called when FOR loop starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_for_iteration(iteration)¶

Called when FOR loop iteration starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if(if_)¶

Called when IF/ELSE structure starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_if_branch(branch)¶

Called when IF/ELSE branch starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_keyword(keyword)¶

Called when keyword starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_message(msg)¶

Called when message starts. Default implementation does nothing.

Can return explicit False to stop visiting.

start_test(test)¶

Called when test starts. Default implementation does nothing.

Can return explicit False to stop visiting.

visit_for(for_)¶

Implements traversing through FOR loops.

Can be overridden to allow modifying the passed in for_ without calling start_for() or end_for() nor visiting body.

visit_for_iteration(iteration)¶

Implements traversing through single FOR loop iteration.

This is only used with the result side model because on the running side there are no iterations.

Can be overridden to allow modifying the passed in iteration without calling start_for_iteration() or end_for_iteration() nor visiting body.

visit_if(if_)¶

Implements traversing through IF/ELSE structures.

Notice that if_ does not have any data directly. Actual IF/ELSE branches are in its body and visited using visit_if_branch().

Can be overridden to allow modifying the passed in if_ without calling start_if() or end_if() nor visiting branches.

visit_if_branch(branch)¶

Implements traversing through single IF/ELSE branch.

Can be overridden to allow modifying the passed in branch without calling start_if_branch() or end_if_branch() nor visiting body.

visit_keyword(kw)¶

Implements traversing through keywords.

Can be overridden to allow modifying the passed in kw without calling start_keyword() or end_keyword() nor visiting child keywords.

visit_message(msg)¶

Implements visiting messages.

Can be overridden to allow modifying the passed in msg without calling start_message() or end_message().

visit_suite(suite)¶

Implements traversing through suites.

Can be overridden to allow modifying the passed in suite without calling start_suite() or end_suite() nor visiting child suites, tests or keywords (setup and teardown) at all.

robot.running.testlibraries module¶

robot.running.testlibraries.TestLibrary(name, args=None, variables=None, create_handlers=True, logger=<robot.output.logger.Logger object>)[source]¶

robot.running.usererrorhandler module¶

class robot.running.usererrorhandler.UserErrorHandler(error, name, libname=None)[source]¶

Bases: object

Created if creating handlers fail – running raises DataError.

The idea is not to raise DataError at processing time and prevent all tests in affected test case file from executing. Instead UserErrorHandler is created and if it is ever run DataError is raised then.

Parameters:	error (robot.errors.DataError) – Occurred error. name (str) – Name of the affected keyword. libname (str) – Name of the affected library or resource.

longname¶

doc¶

shortdoc¶

create_runner(name)[source]¶

run(kw, context, run=True)[source]¶

dry_run(kw, context, run=True)¶

robot.running.userkeyword module¶

class robot.running.userkeyword.UserLibrary(resource, source_type='Resource file')[source]¶

Bases: object

TEST_CASE_FILE_TYPE = 'Test case file'¶

RESOURCE_FILE_TYPE = 'Resource file'¶

class robot.running.userkeyword.UserKeywordHandler(keyword, libname)[source]¶

Bases: object

longname¶

shortdoc¶

create_runner(name)[source]¶

class robot.running.userkeyword.EmbeddedArgumentsHandler(keyword, libname, embedded)[source]¶

Bases: robot.running.userkeyword.UserKeywordHandler

matches(name)[source]¶

create_runner(name)[source]¶

longname¶

shortdoc¶

robot.running.userkeywordrunner module¶

class robot.running.userkeywordrunner.UserKeywordRunner(handler, name=None)[source]¶

Bases: object

longname¶

libname¶

arguments¶

Return type:	`robot.running.arguments.ArgumentSpec`

run(kw, context, run=True)[source]¶

dry_run(kw, context)[source]¶

class robot.running.userkeywordrunner.EmbeddedArgumentsRunner(handler, name)[source]¶

Bases: robot.running.userkeywordrunner.UserKeywordRunner

arguments¶

Return type:	`robot.running.arguments.ArgumentSpec`

dry_run(kw, context)¶

libname¶

longname¶

run(kw, context, run=True)¶

robot.tidypkg package¶

Submodules¶

robot.tidypkg.transformers module¶

class robot.tidypkg.transformers.Cleaner[source]¶

Bases: robot.parsing.model.visitor.ModelTransformer

Clean up and normalize data.

Following transformations are made: 1) section headers are normalized to format *** Section Name *** 2) setting names are normalize in setting table and in test cases and

user keywords to format Setting Name or [Setting Name]

settings without values are removed
Empty lines after section headers and within items are removed
For loop declaration and end tokens are normalized to FOR and END
Old style for loop indent (i.e. a cell with only a ``) are removed

visit_CommentSection(section)[source]¶

visit_Section(section)[source]¶

visit_Statement(statement)[source]¶

visit_For(loop)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.tidypkg.transformers.NewlineNormalizer(newline, short_test_name_length)[source]¶

Bases: robot.parsing.model.visitor.ModelTransformer

Normalize new lines in test data

After this transformation, there is exactly one empty line between each section and between each test or user keyword.

visit_File(node)[source]¶

visit_Section(node)[source]¶

visit_CommentSection(node)[source]¶

visit_TestCaseSection(node)[source]¶

visit_TestCase(node)[source]¶

visit_KeywordSection(node)[source]¶

visit_Keyword(node)[source]¶

visit_Statement(statement)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.tidypkg.transformers.SeparatorNormalizer(use_pipes, space_count)[source]¶

Bases: robot.parsing.model.visitor.ModelTransformer

Make separators and indentation consistent.

visit_TestCase(node)[source]¶

visit_Keyword(node)[source]¶

visit_For(node)[source]¶

visit_If(node)[source]¶

visit_Statement(statement)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.tidypkg.transformers.ColumnAligner(short_test_name_length, widths)[source]¶

Bases: robot.parsing.model.visitor.ModelTransformer

visit_TestCase(node)[source]¶

visit_For(node)[source]¶

visit_Statement(statement)[source]¶

align_header(statement)[source]¶

align_statement(statement)[source]¶

widths_for_line(line)[source]¶

should_write_content_after_name(line_pos)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.tidypkg.transformers.ColumnWidthCounter[source]¶

Bases: robot.parsing.model.visitor.ModelTransformer

visit_Statement(statement)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

class robot.tidypkg.transformers.Aligner(short_test_name_length, setting_and_variable_name_length, pipes_mode)[source]¶

Bases: robot.parsing.model.visitor.ModelTransformer

visit_TestCaseSection(section)[source]¶

visit_KeywordSection(section)[source]¶

visit_Statement(statement)[source]¶

generic_visit(node)¶: Called if no explicit visitor function exists for a node.

visit(node)¶: Visit a node.

robot.utils package¶

Various generic utility functions and classes.

Utilities are mainly for internal usage, but external libraries and tools may find some of them useful. Utilities are generally stable, but absolute backwards compatibility between major versions is not guaranteed.

All utilities are exposed via the robot.utils package, and should be used either like:

from robot import utils

assert utils.Matcher('H?llo').match('Hillo')

or:

from robot.utils import Matcher

assert Matcher('H?llo').match('Hillo')

robot.utils.read_rest_data(rstfile)[source]¶

Submodules¶

robot.utils.application module¶

class robot.utils.application.Application(usage, name=None, version=None, arg_limits=None, env_options=None, logger=None, **auto_options)[source]¶

Bases: object

main(arguments, **options)[source]¶

validate(options, arguments)[source]¶

execute_cli(cli_arguments, exit=True)[source]¶

console(msg)[source]¶

parse_arguments(cli_args)[source]¶

Public interface for parsing command line arguments.

Parameters:	cli_args – Command line arguments as a list
Returns:	options (dict), arguments (list)
Raises:	`Information` when –help or –version used
Raises:	`DataError` when parsing fails

execute(*arguments, **options)[source]¶

class robot.utils.application.DefaultLogger[source]¶

Bases: object

info(message)[source]¶

error(message)[source]¶

close()[source]¶

robot.utils.argumentparser module¶

robot.utils.argumentparser.cmdline2list(args, escaping=False)[source]¶

class robot.utils.argumentparser.ArgumentParser(usage, name=None, version=None, arg_limits=None, validator=None, env_options=None, auto_help=True, auto_version=True, auto_pythonpath=True, auto_argumentfile=True)[source]¶

Bases: object

Available options and tool name are read from the usage.

Tool name is got from the first row of the usage. It is either the whole row or anything before first ‘ – ‘.

parse_args(args)[source]¶

Parse given arguments and return options and positional arguments.

Arguments must be given as a list and are typically sys.argv[1:].

Options are returned as a dictionary where long options are keys. Value is a string for those options that can be given only one time (if they are given multiple times the last value is used) or None if the option is not used at all. Value for options that can be given multiple times (denoted with ‘*’ in the usage) is a list which contains all the given values and is empty if options are not used. Options not taken arguments have value False when they are not set and True otherwise.

Positional arguments are returned as a list in the order they are given.

If ‘check_args’ is True, this method will automatically check that correct number of arguments, as parsed from the usage line, are given. If the last argument in the usage line ends with the character ‘s’, the maximum number of arguments is infinite.

Possible errors in processing arguments are reported using DataError.

Some options have a special meaning and are handled automatically if defined in the usage and given from the command line:

–argumentfile can be used to automatically read arguments from a specified file. When –argumentfile is used, the parser always allows using it multiple times. Adding ‘*’ to denote that is thus recommend. A special value ‘stdin’ can be used to read arguments from stdin instead of a file.

–pythonpath can be used to add extra path(s) to sys.path.

–help and –version automatically generate help and version messages. Version is generated based on the tool name and version – see __init__ for information how to set them. Help contains the whole usage given to __init__. Possible <VERSION> text in the usage is replaced with the given version. Both help and version are wrapped to Information exception.

class robot.utils.argumentparser.ArgLimitValidator(arg_limits)[source]¶: Bases: object

class robot.utils.argumentparser.ArgFileParser(options)[source]¶

Bases: object

process(args)[source]¶

robot.utils.asserts module¶

Convenience functions for testing both in unit and higher levels.

Benefits:

Integrates 100% with unittest (see example below)
Can be easily used without unittest (using unittest.TestCase when you only need convenient asserts is not so nice)
Saved typing and shorter lines because no need to have ‘self.’ before asserts. These are static functions after all so that is OK.
All ‘equals’ methods (by default) report given values even if optional message given. This behavior can be controlled with the optional values argument.

Drawbacks:

unittest is not able to filter as much non-interesting traceback away as with its own methods because AssertionErrors occur outside.

Most of the functions are copied more or less directly from unittest.TestCase which comes with the following license. Further information about unittest in general can be found from http://pyunit.sourceforge.net/. This module can be used freely in same terms as unittest.

unittest license:

Copyright (c) 1999-2003 Steve Purcell
This module is free software, and you may redistribute it and/or modify
it under the same terms as Python itself, so long as this copyright message
and disclaimer are retained in their original form.

IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF
THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.

THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS,
AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

Examples:

import unittest
from robot.utils.asserts import assert_equal

class MyTests(unittest.TestCase):

    def test_old_style(self):
        self.assertEqual(1, 2, 'my msg')

    def test_new_style(self):
        assert_equal(1, 2, 'my msg')

Example output:

FF
======================================================================
FAIL: test_old_style (example.MyTests)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "example.py", line 7, in test_old_style
    self.assertEqual(1, 2, 'my msg')
AssertionError: my msg

======================================================================
FAIL: test_new_style (example.MyTests)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "example.py", line 10, in test_new_style
    assert_equal(1, 2, 'my msg')
  File "/path/to/robot/utils/asserts.py", line 181, in assert_equal
    _report_inequality_failure(first, second, msg, values, '!=')
  File "/path/to/robot/utils/asserts.py", line 229, in _report_inequality_failure
    raise AssertionError(msg)
AssertionError: my msg: 1 != 2

----------------------------------------------------------------------
Ran 2 tests in 0.000s

FAILED (failures=2)

robot.utils.asserts.fail(msg=None)[source]¶: Fail test immediately with the given message.

robot.utils.asserts.assert_false(expr, msg=None)[source]¶: Fail the test if the expression is True.

robot.utils.asserts.assert_true(expr, msg=None)[source]¶: Fail the test unless the expression is True.

robot.utils.asserts.assert_not_none(obj, msg=None, values=True)[source]¶: Fail the test if given object is None.

robot.utils.asserts.assert_none(obj, msg=None, values=True)[source]¶: Fail the test if given object is not None.

robot.utils.asserts.assert_raises(exc_class, callable_obj, *args, **kwargs)[source]¶

Fail unless an exception of class exc_class is thrown by callable_obj.

callable_obj is invoked with arguments args and keyword arguments kwargs. If a different type of exception is thrown, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If a correct exception is raised, the exception instance is returned by this method.

robot.utils.asserts.assert_raises_with_msg(exc_class, expected_msg, callable_obj, *args, **kwargs)[source]¶: Similar to fail_unless_raises but also checks the exception message.

robot.utils.asserts.assert_equal(first, second, msg=None, values=True, formatter=None)[source]¶: Fail if given objects are unequal as determined by the ‘==’ operator.

robot.utils.asserts.assert_not_equal(first, second, msg=None, values=True, formatter=None)[source]¶: Fail if given objects are equal as determined by the ‘==’ operator.

robot.utils.asserts.assert_almost_equal(first, second, places=7, msg=None, values=True)[source]¶

Fail if the two objects are unequal after rounded to given places.

inequality is determined by object’s difference rounded to the given number of decimal places (default 7) and comparing to zero. Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

robot.utils.asserts.assert_not_almost_equal(first, second, places=7, msg=None, values=True)[source]¶

Fail if the two objects are unequal after rounded to given places.

Equality is determined by object’s difference rounded to to the given number of decimal places (default 7) and comparing to zero. Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

robot.utils.charwidth module¶

A module to handle different character widths on the console.

Some East Asian characters have width of two on console, and combining characters themselves take no extra space.

See issue 604 [1] for more details about East Asian characters. The issue also contains generate_wild_chars.py script that was originally used to create _EAST_ASIAN_WILD_CHARS mapping. An updated version of the script is attached to issue 1096. Big thanks for xieyanbo for the script and the original patch.

Note that Python’s unicodedata module is not used here because importing it takes several seconds on Jython.

[1] https://github.com/robotframework/robotframework/issues/604 [2] https://github.com/robotframework/robotframework/issues/1096

robot.utils.charwidth.get_char_width(char)[source]¶

robot.utils.compat module¶

robot.utils.compat.unwrap(func)[source]¶

robot.utils.compat.unicode_to_str(self)[source]¶

robot.utils.compat.py2to3(cls)[source]¶: Deprecated since RF 4.0. Use ‘py3to2’ instead.

robot.utils.compat.py3to2(cls)[source]¶

robot.utils.compat.with_metaclass(meta, *bases)[source]¶: Create a base class with a metaclass.

robot.utils.compat.isatty(stream)[source]¶

robot.utils.compress module¶

robot.utils.compress.compress_text(text)[source]¶

robot.utils.connectioncache module¶

class robot.utils.connectioncache.ConnectionCache(no_current_msg='No open connection.')[source]¶

Bases: object

Cache for test libs to use with concurrent connections, processes, etc.

The cache stores the registered connections (or other objects) and allows switching between them using generated indices or user given aliases. This is useful with any test library where there’s need for multiple concurrent connections, processes, etc.

This class can, and is, used also outside the core framework by SSHLibrary, Selenium(2)Library, etc. Backwards compatibility is thus important when doing changes.

current = None¶: Current active connection.

current_index¶

register(connection, alias=None)[source]¶

Registers given connection with optional alias and returns its index.

Given connection is set to be the current connection.

If alias is given, it must be a string. Aliases are case and space insensitive.

The index of the first connection after initialization, and after close_all() or empty_cache(), is 1, second is 2, etc.

switch(alias_or_index)[source]¶

Switches to the connection specified by the given alias or index.

Updates current and also returns its new value.

Alias is whatever was given to register() method and indices are returned by it. Index can be given either as an integer or as a string that can be converted to an integer. Raises an error if no connection with the given index or alias found.

get_connection(alias_or_index=None)[source]¶

Get the connection specified by the given alias or index..

If alias_or_index is None, returns the current connection if it is active, or raises an error if it is not.

Alias is whatever was given to register() method and indices are returned by it. Index can be given either as an integer or as a string that can be converted to an integer. Raises an error if no connection with the given index or alias found.

close_all(closer_method='close')[source]¶

Closes connections using given closer method and empties cache.

If simply calling the closer method is not adequate for closing connections, clients should close connections themselves and use empty_cache() afterwards.

empty_cache()[source]¶

Empties the connection cache.

Indexes of the new connections starts from 1 after this.

resolve_alias_or_index(alias_or_index)[source]¶

class robot.utils.connectioncache.NoConnection(message)[source]¶

Bases: object

raise_error()[source]¶

robot.utils.dotdict module¶

class robot.utils.dotdict.DotDict(*args, **kwds)[source]¶

Bases: collections.OrderedDict

clear() → None. Remove all items from od.¶

copy() → a shallow copy of od¶

classmethod fromkeys(S[, v]) → New ordered dictionary with keys from S.¶: If not specified, the value defaults to None.

get(k[, d]) → D[k] if k in D, else d. d defaults to None.¶

has_key(k) → True if D has a key k, else False¶

items() → list of (key, value) pairs in od¶

iteritems()¶: od.iteritems -> an iterator over the (key, value) pairs in od

iterkeys() → an iterator over the keys in od¶

itervalues()¶: od.itervalues -> an iterator over the values in od

keys() → list of keys in od¶

pop(k[, d]) → v, remove specified key and return the corresponding¶: value. If key is not found, d is returned if given, otherwise KeyError is raised.

popitem() → (k, v), return and remove a (key, value) pair.¶: Pairs are returned in LIFO order if last is true or FIFO order if false.

setdefault(k[, d]) → od.get(k,d), also set od[k]=d if k not in od¶

update([E, ]**F) → None. Update D from mapping/iterable E and F.¶: If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

values() → list of values in od¶

viewitems() → a set-like object providing a view on od's items¶

viewkeys() → a set-like object providing a view on od's keys¶

viewvalues() → an object providing a view on od's values¶

robot.utils.encoding module¶

robot.utils.encoding.console_decode(string, encoding='UTF-8', force=False)[source]¶

Decodes bytes from console encoding to Unicode.

By default uses the system console encoding, but that can be configured using the encoding argument. In addition to the normal encodings, it is possible to use case-insensitive values CONSOLE and SYSTEM to use the system console and system encoding, respectively.

By default returns Unicode strings as-is. The force argument can be used on IronPython where all strings are unicode and caller knows decoding is needed.

robot.utils.encoding.console_encode(string, encoding=None, errors='replace', stream=<open file '<stdout>', mode 'w'>, force=False)[source]¶

Encodes Unicode to bytes in console or system encoding.

If encoding is not given, determines it based on the given stream and system configuration. In addition to the normal encodings, it is possible to use case-insensitive values CONSOLE and SYSTEM to use the system console and system encoding, respectively.

On Python 3 and IronPython returns Unicode unless force is True in which case returns bytes. Otherwise always returns bytes.

robot.utils.encoding.system_decode(string)[source]¶

Decodes bytes from system (e.g. cli args or env vars) to Unicode.

Depending on the usage, at least cli args may already be Unicode.

robot.utils.encoding.system_encode(string, errors='replace')[source]¶

Encodes Unicode to system encoding (e.g. cli args and env vars).

Non-Unicode values are first converted to Unicode.

robot.utils.encodingsniffer module¶

robot.utils.encodingsniffer.get_system_encoding()[source]¶

robot.utils.encodingsniffer.get_console_encoding()[source]¶

robot.utils.error module¶

robot.utils.error.get_error_message()[source]¶

Returns error message of the last occurred exception.

This method handles also exceptions containing unicode messages. Thus it MUST be used to get messages from all exceptions originating outside the framework.

robot.utils.error.get_error_details(exclude_robot_traces=True)[source]¶: Returns error message and details of the last occurred exception.

robot.utils.error.ErrorDetails(exc_info=None, exclude_robot_traces=True)[source]¶

This factory returns an object that wraps the last occurred exception

It has attributes message, traceback and error, where message contains type and message of the original error, traceback contains the traceback/stack trace and error contains the original error instance.

class robot.utils.error.PythonErrorDetails(exc_type, exc_value, exc_traceback, exclude_robot_traces=True)[source]¶

Bases: robot.utils.error._ErrorDetails

message¶

traceback¶

class robot.utils.error.JavaErrorDetails(exc_type, exc_value, exc_traceback, exclude_robot_traces=True)[source]¶

Bases: robot.utils.error._ErrorDetails

message¶

traceback¶

robot.utils.escaping module¶

robot.utils.escaping.escape(item)[source]¶

robot.utils.escaping.glob_escape(item)[source]¶

class robot.utils.escaping.Unescaper[source]¶

Bases: object

unescape(item)[source]¶

robot.utils.escaping.split_from_equals(string)[source]¶

robot.utils.etreewrapper module¶

class robot.utils.etreewrapper.ETSource(source)[source]¶: Bases: object

robot.utils.filereader module¶

class robot.utils.filereader.FileReader(source, accept_text=False)[source]¶

Bases: object

Utility to ease reading different kind of files.

Supports different sources where to read the data:

The source can be a path to a file, either as a string or as a pathlib.Path instance in Python 3. The file itself must be UTF-8 encoded.
Alternatively the source can be an already opened file object, including a StringIO or BytesIO object. The file can contain either Unicode text or UTF-8 encoded bytes.
The third options is giving the source as Unicode text directly. This requires setting accept_text=True when creating the reader.

In all cases bytes are automatically decoded to Unicode and possible BOM removed.

read()[source]¶

readlines()[source]¶

robot.utils.frange module¶

robot.utils.frange.frange(*args)[source]¶: Like range() but accepts float arguments.

robot.utils.htmlformatters module¶

class robot.utils.htmlformatters.LinkFormatter[source]¶

Bases: object

format_url(text)[source]¶

format_link(text)[source]¶

class robot.utils.htmlformatters.LineFormatter[source]¶

Bases: object

handles(line)¶

newline = '\n'¶

format(line)[source]¶

class robot.utils.htmlformatters.HtmlFormatter[source]¶

Bases: object

format(text)[source]¶

class robot.utils.htmlformatters.RulerFormatter[source]¶

Bases: robot.utils.htmlformatters._SingleLineFormatter

match()¶: match(string[, pos[, endpos]]) –> match object or None. Matches zero or more characters at the beginning of the string

format_line(line)[source]¶

add(line)¶

end()¶

format(lines)¶

handles(line)¶

class robot.utils.htmlformatters.HeaderFormatter[source]¶

Bases: robot.utils.htmlformatters._SingleLineFormatter

match()¶: match(string[, pos[, endpos]]) –> match object or None. Matches zero or more characters at the beginning of the string

format_line(line)[source]¶

add(line)¶

end()¶

format(lines)¶

handles(line)¶

class robot.utils.htmlformatters.ParagraphFormatter(other_formatters)[source]¶

Bases: robot.utils.htmlformatters._Formatter

format(lines)[source]¶

add(line)¶

end()¶

handles(line)¶

class robot.utils.htmlformatters.TableFormatter[source]¶

Bases: robot.utils.htmlformatters._Formatter

format(lines)[source]¶

add(line)¶

end()¶

handles(line)¶

class robot.utils.htmlformatters.PreformattedFormatter[source]¶

Bases: robot.utils.htmlformatters._Formatter

format(lines)[source]¶

add(line)¶

end()¶

handles(line)¶

class robot.utils.htmlformatters.ListFormatter[source]¶

Bases: robot.utils.htmlformatters._Formatter

format(lines)[source]¶

add(line)¶

end()¶

handles(line)¶

robot.utils.importer module¶

robot.utils.importer.invalidate_import_caches()¶

class robot.utils.importer.Importer(type=None, logger=None)[source]¶

Bases: object

Utility that can import modules and classes based on names and paths.

Imported classes can optionally be instantiated automatically.

Parameters:	type – Type of the thing being imported. Used in error and log messages. logger – Logger to be notified about successful imports and other events. Currently only needs the `info` method, but other level specific methods may be needed in the future. If not given, logging is disabled.

import_class_or_module(name_or_path, instantiate_with_args=None, return_source=False)[source]¶

Imports Python class/module or Java class based on the given name or path.

Parameters:	name_or_path – Name or path of the module or class to import. instantiate_with_args – When arguments are given, imported classes are automatically initialized using them. return_source – When true, returns a tuple containing the imported module or class and a path to it. By default returns only the imported module or class.

The class or module to import can be specified either as a name, in which case it must be in the module search path, or as a path to the file or directory implementing the module. See import_class_or_module_by_path() for more information about importing classes and modules by path.

Classes can be imported from the module search path using name like modulename.ClassName. If the class name and module name are same, using just CommonName is enough. When importing a class by a path, the class name and the module name must match.

Optional arguments to use when creating an instance are given as a list. Starting from Robot Framework 4.0, both positional and named arguments are supported (e.g. ['positional', 'name=value']) and arguments are converted automatically based on type hints and default values.

If arguments needed when creating an instance are initially embedded into the name or path like Example:arg1:arg2, separate split_args_from_name_or_path() function can be used to split them before calling this method.

import_class_or_module_by_path(path, instantiate_with_args=None)[source]¶

Import a Python module or Java class using a file system path.

Parameters:	path – Path to the module or class to import. instantiate_with_args – When arguments are given, imported classes are automatically initialized using them.

When importing a Python file, the path must end with .py and the actual file must also exist. When importing Java classes, the path must end with .java or .class. The Java class file must exist in both cases and in the former case also the source file must exist.

Use import_class_or_module() to support importing also using name, not only path. See the documentation of that function for more information about creating instances automatically.

class robot.utils.importer.ByPathImporter(logger)[source]¶

Bases: robot.utils.importer._Importer

handles(path)[source]¶

import_(path)[source]¶

class robot.utils.importer.NonDottedImporter(logger)[source]¶

Bases: robot.utils.importer._Importer

handles(name)[source]¶

import_(name)[source]¶

class robot.utils.importer.DottedImporter(logger)[source]¶

Bases: robot.utils.importer._Importer

handles(name)[source]¶

import_(name)[source]¶

class robot.utils.importer.NoLogger[source]¶

Bases: object

error(*args, **kws)¶

warn(*args, **kws)¶

info(*args, **kws)¶

debug(*args, **kws)¶

trace(*args, **kws)¶

robot.utils.markuputils module¶

robot.utils.markuputils.html_escape(text, linkify=True)[source]¶

robot.utils.markuputils.xml_escape(text)[source]¶

robot.utils.markuputils.html_format(text)[source]¶

robot.utils.markuputils.attribute_escape(attr)[source]¶

robot.utils.markupwriters module¶

class robot.utils.markupwriters.HtmlWriter(output, write_empty=True, usage=None)[source]¶

Bases: robot.utils.markupwriters._MarkupWriter

Parameters:	output – Either an opened, file like object, or a path to the desired output file. In the latter case, the file is created and clients should use `close()` method to close it. write_empty – Whether to write empty elements and attributes.

close()¶: Closes the underlying output file.

content(content=None, escape=True, newline=False)¶

element(name, content=None, attrs=None, escape=True, newline=True)¶

end(name, newline=True)¶

start(name, attrs=None, newline=True)¶

class robot.utils.markupwriters.XmlWriter(output, write_empty=True, usage=None)[source]¶

Bases: robot.utils.markupwriters._MarkupWriter

Parameters:	output – Either an opened, file like object, or a path to the desired output file. In the latter case, the file is created and clients should use `close()` method to close it. write_empty – Whether to write empty elements and attributes.

element(name, content=None, attrs=None, escape=True, newline=True)[source]¶

close()¶: Closes the underlying output file.

content(content=None, escape=True, newline=False)¶

end(name, newline=True)¶

start(name, attrs=None, newline=True)¶

class robot.utils.markupwriters.NullMarkupWriter(**kwargs)[source]¶

Bases: object

Null implementation of the _MarkupWriter interface.

start(**kwargs)¶

content(**kwargs)¶

element(**kwargs)¶

end(**kwargs)¶

close(**kwargs)¶

robot.utils.match module¶

robot.utils.match.eq(str1, str2, ignore=(), caseless=True, spaceless=True)[source]¶

class robot.utils.match.Matcher(pattern, ignore=(), caseless=True, spaceless=True, regexp=False)[source]¶

Bases: object

match(string)[source]¶

match_any(strings)[source]¶

class robot.utils.match.MultiMatcher(patterns=None, ignore=(), caseless=True, spaceless=True, match_if_no_patterns=False, regexp=False)[source]¶

Bases: object

match(string)[source]¶

match_any(strings)[source]¶

robot.utils.misc module¶

robot.utils.misc.roundup(number, ndigits=0, return_type=None)[source]¶

Rounds number to the given number of digits.

Numbers equally close to a certain precision are always rounded away from zero. By default return value is float when ndigits is positive and int otherwise, but that can be controlled with return_type.

With the built-in round() rounding equally close numbers as well as the return type depends on the Python version.

robot.utils.misc.printable_name(string, code_style=False)[source]¶

Generates and returns printable name from the given string.

Examples: ‘simple’ -> ‘Simple’ ‘name with spaces’ -> ‘Name With Spaces’ ‘more spaces’ -> ‘More Spaces’ ‘Cases AND spaces’ -> ‘Cases AND Spaces’ ‘’ -> ‘’

If ‘code_style’ is True:

‘mixedCAPSCamel’ -> ‘Mixed CAPS Camel’ ‘camelCaseName’ -> ‘Camel Case Name’ ‘under_score_name’ -> ‘Under Score Name’ ‘under_and space’ -> ‘Under And Space’ ‘miXed_CAPS_nAMe’ -> ‘MiXed CAPS NAMe’ ‘’ -> ‘’

robot.utils.misc.plural_or_not(item)[source]¶

robot.utils.misc.seq2str(sequence, quote="'", sep=', ', lastsep=' and ')[source]¶: Returns sequence in format ‘item 1’, ‘item 2’ and ‘item 3’.

robot.utils.misc.seq2str2(sequence)[source]¶: Returns sequence in format [ item 1 | item 2 | … ].

robot.utils.misc.test_or_task(text, rpa=False)[source]¶: Replaces {test} in text with test or task depending on rpa.

robot.utils.normalizing module¶

robot.utils.normalizing.normalize(string, ignore=(), caseless=True, spaceless=True)[source]¶

Normalizes given string according to given spec.

By default string is turned to lower case and all whitespace is removed. Additional characters can be removed by giving them in ignore list.

robot.utils.normalizing.normalize_whitespace(string)[source]¶

robot.utils.normalizing.lower(string)[source]¶

class robot.utils.normalizing.NormalizedDict(initial=None, ignore=(), caseless=True, spaceless=True)[source]¶

Bases: _abcoll.MutableMapping

Custom dictionary implementation automatically normalizing keys.

Initialized with possible initial value and normalizing spec.

Initial values can be either a dictionary or an iterable of name/value pairs. In the latter case items are added in the given order.

Normalizing spec has exact same semantics as with the normalize() function.

copy()[source]¶

clear() → None. Remove all items from D.[source]¶

get(k[, d]) → D[k] if k in D, else d. d defaults to None.¶

items() → list of D's (key, value) pairs, as 2-tuples¶

iteritems() → an iterator over the (key, value) items of D¶

iterkeys() → an iterator over the keys of D¶

itervalues() → an iterator over the values of D¶

keys() → list of D's keys¶

pop(k[, d]) → v, remove specified key and return the corresponding value.¶: If key is not found, d is returned if given, otherwise KeyError is raised.

popitem() → (k, v), remove and return some (key, value) pair¶: as a 2-tuple; but raise KeyError if D is empty.

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D¶

update([E, ]**F) → None. Update D from mapping/iterable E and F.¶: If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

values() → list of D's values¶

robot.utils.platform module¶

robot.utils.recommendations module¶

class robot.utils.recommendations.RecommendationFinder(normalizer=None)[source]¶

Bases: object

find_and_format(name, candidates, message, max_matches=10)[source]¶

find(name, candidates, max_matches=10)[source]¶: Return a list of close matches to name from candidates.

format(message, recommendations=None)[source]¶

Add recommendations to the given message.

The recommendation string looks like:

<message> Did you mean:
    <recommendations[0]>
    <recommendations[1]>
    <recommendations[2]>

robot.utils.restreader module¶

robot.utils.robotenv module¶

robot.utils.robotinspect module¶

robot.utils.robotio module¶

robot.utils.robotpath module¶

robot.utils.robottime module¶

robot.utils.robottypes module¶

robot.utils.robottypes2 module¶

robot.utils.robottypes3 module¶

robot.utils.setter module¶

robot.utils.sortable module¶

robot.utils.text module¶

robot.utils.unic module¶

robot.variables package¶

Implements storing and resolving variables.

This package is mainly for internal usage, but utilities for finding variables can be used externally as well.

robot.variables.is_var(string, identifiers='$@&')[source]¶: Deprecated since RF 3.2. Use is_variable instead.

robot.variables.is_scalar_var(string)[source]¶: Deprecated since RF 3.2. Use is_scalar_variable instead.

robot.variables.is_list_var(string)[source]¶: Deprecated since RF 3.2. Use is_list_variable instead.

robot.variables.is_dict_var(string)[source]¶: Deprecated since RF 3.2. Use is_dict_variable instead.

robot.variables.contains_var(string, identifiers='$@&')[source]¶: Deprecated since RF 3.2. Use contains_variable instead.

Submodules¶

robot.variables.assigner module¶

class robot.variables.assigner.VariableAssignment(assignment)[source]¶

Bases: object

validate_assignment()[source]¶

assigner(context)[source]¶

class robot.variables.assigner.AssignmentValidator[source]¶

Bases: object

validate(variable)[source]¶

class robot.variables.assigner.VariableAssigner(assignment, context)[source]¶

Bases: object

assign(return_value)[source]¶

robot.variables.assigner.ReturnValueResolver(assignment)[source]¶

class robot.variables.assigner.NoReturnValueResolver[source]¶

Bases: object

resolve(return_value)[source]¶

class robot.variables.assigner.OneReturnValueResolver(variable)[source]¶

Bases: object

resolve(return_value)[source]¶

class robot.variables.assigner.ScalarsOnlyReturnValueResolver(variables)[source]¶

Bases: robot.variables.assigner._MultiReturnValueResolver

resolve(return_value)¶

class robot.variables.assigner.ScalarsAndListReturnValueResolver(variables)[source]¶

Bases: robot.variables.assigner._MultiReturnValueResolver

resolve(return_value)¶

robot.variables.evaluation module¶

robot.variables.evaluation.evaluate_expression(expression, variable_store, modules=None, namespace=None)[source]¶

class robot.variables.evaluation.EvaluationNamespace(variable_store, namespace)[source]¶

Bases: _abcoll.MutableMapping

clear() → None. Remove all items from D.¶

get(k[, d]) → D[k] if k in D, else d. d defaults to None.¶

items() → list of D's (key, value) pairs, as 2-tuples¶

iteritems() → an iterator over the (key, value) items of D¶

iterkeys() → an iterator over the keys of D¶

itervalues() → an iterator over the values of D¶

keys() → list of D's keys¶

pop(k[, d]) → v, remove specified key and return the corresponding value.¶: If key is not found, d is returned if given, otherwise KeyError is raised.

popitem() → (k, v), remove and return some (key, value) pair¶: as a 2-tuple; but raise KeyError if D is empty.

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D¶

update([E, ]**F) → None. Update D from mapping/iterable E and F.¶: If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

values() → list of D's values¶

robot.variables.filesetter module¶

class robot.variables.filesetter.VariableFileSetter(store)[source]¶

Bases: object

set(path_or_variables, args=None, overwrite=False)[source]¶

class robot.variables.filesetter.YamlImporter[source]¶

Bases: object

import_variables(path, args=None)[source]¶

class robot.variables.filesetter.PythonImporter[source]¶

Bases: object

import_variables(path, args=None)[source]¶

robot.variables.finders module¶

robot.variables.finders.get_java_property(name)¶

robot.variables.finders.get_java_properties()¶

class robot.variables.finders.VariableFinder(variable_store)[source]¶

Bases: object

find(variable)[source]¶

class robot.variables.finders.StoredFinder(store)[source]¶

Bases: object

identifiers = '$@&'¶

find(name)[source]¶

class robot.variables.finders.NumberFinder[source]¶

Bases: object

identifiers = '$'¶

find(name)[source]¶

class robot.variables.finders.EmptyFinder[source]¶

Bases: object

identifiers = '$@&'¶

empty = <robot.utils.normalizing.NormalizedDict object>¶

find(name)[source]¶

class robot.variables.finders.InlinePythonFinder(variables)[source]¶

Bases: object

identifiers = '$@&'¶

find(name)[source]¶

class robot.variables.finders.ExtendedFinder(finder)[source]¶

Bases: object

identifiers = '$@&'¶

find(name)[source]¶

class robot.variables.finders.EnvironmentFinder[source]¶

Bases: object

identifiers = '%'¶

find(name)[source]¶

robot.variables.notfound module¶

robot.variables.notfound.variable_not_found(name, candidates, message=None, deco_braces=True)[source]¶

Raise DataError for missing variable name.

Return recommendations for similar variable names if any are found.

robot.variables.replacer module¶

class robot.variables.replacer.VariableReplacer(variable_store)[source]¶

Bases: object

replace_list(items, replace_until=None, ignore_errors=False)[source]¶

Replaces variables from a list of items.

If an item in a list is a @{list} variable its value is returned. Possible variables from other items are replaced using ‘replace_scalar’. Result is always a list.

‘replace_until’ can be used to limit replacing arguments to certain index from the beginning. Used with Run Keyword variants that only want to resolve some of the arguments in the beginning and pass others to called keywords unmodified.

replace_scalar(item, ignore_errors=False)[source]¶

Replaces variables from a scalar item.

If the item is not a string it is returned as is. If it is a variable, its value is returned. Otherwise possible variables are replaced with ‘replace_string’. Result may be any object.

replace_string(item, custom_unescaper=None, ignore_errors=False)[source]¶

Replaces variables from a string. Result is always a string.

Input can also be an already found VariableMatch.

robot.variables.scopes module¶

class robot.variables.scopes.VariableScopes(settings)[source]¶

Bases: object

current¶

start_suite()[source]¶

end_suite()[source]¶

start_test()[source]¶

end_test()[source]¶

start_keyword()[source]¶

end_keyword()[source]¶

replace_list(items, replace_until=None, ignore_errors=False)[source]¶

replace_scalar(items, ignore_errors=False)[source]¶

replace_string(string, custom_unescaper=None, ignore_errors=False)[source]¶

set_from_file(path, args, overwrite=False)[source]¶

set_from_variable_table(variables, overwrite=False)[source]¶

resolve_delayed()[source]¶

set_global(name, value)[source]¶

set_suite(name, value, top=False, children=False)[source]¶

set_test(name, value)[source]¶

set_keyword(name, value)[source]¶

set_local_variable(name, value)[source]¶

as_dict(decoration=True)[source]¶

class robot.variables.scopes.GlobalVariables(settings)[source]¶

Bases: robot.variables.variables.Variables

as_dict(decoration=True)¶

clear()¶

copy()¶

replace_list(items, replace_until=None, ignore_errors=False)¶

replace_scalar(item, ignore_errors=False)¶

replace_string(item, custom_unescaper=None, ignore_errors=False)¶

resolve_delayed()¶

set_from_file(path_or_variables, args=None, overwrite=False)¶

set_from_variable_table(variables, overwrite=False)¶

update(variables)¶

class robot.variables.scopes.SetVariables[source]¶

Bases: object

start_suite()[source]¶

end_suite()[source]¶

start_test()[source]¶

end_test()[source]¶

start_keyword()[source]¶

end_keyword()[source]¶

set_global(name, value)[source]¶

set_suite(name, value)[source]¶

set_test(name, value)[source]¶

set_keyword(name, value)[source]¶

update(variables)[source]¶

robot.variables.search module¶

robot.variables.search.search_variable(string, identifiers='$@&%*', ignore_errors=False)[source]¶

robot.variables.search.contains_variable(string, identifiers='$@&')[source]¶

robot.variables.search.is_variable(string, identifiers='$@&')[source]¶

robot.variables.search.is_scalar_variable(string)[source]¶

robot.variables.search.is_list_variable(string)[source]¶

robot.variables.search.is_dict_variable(string)[source]¶

robot.variables.search.is_assign(string, identifiers='$@&', allow_assign_mark=False)[source]¶

robot.variables.search.is_scalar_assign(string, allow_assign_mark=False)[source]¶

robot.variables.search.is_list_assign(string, allow_assign_mark=False)[source]¶

robot.variables.search.is_dict_assign(string, allow_assign_mark=False)[source]¶

class robot.variables.search.VariableMatch(string, identifier=None, base=None, items=(), start=-1, end=-1)[source]¶

Bases: object

resolve_base(variables, ignore_errors=False)[source]¶

name¶

before¶

match¶

after¶

is_variable()[source]¶

is_scalar_variable()[source]¶

is_list_variable()[source]¶

is_dict_variable()[source]¶

is_assign(allow_assign_mark=False)[source]¶

is_scalar_assign(allow_assign_mark=False)[source]¶

is_list_assign(allow_assign_mark=False)[source]¶

is_dict_assign(allow_assign_mark=False)[source]¶

class robot.variables.search.VariableSearcher(identifiers, ignore_errors=False)[source]¶

Bases: object

search(string)[source]¶

variable_state(char)[source]¶

waiting_item_state(char)[source]¶

item_state(char)[source]¶

robot.variables.search.unescape_variable_syntax(item)[source]¶

class robot.variables.search.VariableIterator(string, identifiers='$@&%', ignore_errors=False)[source]¶: Bases: object

robot.variables.store module¶

class robot.variables.store.VariableStore(variables)[source]¶

Bases: object

resolve_delayed(item=None)[source]¶

get(name, default=<object object>, decorated=True)[source]¶

update(store)[source]¶

clear()[source]¶

add(name, value, overwrite=True, decorated=True)[source]¶

as_dict(decoration=True)[source]¶

robot.variables.tablesetter module¶

class robot.variables.tablesetter.VariableTableSetter(store)[source]¶

Bases: object

set(variables, overwrite=False)[source]¶

robot.variables.tablesetter.VariableTableValue(value, name, error_reporter=None)[source]¶

class robot.variables.tablesetter.VariableTableValueBase(values, error_reporter=None)[source]¶

Bases: object

resolve(variables)[source]¶

report_error(error)[source]¶

class robot.variables.tablesetter.ScalarVariableTableValue(values, error_reporter=None)[source]¶

Bases: robot.variables.tablesetter.VariableTableValueBase

report_error(error)¶

resolve(variables)¶

class robot.variables.tablesetter.ListVariableTableValue(values, error_reporter=None)[source]¶

Bases: robot.variables.tablesetter.VariableTableValueBase

report_error(error)¶

resolve(variables)¶

class robot.variables.tablesetter.DictVariableTableValue(values, error_reporter=None)[source]¶

Bases: robot.variables.tablesetter.VariableTableValueBase

report_error(error)¶

resolve(variables)¶

robot.variables.variables module¶

class robot.variables.variables.Variables[source]¶

Bases: object

Represents a set of variables.

Contains methods for replacing variables from list, scalars, and strings. On top of ${scalar}, @{list} and &{dict} variables, these methods handle also %{environment} variables.

resolve_delayed()[source]¶

replace_list(items, replace_until=None, ignore_errors=False)[source]¶

replace_scalar(item, ignore_errors=False)[source]¶

replace_string(item, custom_unescaper=None, ignore_errors=False)[source]¶

set_from_file(path_or_variables, args=None, overwrite=False)[source]¶

set_from_variable_table(variables, overwrite=False)[source]¶

clear()[source]¶

copy()[source]¶

update(variables)[source]¶

as_dict(decoration=True)[source]¶

Submodules¶

robot.errors module¶

Exceptions and return codes used internally.

External libraries should not used exceptions defined here.

exception robot.errors.RobotError(message='', details='')[source]¶

Bases: exceptions.Exception

Base class for Robot Framework errors.

Do not raise this method but use more specific errors instead.

message¶

args¶

exception robot.errors.FrameworkError(message='', details='')[source]¶

Bases: robot.errors.RobotError

Can be used when the core framework goes to unexpected state.

It is good to explicitly raise a FrameworkError if some framework component is used incorrectly. This is pretty much same as ‘Internal Error’ and should of course never happen.

args¶

message¶

exception robot.errors.DataError(message='', details='')[source]¶

Bases: robot.errors.RobotError

Used when the provided test data is invalid.

DataErrors are not caught by keywords that run other keywords (e.g. Run Keyword And Expect Error).

args¶

message¶

exception robot.errors.VariableError(message='', details='')[source]¶

Bases: robot.errors.DataError

Used when variable does not exist.

VariableErrors are caught by keywords that run other keywords (e.g. Run Keyword And Expect Error).

args¶

message¶

exception robot.errors.KeywordError(message='', details='')[source]¶

Bases: robot.errors.DataError

Used when no keyword is found or there is more than one match.

KeywordErrors are caught by keywords that run other keywords (e.g. Run Keyword And Expect Error).

args¶

message¶

exception robot.errors.TimeoutError(message='', test_timeout=True)[source]¶

Bases: robot.errors.RobotError

Used when a test or keyword timeout occurs.

This exception is handled specially so that execution of the current test is always stopped immediately and it is not caught by keywords executing other keywords (e.g. Run Keyword And Expect Error).

keyword_timeout¶

args¶

message¶

exception robot.errors.Information(message='', details='')[source]¶

Bases: robot.errors.RobotError

Used by argument parser with –help or –version.

args¶

message¶

exception robot.errors.ExecutionStatus(message, test_timeout=False, keyword_timeout=False, syntax=False, exit=False, continue_on_failure=False, skip=False, return_value=None)[source]¶

Bases: robot.errors.RobotError

Base class for exceptions communicating status in test execution.

timeout¶

dont_continue¶

continue_on_failure¶

can_continue(context, templated=False)[source]¶

get_errors()[source]¶

status¶

args¶

message¶

exception robot.errors.ExecutionFailed(message, test_timeout=False, keyword_timeout=False, syntax=False, exit=False, continue_on_failure=False, skip=False, return_value=None)[source]¶

Bases: robot.errors.ExecutionStatus

Used for communicating failures in test execution.

args¶

can_continue(context, templated=False)¶

continue_on_failure¶

dont_continue¶

get_errors()¶

message¶

status¶

timeout¶

exception robot.errors.HandlerExecutionFailed(details)[source]¶

Bases: robot.errors.ExecutionFailed

args¶

can_continue(context, templated=False)¶

continue_on_failure¶

dont_continue¶

get_errors()¶

message¶

status¶

timeout¶

exception robot.errors.ExecutionFailures(errors, message=None)[source]¶

Bases: robot.errors.ExecutionFailed

get_errors()[source]¶

args¶

can_continue(context, templated=False)¶

continue_on_failure¶

dont_continue¶

message¶

status¶

timeout¶

exception robot.errors.UserKeywordExecutionFailed(run_errors=None, teardown_errors=None)[source]¶

Bases: robot.errors.ExecutionFailures

args¶

can_continue(context, templated=False)¶

continue_on_failure¶

dont_continue¶

get_errors()¶

message¶

status¶

timeout¶

exception robot.errors.ExecutionPassed(message=None, **kwargs)[source]¶

Bases: robot.errors.ExecutionStatus

Base class for all exceptions communicating that execution passed.

Should not be raised directly, but more detailed exceptions used instead.

set_earlier_failures(failures)[source]¶

earlier_failures¶

status¶

args¶

can_continue(context, templated=False)¶

continue_on_failure¶

dont_continue¶

get_errors()¶

message¶

timeout¶

exception robot.errors.PassExecution(message)[source]¶

Bases: robot.errors.ExecutionPassed

Used by ‘Pass Execution’ keyword.

args¶

can_continue(context, templated=False)¶

continue_on_failure¶

dont_continue¶

earlier_failures¶

get_errors()¶

message¶

set_earlier_failures(failures)¶

status¶

timeout¶

exception robot.errors.ContinueForLoop(message=None, **kwargs)[source]¶

Bases: robot.errors.ExecutionPassed

Used by ‘Continue For Loop’ keyword.

args¶

can_continue(context, templated=False)¶

continue_on_failure¶

dont_continue¶

earlier_failures¶

get_errors()¶

message¶

set_earlier_failures(failures)¶

status¶

timeout¶

exception robot.errors.ExitForLoop(message=None, **kwargs)[source]¶

Bases: robot.errors.ExecutionPassed

Used by ‘Exit For Loop’ keyword.

args¶

can_continue(context, templated=False)¶

continue_on_failure¶

dont_continue¶

earlier_failures¶

get_errors()¶

message¶

set_earlier_failures(failures)¶

status¶

timeout¶

exception robot.errors.ReturnFromKeyword(return_value=None, failures=None)[source]¶

Bases: robot.errors.ExecutionPassed

Used by ‘Return From Keyword’ keyword.

args¶

can_continue(context, templated=False)¶

continue_on_failure¶

dont_continue¶

earlier_failures¶

get_errors()¶

message¶

set_earlier_failures(failures)¶

status¶

timeout¶

exception robot.errors.RemoteError(message='', details='', fatal=False, continuable=False)[source]¶

Bases: robot.errors.RobotError

Used by Remote library to report remote errors.

args¶

message¶

robot.jarrunner module¶

robot.libdoc module¶

Module implementing the command line entry point for the Libdoc tool.

This module can be executed from the command line using the following approaches:

python -m robot.libdoc
python path/to/robot/libdoc.py

Instead of python it is possible to use also other Python interpreters.

This module also provides libdoc() and libdoc_cli() functions that can be used programmatically. Other code is for internal usage.

Libdoc itself is implemented in the libdocpkg package.

class robot.libdoc.LibDoc[source]¶

Bases: robot.utils.application.Application

validate(options, arguments)[source]¶

main(args, name='', version='', format=None, docformat=None, specdocformat=None, quiet=False)[source]¶

console(msg)¶

execute(*arguments, **options)¶

execute_cli(cli_arguments, exit=True)¶

parse_arguments(cli_args)¶

Public interface for parsing command line arguments.

Parameters:	cli_args – Command line arguments as a list
Returns:	options (dict), arguments (list)
Raises:	`Information` when –help or –version used
Raises:	`DataError` when parsing fails

robot.libdoc.libdoc_cli(arguments=None, exit=True)[source]¶

Executes Libdoc similarly as from the command line.

Parameters:	arguments – Command line options and arguments as a list of strings. Starting from RF 4.0, defaults to `sys.argv[1:]` if not given. exit – If `True`, call `sys.exit` automatically. New in RF 4.0.

The libdoc() function may work better in programmatic usage.

Example:

from robot.libdoc import libdoc_cli

libdoc_cli(['--version', '1.0', 'MyLibrary.py', 'MyLibrary.html'])

robot.libdoc.libdoc(library_or_resource, outfile, name='', version='', format=None, docformat=None, specdocformat=None, quiet=False)[source]¶

Executes Libdoc.

Parameters:

library_or_resource – Name or path of the library or resource file to be documented.
outfile – Path path to the file where to write outputs.
name – Custom name to give to the documented library or resource.
version – Version to give to the documented library or resource.
format – Specifies whether to generate HTML, XML or JSON output. If this options is not used, the format is got from the extension of the output file. Possible values are 'HTML', 'XML', 'JSON' and 'LIBSPEC'.
docformat – Documentation source format. Possible values are 'ROBOT', 'reST', 'HTML' and 'TEXT'. The default value can be specified in library source code and the initial default is 'ROBOT'.
specdocformat – Specifies whether the keyword documentation in spec files is converted to HTML regardless of the original documentation format. Possible values are 'HTML' (convert to HTML) and 'RAW' (use original format). The default depends on the output format. New in Robot Framework 4.0.
quiet – When true, the path of the generated output file is not printed the console. New in Robot Framework 4.0.

Arguments have same semantics as Libdoc command line options with same names. Run libdoc --help or consult the Libdoc section in the Robot Framework User Guide for more details.

Example:

from robot.libdoc import libdoc

libdoc('MyLibrary.py', 'MyLibrary.html', version='1.0')

robot.pythonpathsetter module¶

Module that adds directories needed by Robot to sys.path when imported.

robot.pythonpathsetter.add_path(path, end=False)[source]¶

robot.pythonpathsetter.remove_path(path)[source]¶

robot.rebot module¶

Module implementing the command line entry point for post-processing outputs.

This module can be executed from the command line using the following approaches:

python -m robot.rebot
python path/to/robot/rebot.py

Instead of python it is possible to use also other Python interpreters. This module is also used by the installed rebot start-up script.

This module also provides rebot() and rebot_cli() functions that can be used programmatically. Other code is for internal usage.

class robot.rebot.Rebot[source]¶

Bases: robot.run.RobotFramework

main(datasources, **options)[source]¶

console(msg)¶

execute(*arguments, **options)¶

execute_cli(cli_arguments, exit=True)¶

parse_arguments(cli_args)¶

Public interface for parsing command line arguments.

Parameters:	cli_args – Command line arguments as a list
Returns:	options (dict), arguments (list)
Raises:	`Information` when –help or –version used
Raises:	`DataError` when parsing fails

validate(options, arguments)¶

robot.rebot.rebot_cli(arguments=None, exit=True)[source]¶

Command line execution entry point for post-processing outputs.

Parameters:	arguments – Command line options and arguments as a list of strings. Starting from RF 3.1, defaults to `sys.argv[1:]` if not given. exit – If `True`, call `sys.exit` with the return code denoting execution status, otherwise just return the rc.

Entry point used when post-processing outputs from the command line, but can also be used by custom scripts. Especially useful if the script itself needs to accept same arguments as accepted by Rebot, because the script can just pass them forward directly along with the possible default values it sets itself.

Example:

from robot import rebot_cli

rebot_cli(['--name', 'Example', '--log', 'NONE', 'o1.xml', 'o2.xml'])

See also the rebot() function that allows setting options as keyword arguments like name="Example" and generally has a richer API for programmatic Rebot execution.

robot.rebot.rebot(*outputs, **options)[source]¶

Programmatic entry point for post-processing outputs.

Parameters:	outputs – Paths to Robot Framework output files similarly as when running the `rebot` command on the command line. options – Options to configure processing outputs. Accepted options are mostly same as normal command line options to the `rebot` command. Option names match command line option long names without hyphens so that, for example, `--name` becomes `name`.

The semantics related to passing options are exactly the same as with the run() function. See its documentation for more details.

Examples:

from robot import rebot

rebot('path/to/output.xml')
with open('stdout.txt', 'w') as stdout:
    rebot('o1.xml', 'o2.xml', name='Example', log=None, stdout=stdout)

Equivalent command line usage:

rebot path/to/output.xml
rebot --name Example --log NONE o1.xml o2.xml > stdout.txt

robot.run module¶

Module implementing the command line entry point for executing tests.

This module can be executed from the command line using the following approaches:

python -m robot.run
python path/to/robot/run.py

Instead of python it is possible to use also other Python interpreters. This module is also used by the installed robot start-up script.

This module also provides run() and run_cli() functions that can be used programmatically. Other code is for internal usage.

class robot.run.RobotFramework[source]¶

Bases: robot.utils.application.Application

main(datasources, **options)[source]¶

validate(options, arguments)[source]¶

console(msg)¶

execute(*arguments, **options)¶

execute_cli(cli_arguments, exit=True)¶

parse_arguments(cli_args)¶

Public interface for parsing command line arguments.

Parameters:	cli_args – Command line arguments as a list
Returns:	options (dict), arguments (list)
Raises:	`Information` when –help or –version used
Raises:	`DataError` when parsing fails

robot.run.run_cli(arguments=None, exit=True)[source]¶

Command line execution entry point for running tests.

Parameters:	arguments – Command line options and arguments as a list of strings. Starting from RF 3.1, defaults to `sys.argv[1:]` if not given. exit – If `True`, call `sys.exit` with the return code denoting execution status, otherwise just return the rc.

Entry point used when running tests from the command line, but can also be used by custom scripts that execute tests. Especially useful if the script itself needs to accept same arguments as accepted by Robot Framework, because the script can just pass them forward directly along with the possible default values it sets itself.

Example:

from robot import run_cli

# Run tests and return the return code.
rc = run_cli(['--name', 'Example', 'tests.robot'], exit=False)

# Run tests and exit to the system automatically.
run_cli(['--name', 'Example', 'tests.robot'])

See also the run() function that allows setting options as keyword arguments like name="Example" and generally has a richer API for programmatic test execution.

robot.run.run(*tests, **options)[source]¶

Programmatic entry point for running tests.

Parameters:	tests – Paths to test case files/directories to be executed similarly as when running the `robot` command on the command line. options – Options to configure and control execution. Accepted options are mostly same as normal command line options to the `robot` command. Option names match command line option long names without hyphens so that, for example, `--name` becomes `name`.

Most options that can be given from the command line work. An exception is that options --pythonpath, --argumentfile, --help and --version are not supported.

Options that can be given on the command line multiple times can be passed as lists. For example, include=['tag1', 'tag2'] is equivalent to --include tag1 --include tag2. If such options are used only once, they can be given also as a single string like include='tag'.

Options that accept no value can be given as Booleans. For example, dryrun=True is same as using the --dryrun option.

Options that accept string NONE as a special value can also be used with Python None. For example, using log=None is equivalent to --log NONE.

listener, prerunmodifier and prerebotmodifier options allow passing values as Python objects in addition to module names these command line options support. For example, run('tests', listener=MyListener()).

To capture the standard output and error streams, pass an open file or file-like object as special keyword arguments stdout and stderr, respectively.

A return code is returned similarly as when running on the command line. Zero means that tests were executed and no critical test failed, values up to 250 denote the number of failed critical tests, and values between 251-255 are for other statuses documented in the Robot Framework User Guide.

Example:

from robot import run

run('path/to/tests.robot')
run('tests.robot', include=['tag1', 'tag2'], splitlog=True)
with open('stdout.txt', 'w') as stdout:
    run('t1.robot', 't2.robot', name='Example', log=None, stdout=stdout)

Equivalent command line usage:

robot path/to/tests.robot
robot --include tag1 --include tag2 --splitlog tests.robot
robot --name Example --log NONE t1.robot t2.robot > stdout.txt

robot.testdoc module¶

Module implementing the command line entry point for the Testdoc tool.

This module can be executed from the command line using the following approaches:

python -m robot.testdoc
python path/to/robot/testdoc.py

Instead of python it is possible to use also other Python interpreters.

This module also provides testdoc() and testdoc_cli() functions that can be used programmatically. Other code is for internal usage.

class robot.testdoc.TestDoc[source]¶

Bases: robot.utils.application.Application

main(datasources, title=None, **options)[source]¶

console(msg)¶

execute(*arguments, **options)¶

execute_cli(cli_arguments, exit=True)¶

parse_arguments(cli_args)¶

Public interface for parsing command line arguments.

Parameters:	cli_args – Command line arguments as a list
Returns:	options (dict), arguments (list)
Raises:	`Information` when –help or –version used
Raises:	`DataError` when parsing fails

validate(options, arguments)¶

robot.testdoc.TestSuiteFactory(datasources, **options)[source]¶

class robot.testdoc.TestdocModelWriter(output, suite, title=None)[source]¶

Bases: robot.htmldata.htmlfilewriter.ModelWriter

write(line)[source]¶

write_data()[source]¶

handles(line)¶

class robot.testdoc.JsonConverter(output_path=None)[source]¶

Bases: object

convert(suite)[source]¶

robot.testdoc.testdoc_cli(arguments)[source]¶

Executes Testdoc similarly as from the command line.

Parameters:	arguments – command line arguments as a list of strings.

For programmatic usage the testdoc() function is typically better. It has a better API for that and does not call sys.exit() like this function.

Example:

from robot.testdoc import testdoc_cli

testdoc_cli(['--title', 'Test Plan', 'mytests', 'plan.html'])

robot.testdoc.testdoc(*arguments, **options)[source]¶

Executes Testdoc programmatically.

Arguments and options have same semantics, and options have same names, as arguments and options to Testdoc.

Example:

from robot.testdoc import testdoc

testdoc('mytests', 'plan.html', title='Test Plan')

robot.tidy module¶

Module implementing the command line entry point for the Tidy tool.

This module can be executed from the command line using the following approaches:

python -m robot.tidy
python path/to/robot/tidy.py

Instead of python it is possible to use also other Python interpreters.

This module also provides Tidy class and tidy_cli() function that can be used programmatically. Other code is for internal usage.

class robot.tidy.Tidy(space_count=4, use_pipes=False, line_separator='n')[source]¶

Bases: robot.parsing.suitestructure.SuiteStructureVisitor

Programmatic API for the Tidy tool.

Arguments accepted when creating an instance have same semantics as Tidy command line options with same names.

file(path, outpath=None)[source]¶

Tidy a file.

Parameters:	path – Path of the input file. outpath – Path of the output file. If not given, output is returned.

Use inplace() to tidy files in-place.

inplace(*paths)[source]¶

Tidy file(s) in-place.

Parameters:	paths – Paths of the files to to process.

directory(path)[source]¶

Tidy a directory.

Parameters:	path – Path of the directory to process.

All files in a directory, recursively, are processed in-place.

visit_file(file)[source]¶

visit_directory(directory)[source]¶

end_directory(structure)¶

start_directory(structure)¶

class robot.tidy.TidyCommandLine[source]¶

Bases: robot.utils.application.Application

Command line interface for the Tidy tool.

Typically tidy_cli() is a better suited for command line style usage and Tidy for other programmatic usage.

main(arguments, recursive=False, inplace=False, usepipes=False, spacecount=4, lineseparator='\n')[source]¶

validate(opts, args)[source]¶

console(msg)¶

execute(*arguments, **options)¶

execute_cli(cli_arguments, exit=True)¶

parse_arguments(cli_args)¶

Public interface for parsing command line arguments.

Parameters:	cli_args – Command line arguments as a list
Returns:	options (dict), arguments (list)
Raises:	`Information` when –help or –version used
Raises:	`DataError` when parsing fails

class robot.tidy.ArgumentValidator[source]¶

Bases: object

mode_and_args(args, recursive, inplace, **others)[source]¶

line_sep(lineseparator, **others)[source]¶

spacecount(spacecount)[source]¶

robot.tidy.tidy_cli(arguments)[source]¶

Executes Tidy similarly as from the command line.

Parameters:	arguments – Command line arguments as a list of strings.

Example:

from robot.tidy import tidy_cli

tidy_cli(['--spacecount', '2', 'tests.robot'])

robot.version module¶

robot.version.get_version(naked=False)[source]¶

robot.version.get_full_version(program=None, naked=False)[source]¶

robot.version.get_interpreter()[source]¶