Runtime validators for attrs
attrs runtime validation
attrs-strict is a Python package which contains runtime validation for
attrs data classes based on the types
existing in the typing module.
The purpose of the library is to provide runtime validation for attributes
attrs data classes. The types
supported are all the builtin types and most of the ones defined in the typing
library. For Python 2, the typing module is available through the backport found
Type enforcement is based on the
type attribute set on any field specified in
attrs dataclass. If the type argument is not specified, no validation takes
pip install attrs-strict
from typing import List import attr from attrs_strict import type_validator @attr.s class SomeClass(object): list_of_numbers = attr.ib(validator=type_validator(), type=List[int]) sc = SomeClass([1, 2, 3, 4]) print(sc) SomeClass(list_of_numbers=[1, 2, 3, 4]) try: SomeClass([1, 2, 3, "four"]) except ValueError as exception: print(repr(exception))
SomeClass(list_of_numbers=[1, 2, 3, 4]) <list_of_numbers must be typing.List[int] (got four that is a <class 'str'>) in [1, 2, 3, 'four']>
Nested type exceptions are validated accordingly, and a backtrace to the initial container is maintained to ease with debugging. This means that if an exception occurs because a nested element doesn't have the correct type, the representation of the exception will contain the path to the specific element that caused the exception.
from typing import List, Tuple import attr from attrs_strict import type_validator @attr.s class SomeClass(object): names = attr.ib(validator=type_validator(), type=List[Tuple[str, str]]) try: SomeClass(names=[("Moo", "Moo"), ("Zoo", 123)]) except ValueError as exception: print(exception)
names must be typing.List[typing.Tuple[str, str]] (got 123 that is a <class 'int'>) in ('Zoo', 123) in [('Moo', 'Moo'), ('Zoo', 123)]
What is currently supported ?
Currently, there's support for simple types and types specified in the
Literal and any combination of them. This means that you can
specify nested types like
List[List[Dict[int, str]]] and the validation would
check if attribute has the specific type.
Callable will validate if the callable function's annotation matches the type
definition. If type does not specify any annotations then all callables will
pass the validation against it. Support for
Callable is not available for
Literal only allows using instances of
Enum or valid
Literal types. Type checking
Literal with any other type as argument raises
def fully_annotated_function(self, a: int, b: int) -> str: ... def un_annonated_function(a, b): ... @attr.s class Something(object): a = attr.ib( validator=type_validator(), type=typing.Callable ) # Will work for any callable b = attr.ib(validator=type_validator(), type=typing.Callable[[int, int], str]) Something(a=un_annonated_function, b=fully_annotated_function)
Generics are not supported yet but there are plans to support
this in the future.
For development, the project uses
tox in order
to install dependencies, run tests and generate documentation. In order to be
able to do this, you need tox
pip install tox and after that invoke
the root of the project.
For the latest version, on github
pip install git+https://github.com/bloomberg/attrs-strict.
Release history Release notifications | RSS feed
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Hashes for attrs_strict-0.2.1-py2.py3-none-any.whl