Skip to content

robot.running.arguments.typeinfo

TypeInfo 

1
2
3
4
5
TypeInfo(
    name: str | None = None,
    type: Any = NOT_SET,
    nested: Sequence[TypeInfo] | None = None,
)

Represents an argument type.

Normally created using the :meth:from_type_hint classmethod. With unions and parametrized types, :attr:nested contains nested types.

Values can be converted according to this type info by using the :meth:convert method.

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

Source code in src/robot/running/arguments/typeinfo.py 
 93
 94
 95
 96
 97
 98
 99
100
def __init__(self, name: 'str|None' = None,
             type: Any = NOT_SET,
             nested: 'Sequence[TypeInfo]|None' = None):
    if type is NOT_SET:
        type = TYPE_NAMES.get(name.lower()) if name else None
    self.name = name
    self.type = type
    self.nested = nested

nested 

1
2
3
nested(
    nested: Sequence[TypeInfo],
) -> tuple[TypeInfo, ...] | None

Nested types as a tuple of TypeInfo objects.

Used with parameterized types and unions.

Source code in src/robot/running/arguments/typeinfo.py 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
@setter
def nested(self, nested: 'Sequence[TypeInfo]') -> 'tuple[TypeInfo, ...]|None':
    """Nested types as a tuple of ``TypeInfo`` objects.

    Used with parameterized types and unions.
    """
    typ = self.type
    if self.is_union:
        self._validate_union(nested)
    elif nested is None:
        return None
    elif typ is None:
        return tuple(nested)
    elif typ is Literal:
        self._validate_literal(nested)
    elif not isinstance(typ, type):
        self._report_nested_error(nested)
    elif issubclass(typ, tuple):
        if nested[-1].type is Ellipsis:
            self._validate_nested_count(nested, 2, 'Homogenous tuple', offset=-1)
    elif issubclass(typ, Sequence) and not issubclass(typ, (str, bytes, bytearray)):
        self._validate_nested_count(nested, 1)
    elif issubclass(typ, Set):
        self._validate_nested_count(nested, 1)
    elif issubclass(typ, Mapping):
        self._validate_nested_count(nested, 2)
    elif typ in TYPE_NAMES.values():
        self._report_nested_error(nested)
    return tuple(nested)

from_type_hint classmethod 

1
from_type_hint(hint: Any) -> TypeInfo

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 :class: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 :meth:from_sequence may be more appropriate than using this generic method.

Source code in src/robot/running/arguments/typeinfo.py 
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
@classmethod
def from_type_hint(cls, hint: Any) -> 'TypeInfo':
    """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 :class:`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 :meth:`from_sequence`
    may be more appropriate than using this generic method.
    """
    if hint is NOT_SET:
        return cls()
    if isinstance(hint, ForwardRef):
        hint = hint.__forward_arg__
    if isinstance(hint, typeddict_types):
        return TypedDictInfo(hint.__name__, hint)
    if is_union(hint):
        nested = [cls.from_type_hint(a) for a in hint.__args__]
        return cls('Union', nested=nested)
    if hasattr(hint, '__origin__'):
        if hint.__origin__ is Literal:
            nested = [cls(repr(a) if not isinstance(a, Enum) else a.name, a)
                      for a in hint.__args__]
        elif has_args(hint):
            nested = [cls.from_type_hint(a) for a in hint.__args__]
        else:
            nested = None
        return cls(type_repr(hint, nested=False), hint.__origin__, nested)
    if isinstance(hint, str):
        return cls.from_string(hint)
    if isinstance(hint, (tuple, list)):
        return cls.from_sequence(hint)
    if isinstance(hint, type):
        return cls(type_repr(hint), hint)
    if hint is None:
        return cls('None', type(None))
    if hint is Union:    # Plain `Union` without params.
        return cls('Union')
    if hint is Any:
        return cls('Any', hint)
    if hint is Ellipsis:
        return cls('...', hint)
    return cls(str(hint))

from_type classmethod 

1
from_type(hint: type) -> TypeInfo

Construct a TypeInfo based on an actual type.

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

Source code in src/robot/running/arguments/typeinfo.py 
215
216
217
218
219
220
221
222
@classmethod
def from_type(cls, hint: type) -> 'TypeInfo':
    """Construct a ``TypeInfo`` based on an actual type.

    Use :meth:`from_type_hint` if the type hint can also be something else
    than a concrete type such as a string.
    """
    return cls(type_repr(hint), hint)

from_string classmethod 

1
from_string(hint: str) -> TypeInfo

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 :meth:from_type_hint if the type hint can also be something else than a string such as an actual type.

Source code in src/robot/running/arguments/typeinfo.py 
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
@classmethod
def from_string(cls, hint: str) -> 'TypeInfo':
    """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 :meth:`from_type_hint` if the type hint can also be something else
    than a string such as an actual type.
    """
    # Needs to be imported here due to cyclic dependency.
    from .typeinfoparser import TypeInfoParser
    try:
        return TypeInfoParser(hint).parse()
    except ValueError as err:
        raise DataError(str(err))

from_sequence classmethod 

1
from_sequence(sequence: tuple | list) -> TypeInfo

Construct a TypeInfo based on a sequence of types.

Types can be actual types, strings, or anything else accepted by :meth: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 :meth:from_type_hint if other types than sequences need to supported.

Source code in src/robot/running/arguments/typeinfo.py 
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
@classmethod
def from_sequence(cls, sequence: 'tuple|list') -> 'TypeInfo':
    """Construct a ``TypeInfo`` based on a sequence of types.

    Types can be actual types, strings, or anything else accepted by
    :meth:`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 :meth:`from_type_hint` if other types than sequences need to
    supported.
    """
    infos = []
    for typ in sequence:
        info = cls.from_type_hint(typ)
        if info.is_union:
            infos.extend(info.nested)
        else:
            infos.append(info)
    if len(infos) == 1:
        return infos[0]
    return cls('Union', nested=infos)

convert 

1
2
3
4
5
6
7
8
9
convert(
    value: Any,
    name: str | None = None,
    custom_converters: (
        CustomArgumentConverters | dict | None
    ) = None,
    languages: LanguagesLike = None,
    kind: str = "Argument",
)

Convert value based on type information this TypeInfo contains.

:param value: Value to convert. :param name: Name of the argument or other thing to convert. Used only for error reporting. :param custom_converters: Custom argument converters. :param languages: Language configuration. During execution, uses the current language configuration by default. :param kind: Type of the thing to be converted. Used only for error reporting. :raises: TypeError if there is no converter for this type or ValueError is conversion fails. :return: Converted value.

Source code in src/robot/running/arguments/typeinfo.py 
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
def convert(self, value: Any,
            name: 'str|None' = None,
            custom_converters: 'CustomArgumentConverters|dict|None' = None,
            languages: 'LanguagesLike' = None,
            kind: str = 'Argument'):
    """Convert ``value`` based on type information this ``TypeInfo`` contains.

    :param value: Value to convert.
    :param name: Name of the argument or other thing to convert.
        Used only for error reporting.
    :param custom_converters: Custom argument converters.
    :param languages: Language configuration. During execution, uses the
        current language configuration by default.
    :param kind: Type of the thing to be converted.
        Used only for error reporting.
    :raises: ``TypeError`` if there is no converter for this type or
        ``ValueError`` is conversion fails.
    :return: Converted value.
    """
    if isinstance(custom_converters, dict):
        custom_converters = CustomArgumentConverters.from_dict(custom_converters)
    if not languages and EXECUTION_CONTEXTS.current:
        languages = EXECUTION_CONTEXTS.current.languages
    elif not isinstance(languages, Languages):
        languages = Languages(languages)
    converter = TypeConverter.converter_for(self, custom_converters, languages)
    if not converter:
        raise TypeError(f"No converter found for '{self}'.")
    return converter.convert(value, name, kind)

TypedDictInfo 

1
TypedDictInfo(name: str, type: type)

Bases: TypeInfo

Represents TypedDict used as an argument.

Source code in src/robot/running/arguments/typeinfo.py 
315
316
317
318
319
320
321
322
323
def __init__(self, name: str, type: type):
    super().__init__(name, type)
    type_hints = self._get_type_hints(type)
    # __required_keys__ is new in Python 3.9.
    self.required = getattr(type, '__required_keys__', frozenset())
    if sys.version_info < (3, 11):
        self._handle_typing_extensions_required_and_not_required(type_hints)
    self.annotations = {name: TypeInfo.from_type_hint(hint)
                        for name, hint in type_hints.items()}

nested 

1
2
3
nested(
    nested: Sequence[TypeInfo],
) -> tuple[TypeInfo, ...] | None

Nested types as a tuple of TypeInfo objects.

Used with parameterized types and unions.

Source code in src/robot/running/arguments/typeinfo.py 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
@setter
def nested(self, nested: 'Sequence[TypeInfo]') -> 'tuple[TypeInfo, ...]|None':
    """Nested types as a tuple of ``TypeInfo`` objects.

    Used with parameterized types and unions.
    """
    typ = self.type
    if self.is_union:
        self._validate_union(nested)
    elif nested is None:
        return None
    elif typ is None:
        return tuple(nested)
    elif typ is Literal:
        self._validate_literal(nested)
    elif not isinstance(typ, type):
        self._report_nested_error(nested)
    elif issubclass(typ, tuple):
        if nested[-1].type is Ellipsis:
            self._validate_nested_count(nested, 2, 'Homogenous tuple', offset=-1)
    elif issubclass(typ, Sequence) and not issubclass(typ, (str, bytes, bytearray)):
        self._validate_nested_count(nested, 1)
    elif issubclass(typ, Set):
        self._validate_nested_count(nested, 1)
    elif issubclass(typ, Mapping):
        self._validate_nested_count(nested, 2)
    elif typ in TYPE_NAMES.values():
        self._report_nested_error(nested)
    return tuple(nested)

from_type_hint classmethod 

1
from_type_hint(hint: Any) -> TypeInfo

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 :class: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 :meth:from_sequence may be more appropriate than using this generic method.

Source code in src/robot/running/arguments/typeinfo.py 
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
@classmethod
def from_type_hint(cls, hint: Any) -> 'TypeInfo':
    """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 :class:`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 :meth:`from_sequence`
    may be more appropriate than using this generic method.
    """
    if hint is NOT_SET:
        return cls()
    if isinstance(hint, ForwardRef):
        hint = hint.__forward_arg__
    if isinstance(hint, typeddict_types):
        return TypedDictInfo(hint.__name__, hint)
    if is_union(hint):
        nested = [cls.from_type_hint(a) for a in hint.__args__]
        return cls('Union', nested=nested)
    if hasattr(hint, '__origin__'):
        if hint.__origin__ is Literal:
            nested = [cls(repr(a) if not isinstance(a, Enum) else a.name, a)
                      for a in hint.__args__]
        elif has_args(hint):
            nested = [cls.from_type_hint(a) for a in hint.__args__]
        else:
            nested = None
        return cls(type_repr(hint, nested=False), hint.__origin__, nested)
    if isinstance(hint, str):
        return cls.from_string(hint)
    if isinstance(hint, (tuple, list)):
        return cls.from_sequence(hint)
    if isinstance(hint, type):
        return cls(type_repr(hint), hint)
    if hint is None:
        return cls('None', type(None))
    if hint is Union:    # Plain `Union` without params.
        return cls('Union')
    if hint is Any:
        return cls('Any', hint)
    if hint is Ellipsis:
        return cls('...', hint)
    return cls(str(hint))

from_type classmethod 

1
from_type(hint: type) -> TypeInfo

Construct a TypeInfo based on an actual type.

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

Source code in src/robot/running/arguments/typeinfo.py 
215
216
217
218
219
220
221
222
@classmethod
def from_type(cls, hint: type) -> 'TypeInfo':
    """Construct a ``TypeInfo`` based on an actual type.

    Use :meth:`from_type_hint` if the type hint can also be something else
    than a concrete type such as a string.
    """
    return cls(type_repr(hint), hint)

from_string classmethod 

1
from_string(hint: str) -> TypeInfo

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 :meth:from_type_hint if the type hint can also be something else than a string such as an actual type.

Source code in src/robot/running/arguments/typeinfo.py 
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
@classmethod
def from_string(cls, hint: str) -> 'TypeInfo':
    """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 :meth:`from_type_hint` if the type hint can also be something else
    than a string such as an actual type.
    """
    # Needs to be imported here due to cyclic dependency.
    from .typeinfoparser import TypeInfoParser
    try:
        return TypeInfoParser(hint).parse()
    except ValueError as err:
        raise DataError(str(err))

from_sequence classmethod 

1
from_sequence(sequence: tuple | list) -> TypeInfo

Construct a TypeInfo based on a sequence of types.

Types can be actual types, strings, or anything else accepted by :meth: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 :meth:from_type_hint if other types than sequences need to supported.

Source code in src/robot/running/arguments/typeinfo.py 
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
@classmethod
def from_sequence(cls, sequence: 'tuple|list') -> 'TypeInfo':
    """Construct a ``TypeInfo`` based on a sequence of types.

    Types can be actual types, strings, or anything else accepted by
    :meth:`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 :meth:`from_type_hint` if other types than sequences need to
    supported.
    """
    infos = []
    for typ in sequence:
        info = cls.from_type_hint(typ)
        if info.is_union:
            infos.extend(info.nested)
        else:
            infos.append(info)
    if len(infos) == 1:
        return infos[0]
    return cls('Union', nested=infos)

convert 

1
2
3
4
5
6
7
8
9
convert(
    value: Any,
    name: str | None = None,
    custom_converters: (
        CustomArgumentConverters | dict | None
    ) = None,
    languages: LanguagesLike = None,
    kind: str = "Argument",
)

Convert value based on type information this TypeInfo contains.

:param value: Value to convert. :param name: Name of the argument or other thing to convert. Used only for error reporting. :param custom_converters: Custom argument converters. :param languages: Language configuration. During execution, uses the current language configuration by default. :param kind: Type of the thing to be converted. Used only for error reporting. :raises: TypeError if there is no converter for this type or ValueError is conversion fails. :return: Converted value.

Source code in src/robot/running/arguments/typeinfo.py 
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
def convert(self, value: Any,
            name: 'str|None' = None,
            custom_converters: 'CustomArgumentConverters|dict|None' = None,
            languages: 'LanguagesLike' = None,
            kind: str = 'Argument'):
    """Convert ``value`` based on type information this ``TypeInfo`` contains.

    :param value: Value to convert.
    :param name: Name of the argument or other thing to convert.
        Used only for error reporting.
    :param custom_converters: Custom argument converters.
    :param languages: Language configuration. During execution, uses the
        current language configuration by default.
    :param kind: Type of the thing to be converted.
        Used only for error reporting.
    :raises: ``TypeError`` if there is no converter for this type or
        ``ValueError`` is conversion fails.
    :return: Converted value.
    """
    if isinstance(custom_converters, dict):
        custom_converters = CustomArgumentConverters.from_dict(custom_converters)
    if not languages and EXECUTION_CONTEXTS.current:
        languages = EXECUTION_CONTEXTS.current.languages
    elif not isinstance(languages, Languages):
        languages = Languages(languages)
    converter = TypeConverter.converter_for(self, custom_converters, languages)
    if not converter:
        raise TypeError(f"No converter found for '{self}'.")
    return converter.convert(value, name, kind)