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.

Submodules

robot.variables.assigner module

class robot.variables.assigner.VariableAssignment(assignment)

Bases: object

validate_assignment()

assigner(context)

class robot.variables.assigner.AssignmentValidator

Bases: object

validate(assignment)

class robot.variables.assigner.VariableAssigner(assignment, context)

Bases: object

assign(return_value)

class robot.variables.assigner.ReturnValueResolver

Bases: object

classmethod from_assignment(assignment)

resolve(return_value)

class robot.variables.assigner.NoReturnValueResolver

Bases: ReturnValueResolver

resolve(return_value)

class robot.variables.assigner.OneReturnValueResolver(assignment)

Bases: ReturnValueResolver

resolve(return_value)

class robot.variables.assigner.MultiReturnValueResolver(assignments)

Bases: ReturnValueResolver

resolve(return_value)

class robot.variables.assigner.ScalarsOnlyReturnValueResolver(assignments)

Bases: MultiReturnValueResolver

class robot.variables.assigner.ScalarsAndListReturnValueResolver(assignments)

Bases: MultiReturnValueResolver

robot.variables.evaluation module

robot.variables.evaluation.evaluate_expression(expression, variables, modules=None, namespace=None, resolve_variables=False)

class robot.variables.evaluation.EvaluationNamespace(variable_store, namespace)

Bases: MutableMapping

robot.variables.filesetter module

class robot.variables.filesetter.VariableFileSetter(store: VariableStore)

Bases: object

set(path_or_variables, args=None, overwrite=False)

class robot.variables.filesetter.PythonImporter

Bases: object

import_variables(path, args=None)

class robot.variables.filesetter.JsonImporter

Bases: object

import_variables(path, args=None)

class robot.variables.filesetter.YamlImporter

Bases: object

import_variables(path, args=None)

robot.variables.finders module

class robot.variables.finders.VariableFinder(variables)

Bases: object

find(variable)

class robot.variables.finders.StoredFinder(store)

Bases: object

identifiers = '$@&'

find(variable: VariableMatch)

class robot.variables.finders.NumberFinder

Bases: object

identifiers = '$'

find(variable: VariableMatch)

class robot.variables.finders.EmptyFinder

Bases: object

identifiers = '$@&'

empty = NormalizedDict({'${EMPTY}': '', '&{EMPTY}': {}, '@{EMPTY}': ()})

find(variable: VariableMatch)

class robot.variables.finders.InlinePythonFinder(variables)

Bases: object

identifiers = '$@&'

find(variable: VariableMatch)

class robot.variables.finders.ExtendedFinder(finder)

Bases: object

identifiers = '$@&'

find(variable: VariableMatch)

class robot.variables.finders.EnvironmentFinder

Bases: object

identifiers = '%'

find(variable: VariableMatch)

robot.variables.notfound module

robot.variables.notfound.variable_not_found(name: str, candidates: Mapping[str, object], message: str | None = None, deco_braces: bool = True) → NoReturn

Raise VariableError for missing variable name.

Error message includes recommendations for similar variable names if any are found. Finding recommendations has a performance effect, so this function should only been called when such information is actually useful.

robot.variables.replacer module

class robot.variables.replacer.VariableReplacer(variables)

Bases: object

replace_list(items, replace_until=None, ignore_errors=False)

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 arguments in the beginning and pass others to called keywords unmodified.

replace_scalar(item, ignore_errors=False)

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)

Replaces variables from a string. Result is always a string.

Input can also be an already found VariableMatch.

robot.variables.resolvable module

class robot.variables.resolvable.Resolvable

Bases: object

resolve(variables)

report_error(error)

class robot.variables.resolvable.GlobalVariableValue(value)

Bases: Resolvable

resolve(variables)

robot.variables.scopes module

class robot.variables.scopes.VariableScopes(settings)

Bases: object

property current

start_suite()

end_suite()

start_test()

end_test()

start_keyword()

end_keyword()

replace_list(items, replace_until=None, ignore_errors=False)

replace_scalar(items, ignore_errors=False)

replace_string(string, custom_unescaper=None, ignore_errors=False)

set_from_file(path, args, overwrite=False)

set_from_variable_section(variables, overwrite=False)

resolve_delayed()

set_global(name, value)

set_suite(name, value, top=False, children=False)

set_test(name, value)

set_keyword(name, value)

set_local(name, value)

as_dict(decoration=True)

class robot.variables.scopes.GlobalVariables(settings)

Bases: Variables

class robot.variables.scopes.SetVariables

Bases: object

start_suite()

end_suite()

start_test()

end_test()

start_keyword()

end_keyword()

set_global(name, value)

set_suite(name, value, children=False)

set_test(name, value)

set_keyword(name, value)

update(variables)

robot.variables.search module

robot.variables.search.search_variable(string: str, identifiers: Sequence[str] = '$@&%*', parse_type: bool = False, ignore_errors: bool = False) → VariableMatch

robot.variables.search.contains_variable(string: str, identifiers: Sequence[str] = '$@&') → bool

robot.variables.search.is_variable(string: str, identifiers: Sequence[str] = '$@&') → bool

robot.variables.search.is_scalar_variable(string: str) → bool

robot.variables.search.is_list_variable(string: str) → bool

robot.variables.search.is_dict_variable(string: str) → bool

robot.variables.search.is_assign(string: str, identifiers: Sequence[str] = '$@&', allow_assign_mark: bool = False, allow_nested: bool = False, allow_items: bool = False) → bool

robot.variables.search.is_scalar_assign(string: str, allow_assign_mark: bool = False, allow_nested: bool = False, allow_items: bool = False) → bool

robot.variables.search.is_list_assign(string: str, allow_assign_mark: bool = False, allow_nested: bool = False, allow_items: bool = False) → bool

robot.variables.search.is_dict_assign(string: str, allow_assign_mark: bool = False, allow_nested: bool = False, allow_items: bool = False) → bool

class robot.variables.search.VariableMatch(string: str, identifier: str | None = None, base: str | None = None, type: str | None = None, items: tuple[str, ...] = (), start: int = -1, end: int = -1)

Bases: object

resolve_base(variables, ignore_errors=False)

property name: str | None

property before: str

property match: str | None

property after: str

is_variable() → bool

is_scalar_variable() → bool

is_list_variable() → bool

is_dict_variable() → bool

is_assign(allow_assign_mark: bool = False, allow_nested: bool = False, allow_items: bool = False) → bool

is_scalar_assign(allow_assign_mark: bool = False, allow_nested: bool = False) → bool

is_list_assign(allow_assign_mark: bool = False, allow_nested: bool = False) → bool

is_dict_assign(allow_assign_mark: bool = False, allow_nested: bool = False) → bool

robot.variables.search.unescape_variable_syntax(item)

class robot.variables.search.VariableMatches(string: str, identifiers: Sequence[str] = '$@&%', parse_type: bool = False, ignore_errors: bool = False)

Bases: object

robot.variables.store module

class robot.variables.store.VariableStore(variables)

Bases: object

resolve_delayed()

get(name, default, decorated=True)

pop(name, decorated=True)

update(store)

clear()

add(name, value, overwrite=True, decorated=True)

as_dict(decoration=True)

robot.variables.tablesetter module

class robot.variables.tablesetter.VariableTableSetter(store: VariableStore)

Bases: object

set(variables: Sequence[Variable], overwrite: bool = False)

class robot.variables.tablesetter.VariableResolver(value: Sequence[str], name: str | None = None, type: str | None = None, error_reporter: Callable[[str], None] | None = None)

Bases: Resolvable

classmethod from_name_and_value(name: str, value: str | Sequence[str], separator: str | None = None, error_reporter: Callable[[str], None] | None = None) → VariableResolver

classmethod from_variable(var: Var | Variable) → VariableResolver

resolve(variables) → Any

report_error(error)

class robot.variables.tablesetter.ScalarVariableResolver(value: str | Sequence[str], separator: str | None = None, name=None, type=None, error_reporter=None)

Bases: VariableResolver

class robot.variables.tablesetter.ListVariableResolver(value: Sequence[str], name: str | None = None, type: str | None = None, error_reporter: Callable[[str], None] | None = None)

Bases: VariableResolver

class robot.variables.tablesetter.DictVariableResolver(value: Sequence[str], name=None, type=None, error_reporter=None)

Bases: VariableResolver

robot.variables.variables module

class robot.variables.variables.Variables

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.

get(name, default=None)

resolve_delayed()

replace_list(items, replace_until=None, ignore_errors=False)

replace_scalar(item, ignore_errors=False)

replace_string(item, custom_unescaper=None, ignore_errors=False)

set_from_file(path_or_variables, args=None, overwrite=False)

set_from_variable_section(variables, overwrite=False)

clear()

copy(update=None)

update(variables)

as_dict(decoration=True)