Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://robot-framework.readthedocs.io/en/master/autodoc/robot.running.arguments.html below:

Website Navigation

• Robot Framework

robot.running.arguments package — Robot Framework 7.3.3.dev1 documentation

class robot.running.arguments.argumentconverter.ArgumentConverter(arg_spec: ArgumentSpec, custom_converters: CustomArgumentConverters, dry_run: bool = False, languages: LanguagesLike = None)[source]

Bases: object

convert(positional, named)[source]

class robot.running.arguments.argumentmapper.ArgumentMapper(arg_spec: ArgumentSpec)[source]

Bases: object

map(positional, named, replace_defaults=True)[source]

class robot.running.arguments.argumentmapper.KeywordCallTemplate(spec: ArgumentSpec)[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]

class robot.running.arguments.argumentparser.ArgumentParser(type: str = 'Keyword', error_reporter: Callable[[str], None] | None = None)[source]

Bases: ABC

abstractmethod parse(source: Any, name: str | None = None) → ArgumentSpec[source]

class robot.running.arguments.argumentparser.PythonArgumentParser(type: str = 'Keyword', error_reporter: Callable[[str], None] | None = None)[source]

Bases: ArgumentParser

parse(method, name=None)[source]

class robot.running.arguments.argumentparser.ArgumentSpecParser(type: str = 'Keyword', error_reporter: Callable[[str], None] | None = None)[source]

Bases: ArgumentParser

parse(arguments, name=None)[source]

class robot.running.arguments.argumentparser.DynamicArgumentParser(type: str = 'Keyword', error_reporter: Callable[[str], None] | None = None)[source]

Bases: ArgumentSpecParser

class robot.running.arguments.argumentparser.UserKeywordArgumentParser(type: str = 'Keyword', error_reporter: Callable[[str], None] | None = None)[source]

Bases: ArgumentSpecParser

class robot.running.arguments.argumentresolver.ArgumentResolver(spec: ArgumentSpec, resolve_named: bool = True, resolve_args_until: int | None = None, dict_to_kwargs: bool = False)[source]

Bases: object

resolve(args, named_args=None, variables=None)[source]

class robot.running.arguments.argumentresolver.NamedArgumentResolver(spec: ArgumentSpec)[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(spec: ArgumentSpec, enabled: bool = False)[source]

Bases: object

handle(positional, named)[source]

class robot.running.arguments.argumentresolver.VariableReplacer(spec: ArgumentSpec, resolve_until: int | None = None)[source]

Bases: object

replace(positional, named, variables=None)[source]

class robot.running.arguments.argumentspec.ArgumentSpec(name: str | Callable[[], str] | None = None, type: str = 'Keyword', positional_only: Sequence[str] = (), positional_or_named: Sequence[str] = (), var_positional: str | None = None, named_only: Sequence[str] = (), var_named: str | None = None, defaults: Mapping[str, Any] | None = None, embedded: Sequence[str] = (), types: Mapping | Sequence | None = None, return_type: TypeInfo | None = None)[source]

Bases: object

type

positional_only

positional_or_named

var_positional

named_only

var_named

embedded

defaults

property name: str | None

types

return_type

property positional: tuple[str, ...]

property named: tuple[str, ...]

property minargs: int

property maxargs: int

property argument_names: tuple[str, ...]

resolve(args, named_args=None, variables=None, converters=None, resolve_named=True, resolve_args_until=None, dict_to_kwargs=False, languages=None) → tuple[list, list][source]

convert(positional, named, converters=None, dry_run=False, languages=None) → tuple[list, list][source]

map(positional, named, replace_defaults=True) → tuple[list, list][source]

copy() → ArgumentSpec[source]

class robot.running.arguments.argumentspec.ArgInfo(kind: str, name: str = '', type: ~robot.running.arguments.typeinfo.TypeInfo | None = None, default: ~typing.Any =)[source]

Bases: object

Contains argument information. Only used by Libdoc.

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'

property required: bool

property default_repr: str | None

class robot.running.arguments.argumentvalidator.ArgumentValidator(arg_spec: ArgumentSpec)[source]

Bases: object

validate(positional, named, dryrun=False)[source]

class robot.running.arguments.customconverters.CustomArgumentConverters(converters)[source]

Bases: object

classmethod from_dict(converters, library=None)[source]

get_converter_info(type_)[source]

class robot.running.arguments.customconverters.ConverterInfo(type, converter, value_types, library=None)[source]

Bases: object

property name

property doc

classmethod for_converter(type_, converter, library)[source]

convert(value)[source]

class robot.running.arguments.embedded.EmbeddedArguments(name: Pattern, args: Sequence[str] = (), custom_patterns: Mapping[str, str] | None = None, types: Sequence[TypeInfo | None] = ())[source]

Bases: object

classmethod from_name(name: str) → EmbeddedArguments | None[source]

match(name: str) → Match | None[source]

Deprecated since Robot Framework 7.3.

matches(name: str) → bool[source]

Return True if name matches these embedded arguments.

parse_args(name: str) → tuple[str, ...][source]

Parse arguments matching these embedded arguments from name.

map(args: Sequence[object]) → list[tuple[str, object]][source]

validate(args: Sequence[object])[source]

Validate that embedded args match custom regexps.

Initial validation is done already when matching keywords, but this validation makes sure arguments match also if they are given as variables.

Currently, argument not matching only causes a deprecation warning, but that will be changed to ValueError in RF 8.0: https://github.com/robotframework/robotframework/issues/4069

class robot.running.arguments.embedded.EmbeddedArgumentParser[source]

Bases: object

parse(string: str) → EmbeddedArguments | None[source]

class robot.running.arguments.typeconverters.TypeConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: object

type = None

abc = None

value_types = (<class 'str'>,)

doc = None

nested: list[TypeConverter] | dict[str, TypeConverter] | None

type_name = None

property languages: Languages

classmethod register(converter: type[TypeConverter]) → type[TypeConverter][source]

classmethod converter_for(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None) → TypeConverter[source]

classmethod handles(type_info: TypeInfo) → bool[source]

convert(value: Any, name: str | None = None, kind: str = 'Argument') → Any[source]

no_conversion_needed(value: Any) → bool[source]

validate()[source]

Validate converter. Raise TypeError for unrecognized types.

class robot.running.arguments.typeconverters.EnumConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of Enum

property value_types

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

class robot.running.arguments.typeconverters.AnyConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of Any

type_name = 'Any'

value_types = (typing.Any,)

classmethod handles(type_info: TypeInfo)[source]

no_conversion_needed(value)[source]

class robot.running.arguments.typeconverters.StringConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of str

type_name = 'string'

value_types = (typing.Any,)

class robot.running.arguments.typeconverters.BooleanConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of bool

type_name = 'boolean'

value_types = (<class 'str'>, <class 'int'>, <class 'float'>, <class 'NoneType'>)

class robot.running.arguments.typeconverters.IntegerConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of int

abc

alias of Integral

type_name = 'integer'

value_types = (<class 'str'>, <class 'float'>)

class robot.running.arguments.typeconverters.FloatConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of float

abc

alias of Real

type_name = 'float'

value_types = (<class 'str'>, <class 'numbers.Real'>)

class robot.running.arguments.typeconverters.DecimalConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of Decimal

type_name = 'decimal'

value_types = (<class 'str'>, <class 'int'>, <class 'float'>)

class robot.running.arguments.typeconverters.BytesConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of bytes

type_name = 'bytes'

value_types = (<class 'str'>, <class 'bytearray'>)

class robot.running.arguments.typeconverters.ByteArrayConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of bytearray

type_name = 'bytearray'

value_types = (<class 'str'>, <class 'bytes'>)

class robot.running.arguments.typeconverters.DateTimeConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of datetime

type_name = 'datetime'

value_types = (<class 'str'>, <class 'int'>, <class 'float'>)

class robot.running.arguments.typeconverters.DateConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of date

type_name = 'date'

class robot.running.arguments.typeconverters.TimeDeltaConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of timedelta

type_name = 'timedelta'

value_types = (<class 'str'>, <class 'int'>, <class 'float'>)

class robot.running.arguments.typeconverters.PathConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of Path

abc

alias of PathLike

type_name = 'Path'

value_types = (<class 'str'>, <class 'pathlib._local.PurePath'>)

class robot.running.arguments.typeconverters.NoneConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of None

type_name = 'None'

classmethod handles(type_info: TypeInfo) → bool[source]

class robot.running.arguments.typeconverters.ListConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of list

type_name = 'list'

abc

alias of Sequence

value_types = (<class 'str'>, <class 'collections.abc.Sequence'>)

no_conversion_needed(value)[source]

class robot.running.arguments.typeconverters.TupleConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of tuple

type_name = 'tuple'

value_types = (<class 'str'>, <class 'collections.abc.Sequence'>)

property homogenous: bool

no_conversion_needed(value)[source]

class robot.running.arguments.typeconverters.TypedDictConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type = 'TypedDict'

value_types = (<class 'str'>, <class 'collections.abc.Mapping'>)

type_info: TypedDictInfo

nested: dict[str, TypeConverter]

classmethod handles(type_info: TypeInfo) → bool[source]

no_conversion_needed(value)[source]

class robot.running.arguments.typeconverters.DictionaryConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of dict

abc

alias of Mapping

type_name = 'dictionary'

value_types = (<class 'str'>, <class 'collections.abc.Mapping'>)

no_conversion_needed(value)[source]

class robot.running.arguments.typeconverters.SetConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type

alias of set

abc

alias of Set

type_name = 'set'

value_types = (<class 'str'>, <class 'collections.abc.Container'>)

no_conversion_needed(value)[source]

class robot.running.arguments.typeconverters.FrozenSetConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: SetConverter

type

alias of frozenset

type_name = 'frozenset'

class robot.running.arguments.typeconverters.UnionConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type = typing.Union

classmethod handles(type_info: TypeInfo) → bool[source]

no_conversion_needed(value)[source]

class robot.running.arguments.typeconverters.LiteralConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

type = typing.Literal

type_name = 'Literal'

value_types = (typing.Any,)

classmethod converter_for(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None) → TypeConverter[source]

classmethod handles(type_info: TypeInfo) → bool[source]

no_conversion_needed(value: Any) → bool[source]

class robot.running.arguments.typeconverters.CustomConverter(type_info: TypeInfo, converter_info: ConverterInfo, languages: Languages | None = None)[source]

Bases: TypeConverter

property doc

The type of the None singleton.

property value_types

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

class robot.running.arguments.typeconverters.UnknownConverter(type_info: TypeInfo, custom_converters: CustomArgumentConverters | None = None, languages: Languages | None = None)[source]

Bases: TypeConverter

convert(value, name=None, kind='Argument')[source]

validate()[source]

Validate converter. Raise TypeError for unrecognized types.

class robot.running.arguments.typeinfo.TypeInfo(name: str | None = None, type: ~typing.Any =, nested: ~collections.abc.Sequence[~robot.running.arguments.typeinfo.TypeInfo] | None = None)[source]

Bases: object

Represents an argument type.

Normally created using the from_type_hint() classmethod. With unions and parametrized types, nested contains nested types.

Values can be converted according to this type info by using the convert() method.

Part of the public API starting from Robot Framework 7.0. In such usage should be imported via the robot.api package.

is_typed_dict = False

name

type

nested

Nested types as a tuple of TypeInfo objects.

Used with parameterized types and unions.

property is_union

classmethod from_type_hint(hint: Any) → TypeInfo[source]

Construct a TypeInfo based on a type hint.

The type hint can be in various different formats:

• an actual type such as int

• a parameterized type such as list[int]

• a union such as int | float

• a string such as 'int', 'list[int]' or 'int | float'

• a TypedDict (represented as a TypedDictInfo)

• a sequence of supported type hints to create a union from such as [int, float] or ('int', 'list[int]')

In special cases using a more specialized method like from_sequence() may be more appropriate than using this generic method.

classmethod from_type(hint: type) → TypeInfo[source]

Construct a TypeInfo based on an actual type.

Use from_type_hint() if the type hint can also be something else than a concrete type such as a string.

classmethod from_string(hint: str) → TypeInfo[source]

Construct a TypeInfo based on a string.

In addition to just types names or their aliases like int or integer, supports also parameterized types like list[int] as well as unions like int | float.

Use from_type_hint() if the type hint can also be something else than a string such as an actual type.

classmethod from_sequence(sequence: tuple | list) → TypeInfo[source]

Construct a TypeInfo based on a sequence of types.

Types can be actual types, strings, or anything else accepted by from_type_hint(). If the sequence contains just one type, a TypeInfo created based on it is returned. If there are more types, the returned TypeInfo represents a union. Using an empty sequence is an error.

Use from_type_hint() if other types than sequences need to supported.

classmethod from_variable(variable: str | VariableMatch, handle_list_and_dict: bool = True) → TypeInfo[source]

Construct a TypeInfo based on a variable.

Type can be specified using syntax like ${x: int}.

Parameters:

• variable – Variable as a string or as an already parsed VariableMatch object.

• handle_list_and_dict – When True, types in list and dictionary variables get list[] and dict[] decoration implicitly. For example, @{x: int}, &{x: int} and &{x: str=int} yield types list[int], dict[Any, int] and dict[str, int], respectively.

Raises:

DataError if variable has an unrecognized type. Variable not having a type is not an error.

New in Robot Framework 7.3.

convert(value: Any, name: str | None = None, custom_converters: CustomArgumentConverters | dict | None = None, languages: LanguagesLike = None, kind: str = 'Argument', allow_unknown: bool = False) → object[source]

Convert value based on type information this TypeInfo contains.

Parameters:

• value – Value to convert.

• name – Name of the argument or other thing to convert. Used only for error reporting.

• custom_converters – Custom argument converters.

• languages – Language configuration. During execution, uses the current language configuration by default.

• kind – Type of the thing to be converted. Used only for error reporting.

• allow_unknown – If False, a TypeError is raised if there is no converter for this type or to its nested types. If True, conversion returns the original value instead.

Raises:

ValueError if conversion fails and TypeError if there is no converter for this type and unknown converters are not accepted.

Returns:

Converted value.

get_converter(custom_converters: CustomArgumentConverters | dict | None = None, languages: LanguagesLike = None, allow_unknown: bool = False) → TypeConverter[source]

Get argument converter for this TypeInfo.

Parameters:

• custom_converters – Custom argument converters.

• languages – Language configuration. During execution, uses the current language configuration by default.

• allow_unknown – If False, a TypeError is raised if there is no converter for this type or to its nested types. If True, a special UnknownConverter is returned instead.

Raises:

TypeError if there is no converter and unknown converters are not accepted.

Returns:

TypeConverter.

The convert() method handles the common conversion case, but this method can be used if the converter is needed multiple times or its needed also for other purposes than conversion.

New in Robot Framework 7.2.

class robot.running.arguments.typeinfo.TypedDictInfo(name: str, type: type)[source]

Bases: TypeInfo

Represents TypedDict used as an argument.

is_typed_dict = True

required

annotations

class robot.running.arguments.typeinfoparser.TokenType(*values)[source]

Bases: Enum

NAME = 1

LEFT_SQUARE = 2

RIGHT_SQUARE = 3

PIPE = 4

COMMA = 5

class robot.running.arguments.typeinfoparser.Token(type: robot.running.arguments.typeinfoparser.TokenType, value: str, position: int = -1)[source]

Bases: object

type: TokenType

value: str

position: int = -1

class robot.running.arguments.typeinfoparser.TypeInfoTokenizer(source: str)[source]

Bases: object

markers = {',': TokenType.COMMA, '[': TokenType.LEFT_SQUARE, ']': TokenType.RIGHT_SQUARE, '|': TokenType.PIPE}

property at_end: bool

tokenize() → list[Token][source]

advance() → str[source]

peek() → str | None[source]

name()[source]

add_token(type: TokenType)[source]

class robot.running.arguments.typeinfoparser.TypeInfoParser(source: str)[source]

Bases: object

property at_end: bool

parse() → TypeInfo[source]

type() → TypeInfo[source]

params(literal: bool = False) → list[TypeInfo][source]

union() → list[TypeInfo][source]

match(*types: TokenType) → bool[source]

check(expected: TokenType) → bool[source]

advance() → Token | None[source]

peek() → Token | None[source]

error(message: str, token: Token | None = None)[source]

class robot.running.arguments.typevalidator.TypeValidator(spec: ArgumentSpec)[source]

Bases: object

validate(types: Mapping | Sequence | None) → dict[str, TypeInfo] | None[source]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4