robot.running.arguments package

Submodules

robot.running.arguments.argumentconverter module

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

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.JavaArgumentParser(type='Keyword')

Bases: robot.running.arguments.argumentparser._ArgumentParser

parse(signatures, 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.Enum

Bases: object

class robot.running.arguments.argumentspec.ArgumentSpec(name=None, type='Keyword', positional_only=None, positional_or_named=None, var_positional=None, named_only=None, var_named=None, defaults=None, types=None)

Bases: object

types

positional

minargs

maxargs

argument_names

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

map(positional, named, replace_defaults=True)

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

Bases: object

NOTSET = <object object>

POSITIONAL_ONLY = 'POSITIONAL_ONLY'

POSITIONAL_ONLY_MARKER = 'POSITIONAL_ONLY_MARKER'

POSITIONAL_OR_NAMED = 'POSITIONAL_OR_NAMED'

VAR_POSITIONAL = 'VAR_POSITIONAL'

NAMED_ONLY_MARKER = 'NAMED_ONLY_MARKER'

NAMED_ONLY = 'NAMED_ONLY'

VAR_NAMED = 'VAR_NAMED'

types

required

types_reprs

default_repr

robot.running.arguments.argumentvalidator module

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

Bases: object

validate(positional, named, dryrun=False)

robot.running.arguments.embedded module

class robot.running.arguments.embedded.EmbeddedArguments(name)

Bases: object

class robot.running.arguments.embedded.EmbeddedArgumentParser

Bases: object

parse(string)

robot.running.arguments.javaargumentcoercer module

robot.running.arguments.py2argumentparser module

class robot.running.arguments.py2argumentparser.PythonArgumentParser(type='Keyword')

Bases: object

parse(handler, name=None)

robot.running.arguments.py3argumentparser module

robot.running.arguments.typeconverters module

class robot.running.arguments.typeconverters.Enum

Bases: object

class robot.running.arguments.typeconverters.TypeConverter(used_type)

Bases: object

type = None

type_name = None

abc = None

aliases = ()

value_types = (<type 'unicode'>,)

classmethod register(converter)

classmethod converter_for(type_)

classmethod handles(type_)

convert(name, value, explicit_type=True, strict=True)

no_conversion_needed(value)

class robot.running.arguments.typeconverters.EnumConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of Enum

type_name

value_types

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.StringConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.unicode

type_name = 'string'

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

abc = None

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

value_types = (<type 'unicode'>,)

class robot.running.arguments.typeconverters.BooleanConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

value_types = (<type 'unicode'>, <type 'int'>, <type 'float'>, <type 'NoneType'>)

type

alias of __builtin__.bool

type_name = 'boolean'

aliases = ('bool',)

abc = None

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.IntegerConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.int

abc

alias of numbers.Integral

type_name = 'integer'

aliases = ('int', 'long')

value_types = (<type 'unicode'>, <type 'float'>)

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.FloatConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.float

abc

alias of numbers.Real

type_name = 'float'

aliases = ('double',)

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

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.DecimalConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of decimal.Decimal

type_name = 'decimal'

value_types = (<type 'unicode'>, <type 'int'>, <type 'float'>)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.BytesConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.str

abc = None

type_name = 'bytes'

value_types = (<type 'unicode'>, <type 'bytearray'>)

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.ByteArrayConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.bytearray

type_name = 'bytearray'

value_types = (<type 'unicode'>, <type 'str'>)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.DateTimeConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of datetime.datetime

type_name = 'datetime'

value_types = (<type 'unicode'>, <type 'int'>, <type 'float'>)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.DateConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of datetime.date

type_name = 'date'

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

value_types = (<type 'unicode'>,)

class robot.running.arguments.typeconverters.TimeDeltaConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of datetime.timedelta

type_name = 'timedelta'

value_types = (<type 'unicode'>, <type 'int'>, <type 'float'>)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.NoneConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.NoneType

type_name = 'None'

classmethod handles(type_)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

no_conversion_needed(value)

classmethod register(converter)

value_types = (<type 'unicode'>,)

class robot.running.arguments.typeconverters.ListConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.list

type_name = 'list'

abc

alias of _abcoll.Sequence

value_types = (<type 'unicode'>, <type 'tuple'>)

no_conversion_needed(value)

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

classmethod register(converter)

class robot.running.arguments.typeconverters.TupleConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.tuple

type_name = 'tuple'

value_types = (<type 'unicode'>, <type 'list'>)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.DictionaryConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.dict

abc

alias of _abcoll.Mapping

type_name = 'dictionary'

aliases = ('dict', 'map')

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

value_types = (<type 'unicode'>,)

class robot.running.arguments.typeconverters.SetConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.set

type_name = 'set'

value_types = (<type 'unicode'>, <type 'frozenset'>, <type 'list'>, <type 'tuple'>, <class '_abcoll.Mapping'>)

abc

alias of _abcoll.Set

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.FrozenSetConverter(used_type)

Bases: robot.running.arguments.typeconverters.TypeConverter

type

alias of __builtin__.frozenset

type_name = 'frozenset'

value_types = (<type 'unicode'>, <type 'set'>, <type 'list'>, <type 'tuple'>, <class '_abcoll.Mapping'>)

abc = None

aliases = ()

convert(name, value, explicit_type=True, strict=True)

classmethod converter_for(type_)

classmethod handles(type_)

no_conversion_needed(value)

classmethod register(converter)

class robot.running.arguments.typeconverters.CombinedConverter(union)

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)

classmethod converter_for(type_)

classmethod register(converter)

value_types = (<type 'unicode'>,)

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)