robot.running.arguments package

Submodules

robot.running.arguments.argumentconverter module

class robot.running.arguments.argumentconverter.ArgumentConverter(argspec, converters, dry_run=False, languages=None)

Bases: object

convert(positional, named)

robot.running.arguments.argumentmapper module

class robot.running.arguments.argumentmapper.ArgumentMapper(argspec)

Bases: object

map(positional, named, replace_defaults=True)

class robot.running.arguments.argumentmapper.KeywordCallTemplate(argspec)

Bases: object

fill_positional(positional)

fill_named(named)

replace_defaults()

class robot.running.arguments.argumentmapper.DefaultValue(value)

Bases: object

resolve(variables)

robot.running.arguments.argumentparser module

class robot.running.arguments.argumentparser.ArgumentParser(type='Keyword', error_reporter=None)

Bases: abc.ABC

parse(source, name=None)

class robot.running.arguments.argumentparser.PythonArgumentParser(type='Keyword', error_reporter=None)

Bases: robot.running.arguments.argumentparser.ArgumentParser

parse(handler, name=None)

class robot.running.arguments.argumentparser.ArgumentSpecParser(type='Keyword', error_reporter=None)

Bases: robot.running.arguments.argumentparser.ArgumentParser

parse(argspec, name=None)

class robot.running.arguments.argumentparser.DynamicArgumentParser(type='Keyword', error_reporter=None)

Bases: robot.running.arguments.argumentparser.ArgumentSpecParser

parse(argspec, name=None)

class robot.running.arguments.argumentparser.UserKeywordArgumentParser(type='Keyword', error_reporter=None)

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)

Bases: object

resolve(arguments, variables=None)

class robot.running.arguments.argumentresolver.NamedArgumentResolver(argspec)

Bases: object

resolve(arguments, variables=None)

class robot.running.arguments.argumentresolver.NullNamedArgumentResolver

Bases: object

resolve(arguments, variables=None)

class robot.running.arguments.argumentresolver.DictToKwargs(argspec, enabled=False)

Bases: object

handle(positional, named)

class robot.running.arguments.argumentresolver.VariableReplacer(resolve_until=None)

Bases: object

replace(positional, named, variables=None)

robot.running.arguments.argumentspec module

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)

Bases: object

types

positional

minargs

maxargs

argument_names

resolve(arguments, variables=None, converters=None, resolve_named=True, resolve_variables_until=None, dict_to_kwargs=False, languages=None)

convert(positional, named, converters=None, dry_run=False, languages=None)

map(positional, named, replace_defaults=True)

class robot.running.arguments.argumentspec.ArgInfo(kind, name='', type=<object object>, default=<object object>)

Bases: object

Contains argument information. Only used by Libdoc.

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'

required

types_reprs

Deprecated. Use type instead.

default_repr

class robot.running.arguments.argumentspec.TypeInfo(type: Union[type, str, tuple, object] = <object object>, nested: Tuple[TypeInfo] = ())

Bases: object

Represents argument type. Only used by Libdoc.

With unions and parametrized types, nested contains nested types.

NOTSET = <object object>

name

is_union

classmethod from_type(type: Union[type, str, tuple, object]) → robot.running.arguments.argumentspec.TypeInfo

classmethod from_dict(data: dict) → robot.running.arguments.argumentspec.TypeInfo

robot.running.arguments.argumentvalidator module

class robot.running.arguments.argumentvalidator.ArgumentValidator(argspec)

Bases: object

validate(positional, named, dryrun=False)

robot.running.arguments.customconverters module

class robot.running.arguments.customconverters.CustomArgumentConverters(converters)

Bases: object

classmethod from_dict(converters, library)

get_converter_info(type_)

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

Bases: object

name

doc

classmethod for_converter(type_, converter, library)

convert(value)

robot.running.arguments.embedded module

class robot.running.arguments.embedded.EmbeddedArguments(name=None, args=(), custom_patterns=None)

Bases: object

classmethod from_name(name)

match(name)

map(values)

validate(values)

class robot.running.arguments.embedded.EmbeddedArgumentParser

Bases: object

parse(string)

robot.running.arguments.typeconverters module

class robot.running.arguments.typeconverters.TypeConverter(used_type, custom_converters=None, languages=None)

Bases: object

type = None

type_name = None

abc = None

aliases = ()

value_types = (<class 'str'>,)

doc = None

classmethod register(converter)

classmethod converter_for(type_, custom_converters=None, languages=None)

classmethod handles(type_)

convert(name, value, explicit_type=True, strict=True, kind='Argument')

no_conversion_needed(value)

class robot.running.arguments.typeconverters.EnumConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of enum.Enum

type_name

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.

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.AnyConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of typing.Any

type_name = 'Any'

aliases = ('any',)

value_types = (typing.Any,)

classmethod handles(type_)

no_conversion_needed(value)

abc = None

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod register(converter)

class robot.running.arguments.typeconverters.StringConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.str

type_name = 'string'

aliases = ('string', 'str', 'unicode')

value_types = (typing.Any,)

abc = None

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.BooleanConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.bool

type_name = 'boolean'

aliases = ('bool',)

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

abc = None

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.IntegerConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.int

abc

alias of numbers.Integral

type_name = 'integer'

aliases = ('int', 'long')

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

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.FloatConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.float

abc

alias of numbers.Real

type_name = 'float'

aliases = ('double',)

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

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.DecimalConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of decimal.Decimal

type_name = 'decimal'

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

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.BytesConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.bytes

abc

alias of collections.abc.ByteString

type_name = 'bytes'

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

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.ByteArrayConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.bytearray

type_name = 'bytearray'

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

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.DateTimeConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of datetime.datetime

type_name = 'datetime'

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

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.DateConverter(used_type, custom_converters=None, languages=None)

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, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

value_types = (<class 'str'>,)

class robot.running.arguments.typeconverters.TimeDeltaConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of datetime.timedelta

type_name = 'timedelta'

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

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.PathConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of pathlib.Path

abc

alias of os.PathLike

type_name = 'Path'

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

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.NoneConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.NoneType

type_name = 'None'

classmethod handles(type_)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

no_conversion_needed(value)

classmethod register(converter)

value_types = (<class 'str'>,)

class robot.running.arguments.typeconverters.ListConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.list

abc

alias of collections.abc.Sequence

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

type_name = 'list'

classmethod handles(type_)

no_conversion_needed(value)

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod register(converter)

class robot.running.arguments.typeconverters.TupleConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.tuple

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

type_name = 'tuple'

no_conversion_needed(value)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

classmethod register(converter)

class robot.running.arguments.typeconverters.TypedDictConverter(used_type, custom_converters, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type = 'TypedDict'

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

type_name = None

classmethod handles(type_)

no_conversion_needed(value)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod register(converter)

class robot.running.arguments.typeconverters.DictionaryConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.dict

abc

alias of collections.abc.Mapping

aliases = ('dict', 'map')

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

type_name = 'dictionary'

no_conversion_needed(value)

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

classmethod register(converter)

class robot.running.arguments.typeconverters.SetConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of builtins.set

abc

alias of collections.abc.Set

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

type_name = 'set'

no_conversion_needed(value)

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

classmethod register(converter)

class robot.running.arguments.typeconverters.FrozenSetConverter(used_type, custom_converters=None, languages=None)

Bases: robot.running.arguments.typeconverters.SetConverter

type

alias of builtins.frozenset

type_name = 'frozenset'

abc

alias of collections.abc.Set

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

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

class robot.running.arguments.typeconverters.CombinedConverter(union, custom_converters, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

type = typing.Union

type_name

classmethod handles(type_)

no_conversion_needed(value)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

doc = None

classmethod register(converter)

value_types = (<class 'str'>,)

class robot.running.arguments.typeconverters.CustomConverter(used_type, converter_info, languages=None)

Bases: robot.running.arguments.typeconverters.TypeConverter

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True, kind='Argument')

classmethod converter_for(type_, custom_converters=None, languages=None)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

type = None

type_name

doc

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.

robot.running.arguments.typevalidator module

class robot.running.arguments.typevalidator.TypeValidator(argspec)

Bases: object

validate(types)

validate_type_dict(types)

convert_type_list_to_dict(types)