Robot Framework library for running processes.\n

The library has following main usages:\n

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

  This library provides various benefits over using Run and other similar keywords in the OperatingSystem library:\n

  \n
  • Better process configuration.\n
  • Convenient result object with all result information (rc, stdout, stderr).\n
  • Support for background processes, process termination, sending signals and so on.\n\n

    This library utilizes Python's subprocess module and its Popen class.\n

    Table of contents\n

    \n
    • Specifying command and arguments\n
    • Process configuration\n
    • Active process\n
    • Result object\n
    • Example\n
    • Keywords\n\n

      Specifying command and arguments\n

      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.\n

      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.\n

      Examples:\n

      \n\n\n\n

      Run Process\n	${tools}${/}prog.py\n	argument\n	second arg with spaces\n	\n	\n\n
      Run Process\n	java\n	-jar\n	${jars}${/}example.jar\n	--option\n	value\n\n
      Run Process\n	prog.py \"one arg\" && tool.sh\n	shell=yes\n	cwd=${tools}\n	\n	\n\n\n Possible non-string arguments are converted to strings automatically.\n Process configuration\n Run Process and Start Process keywords can be configured using optional configuration arguments. These arguments must be given after other arguments passed to these keywords and must use the name=value syntax. Available configuration arguments are listed below and discussed further in the subsequent sections.\n \n\n\n\n\n\n\n\n\n\n\n Name\n Explanation\n\n shell\n Specify whether to run the command in a shell or not.\n\n cwd\n Specify the working directory.\n\n env\n Specify environment variables given to the process.\n\n **env_extra\n Override named environment variables using env:<name>=<value> syntax.\n\n stdout\n Path to a file where to write standard output.\n\n stderr\n Path to a file where to write standard error.\n\n stdin\n Configure process standard input. New in RF 4.1.2.\n\n output_encoding\n Encoding to use when reading command outputs.\n\n alias\n A custom name given to the process.\n\n\n Note that 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.\n Running processes in shell\n 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.\n 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.\n 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.\n Current working directory\n By default, the child process will be executed in the same directory as the parent process, the process running Robot Framework, 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.\n Standard output and error streams, when redirected to files, are also relative to the current working directory possibly set using the cwd argument.\n Example:\n \n\n Run Process\n prog.exe\n cwd=${ROOT}/directory\n stdout=stdout.txt\n\n\n Environment variables\n The child process will get a copy of the parent process's environment variables by default. 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.\n Examples:\n \n\n\n\n Run Process\n program\n env=${environ}\n \n\n Run Process\n program\n env:http_proxy=10.144.1.10:8080\n env:PATH=%{PATH}${:}${PROGDIR}\n\n Run Process\n program\n env=${environ}\n env:EXTRA=value\n\n\n Standard output and error streams\n By default, processes are run so that their standard output and standard error streams are kept in the memory. This typically works fine, but there can be problems if the amount of output is large or unlimited. Prior to Robot Framework 7.3 the limit was smaller than nowadays and reaching it caused a deadlock.\n 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 output. This can also be useful if other processes or other keywords need to read or manipulate the output somehow.\n 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.\n 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.\n As a special feature, it is possible to redirect the standard error to the standard output by using stderr=STDOUT.\n If you are not interested in output at all, you can explicitly ignore it 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 even a huge amount of output cannot cause problems, but naturally the output is not available after execution either.\n Examples:\n \n\n\n\n\n\n ${result} =\n Run Process\n program\n stdout=${TEMPDIR}/stdout.txt\n stderr=${TEMPDIR}/stderr.txt\n\n Log Many\n stdout: ${result.stdout}\n stderr: ${result.stderr}\n \n \n\n ${result} =\n Run Process\n program\n stderr=STDOUT\n \n\n Log\n all output: ${result.stdout}\n \n \n \n\n ${result} =\n Run Process\n program\n stdout=DEVNULL\n stderr=DEVNULL\n\n\n Note that the created output files are not automatically removed after execution. The user is responsible to remove them if needed.\n Standard input stream\n 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.\n \n\n\n\n\n\n\n Value\n Explanation\n\n String NONE\n Inherit stdin from the parent process. This is the default.\n\n String PIPE\n Make stdin a pipe that can be written to.\n\n Path to a file\n Open the specified file and use it as the stdin.\n\n Any other string\n Create a temporary file with the text as its content and use it as the stdin.\n\n Any non-string value\n Used as-is. Could be a file descriptor, stdout of another process, etc.\n\n\n Values PIPE and NONE are case-insensitive and internally mapped to subprocess.PIPE and None, respectively, when calling subprocess.Popen.\n Examples:\n \n\n\n\n Run Process\n command\n stdin=PIPE\n\n Run Process\n command\n stdin=${CURDIR}/stdin.txt\n\n Run Process\n command\n stdin=Stdin as text.\n\n\n The support to configure stdin is new in Robot Framework 4.1.2. Its default value used to be PIPE until Robot Framework 7.0.\n Output encoding\n 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.\n 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.\n Examples:\n \n\n\n Start Process\n program\n output_encoding=UTF-8\n \n\n Run Process\n program\n stdout=${path}\n output_encoding=SYSTEM\n\n\n Alias\n A custom name given to the process that can be used when selecting the active process.\n Examples:\n \n\n\n Start Process\n program\n alias=example\n \n \n\n Run Process\n python\n -c\n print('hello')\n alias=hello\n\n\n Active process\n The library keeps record which of the started processes is currently active. By default, it is the latest process started with Start Process, but Switch Process can be used to activate a different process. Using Run Process does not affect the active process.\n 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 an alias explicitly given to Start Process or the process object returned by it.\n Result object\n 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.\n \n\n\n\n\n\n\n Attribute\n Explanation\n\n rc\n Return code of the process as an integer.\n\n stdout\n Contents of the standard output stream.\n\n stderr\n Contents of the standard error stream.\n\n stdout_path\n Path where stdout was redirected or None if not redirected.\n\n stderr_path\n Path where stderr was redirected or None if not redirected.\n\n\n Example:\n \n\n\n\n\n\n\n\n ${result} =\n Run Process\n program\n \n\n Should Be Equal \n ${result.rc}\n 0\n type=int\n\n Should Match\n ${result.stdout}\n Some t?xt*\n \n\n Should Be Empty\n ${result.stderr}\n \n \n\n ${stdout} =\n Get File\n ${result.stdout_path}\n \n\n Should Be Equal\n ${stdout}\n ${result.stdout}\n \n\n File Should Be Empty\n ${result.stderr_path}\n \n \n\n\n Notice that in stdout and stderr content possible trailing newline is removed and \\r\\n converted to \\n automatically. If you need to see the original process output, redirect it to a file using process configuration and read it from there.\n Example\n \n*** Settings ***\nLibrary Process\nSuite Teardown Terminate All Processes kill=True\n\n*** Test Cases ***\nExample\n Start Process program arg1 arg2 alias=First\n ${handle} = Start Process command.sh arg | command2.sh shell=True cwd=/path\n ${result} = Run Process ${CURDIR}/script.py\n Should Not Contain ${result.stdout} FAIL\n Terminate Process ${handle}\n ${result} = Wait For Process First\n Should Be Equal As Integers ${result.rc} 0\n", "version": "7.4.2", "generated": "2026-03-03T16:39:18+00:00", "type": "LIBRARY", "scope": "GLOBAL", "docFormat": "HTML", "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 349, "tags": [], "inits": [], "keywords": [{"name": "Get Process Id", "args": [{"name": "handle", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "handle: Popen | str | None = None"}], "returnType": {"name": "int", "typedoc": "integer", "nested": [], "union": false}, "doc": " Returns the process ID (pid) of the process as an integer.\n If handle is not given, uses the current active process.\n Starting from Robot Framework 5.0, it is also possible to directly access the pid attribute of the subprocess.Popen object returned by Start Process like ${process.pid}.", "shortdoc": "Returns the process ID (pid) of the process as an integer.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 1071}, {"name": "Get Process Object", "args": [{"name": "handle", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "handle: Popen | str | None = None"}], "returnType": {"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, "doc": " Return the underlying subprocess.Popen object.\n If handle is not given, uses the current active process.\n Starting from Robot Framework 5.0, Start Process returns the created subprocess.Popen object, not a generic handle, making this keyword mostly redundant.", "shortdoc": "Return the underlying ``subprocess.Popen`` object.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 1082}, {"name": "Get Process Result", "args": [{"name": "handle", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "handle: Popen | str | None = None"}, {"name": "rc", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "rc: bool = False"}, {"name": "stdout", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "stdout: bool = False"}, {"name": "stderr", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "stderr: bool = False"}, {"name": "stdout_path", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "stdout_path: bool = False"}, {"name": "stderr_path", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "stderr_path: bool = False"}], "returnType": {"name": "Union", "typedoc": null, "nested": [{"name": "ProcessResult", "typedoc": null, "nested": [], "union": false}, {"name": "int", "typedoc": "integer", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "tuple", "typedoc": "tuple", "nested": [{"name": "Union", "typedoc": null, "nested": [{"name": "int", "typedoc": "integer", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}], "union": true}, {"name": "...", "typedoc": null, "nested": [], "union": false}], "union": false}], "union": true}, "doc": " Returns the specified result object or some of its attributes.\n 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.\n 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.\n Examples:\n \n\n\n\n\n\n\n\n\n\n\n\n\n\n Run Process\n python\n -c\n print('Hello, world!')\n alias=myproc\n \n\n # Get result object\n \n \n \n \n \n\n ${result} =\n Get Process Result\n myproc\n \n \n \n\n Should Be Equal\n ${result.rc}\n ${0}\n \n \n \n\n Should Be Equal\n ${result.stdout}\n Hello, world!\n \n \n \n\n Should Be Empty\n ${result.stderr}\n \n \n \n \n\n # Get one attribute\n \n \n \n \n \n\n ${stdout} =\n Get Process Result\n myproc\n stdout=true\n \n \n\n Should Be Equal\n ${stdout}\n Hello, world!\n \n \n \n\n # Multiple attributes\n \n \n \n \n \n\n ${stdout}\n ${stderr} =\n Get Process Result\n myproc\n stdout=yes\n stderr=yes\n\n Should Be Equal\n ${stdout}\n Hello, world!\n \n \n \n\n Should Be Empty\n ${stderr}\n \n \n \n \n\n\n 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.", "shortdoc": "Returns the specified `result object` or some of its attributes.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 1093}, {"name": "Is Process Running", "args": [{"name": "handle", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "handle: Popen | str | None = None"}], "returnType": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "doc": " Checks is the process running or not.\n If handle is not given, uses the current active process.\n Returns True if the process is still running and False otherwise.", "shortdoc": "Checks is the process running or not.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 790}, {"name": "Join Command Line", "args": [{"name": "command", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Sequence", "typedoc": "Sequence", "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}], "union": true}, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*command: Sequence[str] | str"}], "returnType": {"name": "str", "typedoc": "string", "nested": [], "union": false}, "doc": " Joins arguments into one command line string.\n 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.\n Command to join can be given as individual arguments or as a list.\n Giving command as individual arguments:\n \n\n\n ${cmd} =\n Join Command Line\n --option\n value with spaces\n\n Should Be Equal\n ${cmd}\n --option \"value with spaces\"\n \n\n\n Giving command as a list:\n \n\n\n\n VAR\n @{arguments}\n --option\n value with spaces\n\n ${cmd} =\n Join Command Line\n ${arguments}\n \n\n Should Be Equal\n ${cmd}\n --option \"value with spaces\"\n \n\n", "shortdoc": "Joins arguments into one command line string.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 1202}, {"name": "Process Should Be Running", "args": [{"name": "handle", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "handle: Popen | str | None = None"}, {"name": "error_message", "type": {"name": "str", "typedoc": "string", "nested": [], "union": false}, "defaultValue": "Process is not running.", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "error_message: str = Process is not running."}], "returnType": null, "doc": " Verifies that the process is running.\n If handle is not given, uses the current active process.\n Fails if the process has stopped.", "shortdoc": "Verifies that the process is running.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 799}, {"name": "Process Should Be Stopped", "args": [{"name": "handle", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "handle: Popen | str | None = None"}, {"name": "error_message", "type": {"name": "str", "typedoc": "string", "nested": [], "union": false}, "defaultValue": "Process is running.", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "error_message: str = Process is running."}], "returnType": null, "doc": " Verifies that the process is not running.\n If handle is not given, uses the current active process.\n Fails if the process is still running.", "shortdoc": "Verifies that the process is not running.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 813}, {"name": "Run Process", "args": [{"name": "command", "type": {"name": "str", "typedoc": "string", "nested": [], "union": false}, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "command: str"}, {"name": "arguments", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "Secret", "typedoc": "Secret", "nested": [], "union": false}], "union": true}, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*arguments: str | Secret"}, {"name": "cwd", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "cwd: str | None = None"}, {"name": "shell", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "NAMED_ONLY", "required": false, "repr": "shell: bool = False"}, {"name": "stdout", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "stdout: str | None = None"}, {"name": "stderr", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "stderr: str | None = None"}, {"name": "stdin", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "Secret", "typedoc": "Secret", "nested": [], "union": false}, {"name": "Path", "typedoc": "Path", "nested": [], "union": false}, {"name": "int", "typedoc": "integer", "nested": [], "union": false}, {"name": "IOBase", "typedoc": null, "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "stdin: str | Secret | Path | int | IOBase | None = None"}, {"name": "output_encoding", "type": {"name": "str", "typedoc": "string", "nested": [], "union": false}, "defaultValue": "CONSOLE", "kind": "NAMED_ONLY", "required": false, "repr": "output_encoding: str = CONSOLE"}, {"name": "alias", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "alias: str | None = None"}, {"name": "timeout", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "timedelta", "typedoc": "timedelta", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "timeout: timedelta | None = None"}, {"name": "on_timeout", "type": {"name": "Literal", "typedoc": "Literal", "nested": [{"name": "'continue'", "typedoc": null, "nested": [], "union": false}, {"name": "'terminate'", "typedoc": null, "nested": [], "union": false}, {"name": "'kill'", "typedoc": null, "nested": [], "union": false}], "union": false}, "defaultValue": "terminate", "kind": "NAMED_ONLY", "required": false, "repr": "on_timeout: Literal['continue', 'terminate', 'kill'] = terminate"}, {"name": "env", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "dict", "typedoc": "dictionary", "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "Secret", "typedoc": "Secret", "nested": [], "union": false}], "union": true}], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "env: dict[str, str | Secret] | None = None"}, {"name": "env_extra", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "Secret", "typedoc": "Secret", "nested": [], "union": false}], "union": true}, "defaultValue": null, "kind": "VAR_NAMED", "required": false, "repr": "**env_extra: str | Secret"}], "returnType": {"name": "ProcessResult", "typedoc": "ProcessResult", "nested": [], "union": false}, "doc": " Runs a process and waits for it to complete.\n command and arguments specify the command to execute and arguments passed to it. See Specifying command and arguments for more details.\n The started process can be configured using cwd, shell, stdout, stderr, stdin, output_encoding, alias, env and env_extra parameters that are documented in the Process configuration section.\n Configuration related to waiting for processes consists of timeout and on_timeout parameters that have same semantics than with the Wait For Process keyword.\n Process outputs are, by default, written into in-memory buffers. This typically works fine, but there can be problems if the amount of output is large or unlimited. To avoid such problems, outputs can be redirected to files using the stdout and stderr configuration parameters. For more information see the Standard output and error streams section.\n Returns a result object containing information about the execution.\n Note that possible equal signs in command and arguments must be escaped with a backslash (e.g. name\\=value).\n Examples:\n \n\n\n\n\n\n ${result} =\n Run Process\n python\n -c\n print('Hello, world!')\n\n Should Be Equal\n ${result.stdout}\n Hello, world!\n \n \n\n ${result} =\n Run Process\n ${command}\n stdout=${CURDIR}/stdout.txt\n stderr=STDOUT\n\n ${result} =\n Run Process\n ${command}\n timeout=1min\n on_timeout=continue\n\n ${result} =\n Run Process\n java -Dname\\=value Example\n shell=True\n cwd=${EXAMPLE}\n\n\n This keyword does not change the active process.", "shortdoc": "Runs a process and waits for it to complete.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 636}, {"name": "Send Signal To Process", "args": [{"name": "signal", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "int", "typedoc": "integer", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}], "union": true}, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "signal: int | str"}, {"name": "handle", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "handle: Popen | str | None = None"}, {"name": "group", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "group: bool = False"}], "returnType": null, "doc": " Sends the given signal to the specified process.\n If handle is not given, uses the current active process.\n 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):\n \n\n\n\n Send Signal To Process\n 2\n \n # Send to active process\n\n Send Signal To Process\n INT\n \n \n\n Send Signal To Process\n SIGINT\n myproc\n # Send to named process\n\n\n 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).\n 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.\n To send the signal to the whole process group, give the group argument a true value.", "shortdoc": "Sends the given ``signal`` to the specified process.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 1011}, {"name": "Split Command Line", "args": [{"name": "command", "type": {"name": "str", "typedoc": "string", "nested": [], "union": false}, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "command: str"}, {"name": "escaping", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "escaping: bool = False"}], "returnType": {"name": "list", "typedoc": "list", "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}], "union": false}, "doc": " Splits command line string into a list of arguments.\n String is split from spaces, but argument surrounded in quotes may contain spaces in them.\n 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 doubling backslashes in Windows paths and elsewhere.\n Examples:\n \n\n\n @{cmd} =\n Split Command Line\n --option \"value with spaces\"\n\n Should Be True\n $cmd == ['--option', 'value with spaces']\n \n\n", "shortdoc": "Splits command line string into a list of arguments.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 1185}, {"name": "Start Process", "args": [{"name": "command", "type": {"name": "str", "typedoc": "string", "nested": [], "union": false}, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "command: str"}, {"name": "arguments", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "Secret", "typedoc": "Secret", "nested": [], "union": false}], "union": true}, "defaultValue": null, "kind": "VAR_POSITIONAL", "required": false, "repr": "*arguments: str | Secret"}, {"name": "cwd", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "cwd: str | None = None"}, {"name": "shell", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "NAMED_ONLY", "required": false, "repr": "shell: bool = False"}, {"name": "stdout", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "stdout: str | None = None"}, {"name": "stderr", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "stderr: str | None = None"}, {"name": "stdin", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "Secret", "typedoc": "Secret", "nested": [], "union": false}, {"name": "Path", "typedoc": "Path", "nested": [], "union": false}, {"name": "int", "typedoc": "integer", "nested": [], "union": false}, {"name": "IOBase", "typedoc": null, "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "stdin: str | Secret | Path | int | IOBase | None = None"}, {"name": "output_encoding", "type": {"name": "str", "typedoc": "string", "nested": [], "union": false}, "defaultValue": "CONSOLE", "kind": "NAMED_ONLY", "required": false, "repr": "output_encoding: str = CONSOLE"}, {"name": "alias", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "alias: str | None = None"}, {"name": "env", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "dict", "typedoc": "dictionary", "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "Secret", "typedoc": "Secret", "nested": [], "union": false}], "union": true}], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "NAMED_ONLY", "required": false, "repr": "env: dict[str, str | Secret] | None = None"}, {"name": "env_extra", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "Secret", "typedoc": "Secret", "nested": [], "union": false}], "union": true}, "defaultValue": null, "kind": "VAR_NAMED", "required": false, "repr": "**env_extra: str | Secret"}], "returnType": {"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, "doc": " Starts a new process on background.\n See Specifying command and arguments and Process configuration sections for more information about the arguments, and Run Process keyword for related examples. This includes information about redirecting process outputs to avoid process handing due to output buffers getting full.\n Makes the started process new active process. Returns the created subprocess.Popen object which can be used later to activate this process. Popen attributes like pid can also be accessed directly.\n Processes are started so that they create a new process group. This allows terminating and sending signals to possible child processes.\n Examples:\n Start process and wait for it to end later using an alias:\n \n\n\n\n Start Process\n ${command}\n alias=example\n\n # Other keywords\n \n \n\n ${result} =\n Wait For Process\n example\n\n\n Use returned Popen object:\n \n\n\n\n\n ${process} =\n Start Process\n ${command}\n\n Log\n PID: ${process.pid}\n \n\n # Other keywords\n \n \n\n ${result} =\n Terminate Process\n ${process}\n\n\n Use started process in a pipeline with another process:\n \n\n\n\n\n ${process} =\n Start Process\n python\n -c\n print('Hello, world!')\n \n\n ${result} =\n Run Process\n python\n -c\n import sys; print(sys.stdin.read().upper().strip())\n stdin=${process.stdout}\n\n Wait For Process\n ${process}\n \n \n \n \n\n Should Be Equal\n ${result.stdout}\n HELLO, WORLD!\n \n \n \n\n\n Returning a subprocess.Popen object is new in Robot Framework 5.0. Earlier versions returned a generic handle and getting the process object required using Get Process Object separately.", "shortdoc": "Starts a new process on background.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 707}, {"name": "Switch Process", "args": [{"name": "handle", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": null, "kind": "POSITIONAL_OR_NAMED", "required": true, "repr": "handle: Popen | str | None"}], "returnType": null, "doc": " Makes the specified process the current active process.\n The handle can be an identifier returned by Start Process or the alias given to it explicitly.\n Example:\n \n\n\n\n\n\n Start Process\n prog1\n alias=process1\n\n Start Process\n prog2\n alias=process2\n\n # currently active process is process2\n \n \n\n Switch Process\n process1\n \n\n # now active process is process1\n \n \n\n", "shortdoc": "Makes the specified process the current `active process`.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 1163}, {"name": "Terminate All Processes", "args": [{"name": "kill", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "kill: bool = False"}], "returnType": null, "doc": " Terminates all still running processes started by this library.\n This keyword can be used in suite teardown or elsewhere to make sure that all processes are stopped,\n Tries to terminate processes gracefully by default, but can be configured to forcefully kill them immediately. See Terminate Process that this keyword uses internally for more details.", "shortdoc": "Terminates all still running processes started by this library.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 996}, {"name": "Terminate Process", "args": [{"name": "handle", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "handle: Popen | str | None = None"}, {"name": "kill", "type": {"name": "bool", "typedoc": "boolean", "nested": [], "union": false}, "defaultValue": "False", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "kill: bool = False"}], "returnType": {"name": "ProcessResult", "typedoc": "ProcessResult", "nested": [], "union": false}, "doc": " Stops the process gracefully or forcefully.\n If handle is not given, uses the current active process.\n By default, first tries to stop the process gracefully. If the process does not stop in 30 seconds, or the kill argument is given a true value, kills the process forcefully. Stops also all the child processes of the originally started process.\n Waits for the process to stop after terminating it. Returns a result object containing information about the execution similarly as Wait For Process.\n On Unix-like machines graceful termination is done using TERM (15) signal and forceful kill 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.\n On Windows graceful termination is done using CTRL_BREAK_EVENT event and forceful kill using Win32 API function TerminateProcess(). In this case forceful kill only stops the main process, not possible child processes.\n Examples:\n \n\n\n\n ${result} =\n Terminate Process\n \n \n\n Should Be Equal As Integers\n ${result.rc}\n -15\n # On Unixes\n\n Terminate Process\n myproc\n kill=true\n \n\n", "shortdoc": "Stops the process gracefully or forcefully.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 926}, {"name": "Wait For Process", "args": [{"name": "handle", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "Popen", "typedoc": "Popen", "nested": [], "union": false}, {"name": "str", "typedoc": "string", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "handle: Popen | str | None = None"}, {"name": "timeout", "type": {"name": "Union", "typedoc": null, "nested": [{"name": "timedelta", "typedoc": "timedelta", "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "defaultValue": "None", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "timeout: timedelta | None = None"}, {"name": "on_timeout", "type": {"name": "Literal", "typedoc": "Literal", "nested": [{"name": "'continue'", "typedoc": null, "nested": [], "union": false}, {"name": "'terminate'", "typedoc": null, "nested": [], "union": false}, {"name": "'kill'", "typedoc": null, "nested": [], "union": false}], "union": false}, "defaultValue": "continue", "kind": "POSITIONAL_OR_NAMED", "required": false, "repr": "on_timeout: Literal['continue', 'terminate', 'kill'] = continue"}], "returnType": {"name": "Union", "typedoc": null, "nested": [{"name": "ProcessResult", "typedoc": null, "nested": [], "union": false}, {"name": "None", "typedoc": "None", "nested": [], "union": false}], "union": true}, "doc": " Waits for the process to complete or to reach the given timeout.\n The process to wait for must have been started earlier with Start Process. If handle is not given, uses the current active process.\n timeout defines the maximum time to wait for the process. It can be given in various time formats supported by Robot Framework, for example, 42, 42 s, or 1 minute 30 seconds. The timeout is ignored if it is None (default), zero or negative.\n 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.\n \n\n\n\n\n Value\n Action\n\n continue\n The process is left running (default).\n\n terminate\n The process is gracefully terminated.\n\n kill\n The process is forcefully stopped.\n\n\n See Terminate Process keyword for more details how processes are terminated and killed.\n 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.\n Examples:\n \n\n\n\n\n\n\n\n\n\n\n\n\n # Process ends cleanly\n \n \n \n\n ${result} =\n Wait For Process\n example\n \n\n Process Should Be Stopped\n example\n \n \n\n Should Be Equal As Integers\n ${result.rc}\n 0\n \n\n # Process does not end\n \n \n \n\n ${result} =\n Wait For Process\n timeout=42 secs\n \n\n Process Should Be Running\n \n \n \n\n Should Be Equal\n ${result}\n ${NONE}\n \n\n # Kill non-ending process\n \n \n \n\n ${result} =\n Wait For Process\n timeout=1min 30s\n on_timeout=kill\n\n Process Should Be Stopped\n \n \n \n\n Should Be Equal As Integers\n ${result.rc}\n -9\n \n\n\n Note: If Robot Framework's test or keyword timeout is exceeded while this keyword is waiting for the process to end, the process is killed to avoid leaving it running on the background. This is new in Robot Framework 7.3.", "shortdoc": "Waits for the process to complete or to reach the given timeout.", "tags": [], "source": "/home/peke/Devel/robotframework/src/robot/libraries/Process.py", "lineno": 827}], "typedocs": [{"type": "Standard", "name": "boolean", "doc": " Strings TRUE, YES, ON, 1 and possible localization specific \"true strings\" are converted to Boolean True, the empty string, strings FALSE, NO, OFF and 0 and possibly localization specific \"false strings\" are converted to Boolean False, and the string NONE is converted to the Python None object. Other strings and all other values are passed as-is, allowing keywords to handle them specially if needed. All string comparisons are case-insensitive.\n Examples: TRUE (converted to True), off (converted to False), example (used as-is)", "usages": ["Get Process Result", "Is Process Running", "Run Process", "Send Signal To Process", "Split Command Line", "Start Process", "Terminate All Processes", "Terminate Process"], "accepts": ["string", "integer", "float", "None"]}, {"type": "Standard", "name": "dictionary", "doc": " Strings must be Python dictionary literals. They are converted to actual dictionaries using the ast.literal_eval function. They can contain any values ast.literal_eval supports, including dictionaries and other collections.\n Any mapping is accepted and converted to a dict.\n If the type has nested types like dict[str, int], items are converted to those types automatically. This in new in Robot Framework 6.0.\n Examples: {'a': 1, 'b': 2}, {'key': 1, 'nested': {'key': 2}}", "usages": ["Run Process", "Start Process"], "accepts": ["string", "Mapping"]}, {"type": "Standard", "name": "integer", "doc": " Conversion is done using Python's int built-in function. Floating point numbers are accepted only if they can be represented as integers exactly. For example, 1.0 is accepted and 1.1 is not.\n It is possible to use hexadecimal, octal and binary numbers by prefixing values with 0x, 0o and 0b, respectively. Spaces and underscores can be used as visual separators for digit grouping purposes.\n Examples: 42, -1, 0b1010, 10 000 000, 0xBAD_C0FFEE", "usages": ["Get Process Id", "Get Process Result", "Run Process", "Send Signal To Process", "Start Process"], "accepts": ["string", "float"]}, {"type": "Standard", "name": "list", "doc": " Strings must be Python list or tuple literals. They are converted using the ast.literal_eval function and possible tuples converted further to lists. They can contain any values ast.literal_eval supports, including lists and other collections.\n If the argument is a list, it is used without conversion. Tuples and other sequences are converted to lists.\n If the type has nested types like list[int], items are converted to those types automatically.\n Examples: ['one', 'two'], [('one', 1), ('two', 2)]\n Support to convert nested types is new in Robot Framework 6.0. Support for tuple literals is new in Robot Framework 7.4.", "usages": ["Split Command Line"], "accepts": ["string", "Sequence"]}, {"type": "Standard", "name": "Literal", "doc": " Only specified values are accepted. Values can be strings, integers, bytes, Booleans, enums and None, and used arguments are converted using the value type specific conversion logic.\n Strings are case, space, underscore and hyphen insensitive, but exact matches have precedence over normalized matches.", "usages": ["Run Process", "Wait For Process"], "accepts": ["Any"]}, {"type": "Standard", "name": "None", "doc": " String NONE (case-insensitive) and the empty string are converted to the Python None object. Other values cause an error.\n Converting the empty string is new in Robot Framework 7.4.", "usages": ["Get Process Id", "Get Process Object", "Get Process Result", "Is Process Running", "Process Should Be Running", "Process Should Be Stopped", "Run Process", "Send Signal To Process", "Start Process", "Switch Process", "Terminate Process", "Wait For Process"], "accepts": ["string"]}, {"type": "Standard", "name": "Path", "doc": " Strings are converted Path objects. On Windows / is converted to \\ automatically.\n Examples: /tmp/absolute/path, relative/path/to/file.ext, name.txt", "usages": ["Run Process", "Start Process"], "accepts": ["string", "PurePath"]}, {"type": "Custom", "name": "Popen", "doc": " subprocess.Popen object.\n Returned by Start Process. Can be used as a handle with keywords like Wait For Process when working with multiple concurrent processes. Attributes like pid and stdin can also be accessed directly.\n Examples:\n \n\n\n\n\n ${process} =\n Start Process\n ${command}\n\n Log\n PID: ${process.pid}\n \n\n # Oher keywords\n \n \n\n ${result} =\n Terminate Process\n ${process}\n\n", "usages": ["Get Process Id", "Get Process Object", "Get Process Result", "Is Process Running", "Process Should Be Running", "Process Should Be Stopped", "Send Signal To Process", "Start Process", "Switch Process", "Terminate Process", "Wait For Process"], "accepts": []}, {"type": "Custom", "name": "ProcessResult", "doc": " An object containing process execution results in its attributes.\n \n\n\n\n\n\n\n Attribute\n Explanation\n\n rc\n Return code of the process as an integer.\n\n stdout\n Contents of the standard output stream.\n\n stderr\n Contents of the standard error stream.\n\n stdout_path\n Path where stdout was redirected or None if not redirected.\n\n stderr_path\n Path where stderr was redirected or None if not redirected.\n\n\n Example:\n \n\n\n\n\n\n\n\n ${result} =\n Run Process\n program\n \n\n Should Be Equal \n ${result.rc}\n 0\n type=int\n\n Should Match\n ${result.stdout}\n Some t?xt*\n \n\n Should Be Empty\n ${result.stderr}\n \n \n\n ${stdout} =\n Get File\n ${result.stdout_path}\n \n\n Should Be Equal\n ${stdout}\n ${result.stdout}\n \n\n File Should Be Empty\n ${result.stderr_path}\n \n \n\n\n Notice that in stdout and stderr content possible trailing newline is removed and \\r\\n converted to \\n automatically. If you need to see the original process output, redirect it to a file using process configuration and read it from there.", "usages": ["Run Process", "Terminate Process"], "accepts": []}, {"type": "Standard", "name": "Secret", "doc": " Encapsulates secret values to avoid them being shown in Robot Framework logs.\n The value is required to be robot.api.types.Secret object. These objects encapsulate confidential values so that they are not exposed in log files. How to create them is explained in the User Guide.\n New in Robot Framework 7.4.", "usages": ["Run Process", "Start Process"], "accepts": ["string"]}, {"type": "Standard", "name": "Sequence", "doc": " Strings must be Python list or tuple literals. They are converted to actual lists or tuples using the ast.literal_eval function. They can contain any values ast.literal_eval supports, including lists and other collections.\n Any sequence is accepted without conversion. An exception is that if the used type is MutableSequence, immutable values are converted to lists.\n If the type has nested types like Sequence[int], items are converted to those types automatically.\n Examples: ['one', 'two'], (1, 2, 3)\n Support to convert nested types is new in Robot Framework 6.0. Support for tuple literals is new in Robot Framework 7.4.", "usages": ["Join Command Line"], "accepts": ["string", "Sequence"]}, {"type": "Standard", "name": "string", "doc": " All arguments are converted to Unicode strings.\n Most values are converted simply by using str(value). An exception is that bytes are mapped directly to Unicode code points with same ordinals. This means that, for example, b\"hyv\\xe4\" becomes \"hyv\u00e4\".\n Converting bytes specially is new Robot Framework 7.4.", "usages": ["Get Process Id", "Get Process Object", "Get Process Result", "Is Process Running", "Join Command Line", "Process Should Be Running", "Process Should Be Stopped", "Run Process", "Send Signal To Process", "Split Command Line", "Start Process", "Switch Process", "Terminate Process", "Wait For Process"], "accepts": ["Any"]}, {"type": "Standard", "name": "timedelta", "doc": " Strings are expected to represent a time interval in one of the time formats Robot Framework supports:\n \n a number representing seconds like 42 or 10.5\n a time string like 1 hour 2 seconds or 1h 2s\n a \"timer\" string like 01:02 (1 minute 2 seconds) or 01:00:03 (1 hour 3 seconds)\n\n Integers and floats are considered to be seconds.\n See the Robot Framework User Guide for more details about the supported time formats.", "usages": ["Run Process", "Wait For Process"], "accepts": ["string", "integer", "float"]}, {"type": "Standard", "name": "tuple", "doc": " Strings must be Python tuple or list literals. They are converted using the ast.literal_eval function and possible lists converted further to tuples. They can contain any values ast.literal_eval supports, including tuples and other collections.\n If the argument is a tuple, it is used without conversion. Lists and other sequences are converted to tuples.\n If the type has nested types like tuple[str, int, int], items are converted to those types automatically.\n Examples: ('one', 'two'), (('one', 1), ('two', 2))\n Support to convert nested types is new in Robot Framework 6.0. Support for list literals is new in Robot Framework 7.4.", "usages": ["Get Process Result"], "accepts": ["string", "Sequence"]}]} Opening library documentation failed Verify that you have JavaScript enabled in your browser. Make sure you are using a modern enough browser. If using Internet Explorer, version 11 is required. Check are there messages in your browser's JavaScript error log. Please report the problem if you suspect you have encountered a bug.