typedload Module to load data into typed data structures

Classes

Loader

A loader object that recursively loads data into the desired type.

basictypes: a set of types that are considered as building blocks for everything else and do not need to be converted further. If you are not loading from json, you probably want to add bytes to the set.

failonextra: Disabled by default. When enabled, the loader will raise exceptions if there are fields in the data that are not being used by the type.

basiccast: Enabled by default. When disabled, instead of trying to perform casts, exceptions will be raised. Since many json seem to encode numbers as strings, to avoid extra complications this functionality is provided. If you know that your original data is encoded properly, it is better to disable this.

dictequivalence: Enabled by default. Automatically convert dict-like classes to dictionary when loading. This enables them to be loaded into other classes. At the moment it supports: argparse.Namespace

raiseconditionerrors: Enabled by default. Raises exceptions when evaluating a condition from an handler. When disabled, the exceptions are not raised and the condition is considered False.

uniondebugconflict: Disabled by default When enabled, all the possible types for the unions are evaluated instead of stopping at the first that works. If more than one type in the union works, an error is raised because the types are conflicting and the union might return different types with the same input value. This option makes the loading slower and is only to be used when debugging issues.

mangle_key: Defaults to 'name' Specifies which key is used into the metadata dictionaries to perform name-mangling.

handlers: This is the list that the loader uses to perform its task. The type is: list[ tuple[ Callable[[Type[T]], bool], Callable[['Loader', Any, Type[T]], T] ] ]

The elements are: tuple[Condition, Loader]
Condition(type) -> Bool
Loader(loader, value, type) -> type

In most cases, it is sufficient to append new elements
at the end, to handle more types.

There is an internal cache to speed up lookup, so after the
first call to load, this should no longer be modified.

strconstructed: Set of types to construct from a string.

iterstr: Defaults to False If set, str objects are considered iterable and can be used to be loaded into list[str] or similar. This was the default behaviour previously. From 2.38 loading a string into list[str] will fail. You can restore the previous unintended behaviour by setting this to True.

frefs: Dictionary to resolve ForwardRef. Something like class Node(NamedTuple): next: 'Node' | None

requires a ForwardRef (also in python3.7), which means that the type
is stored as string and must be resolved at runtime.

This dictionary contains the names of the types as keys, and the
actual types as values.

A loader object by default starts with an empty dictionary and
fills it with the types it encounters, but it is possible to
manually add more types to the dictionary.

Setting this to None disables any support for ForwardRef.

Reusing the same loader object on unrelated types might cause
failures, if the types are different but use the same names.

pep563: Set to true to use future.annotations WARNING: DEPRECATED Support for this might be removed in any future release without notice.

Check deferred evaluation in the documentation for more details.

This will make typedload much slower.

This PEP is broken and superseeded by PEP649.

Do not report bugs about this "feature". It's not here to stay.

These parameters can be set as named arguments in the constructor or they can be set later on.

The constructor will accept any named argument, but only the documented ones have any effect. This is to allow custom handlers to have their own parameters as well.

Because internal caches are used, after the first call to load() these properties should no longer be modified.

Using unions is complicated. The best is to use tagged unions using a Literal field. If the types in the union are too similar to each other, it is easy to obtain an unexpected type.