diff options
Diffstat (limited to 'python-attrs-strict.spec')
| -rw-r--r-- | python-attrs-strict.spec | 477 |
1 files changed, 477 insertions, 0 deletions
diff --git a/python-attrs-strict.spec b/python-attrs-strict.spec new file mode 100644 index 0000000..f7387db --- /dev/null +++ b/python-attrs-strict.spec @@ -0,0 +1,477 @@ +%global _empty_manifest_terminate_build 0 +Name: python-attrs-strict +Version: 1.0.0 +Release: 1 +Summary: Runtime validators for attrs +License: Apache-2.0 +URL: https://github.com/bloomberg/attrs-strict +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/9a/11/f753d21da36bc7218930d423f10c284530e316058ffbe9e1691651ce7b25/attrs_strict-1.0.0.tar.gz +BuildArch: noarch + +Requires: python3-attrs +Requires: python3-typing-extensions +Requires: python3-Sphinx +Requires: python3-covdefaults +Requires: python3-pytest +Requires: python3-pytest-cov + +%description + + +[](https://badge.fury.io/py/attrs-strict) +[](https://pypi.org/project/attrs-strict/) +[](https://pypi.org/project/attrs-strict) +[](https://github.com/bloomberg/attrs-strict/actions) +[](https://github.com/psf/black) + +# attrs runtime validation + +`attrs-strict` is a Python package which contains runtime validation for +[`attrs`](https://github.com/python-attrs/attrs) data classes based on the types existing in the typing module. + + + +## Rationale + +The purpose of the library is to provide runtime validation for attributes specified in +[`attrs`](https://www.attrs.org/en/stable/) 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 +[`here`](https://pypi.org/project/typing/). + +## Quick Start + +Type enforcement is based on the `type` attribute set on any field specified in an `attrs` dataclass. If the type +argument is not specified, no validation takes place. + +`pip install attrs-strict` + +```python +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)) +``` + +```console +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. + +```python +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) +``` + +```console +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 `typing` module: `List`, `Dict`, `DefaultDict`, +`Set`, `Union`, `Tuple`, `NewType` `Callable`, `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 +`python2`. + +`Literal` only allows using instances of `int`, `str`, `bool`, `Enum` or valid `Literal` types. Type checking `Literal` +with any other type as argument raises `attrs_strict._error.UnsupportedLiteralError`. + +```python +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) +``` + +`TypeVars` or `Generics` are not supported yet but there are plans to support this in the future. + +## Building + +For development, the project uses [`tox`](http://tox.readthedocs.org/) 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 `tox` in +the root of the project. + +## Installation + +Run `pip install attrs-strict` to install the latest stable version from [PyPi](https://pypi.org/project/attrs-strict/). +Documentation is hosted on [readthedocs](https://attrs-strict.readthedocs.io/en/latest/). + +For the latest version, on github `pip install git+https://github.com/bloomberg/attrs-strict`. + + + + + +%package -n python3-attrs-strict +Summary: Runtime validators for attrs +Provides: python-attrs-strict +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-attrs-strict + + +[](https://badge.fury.io/py/attrs-strict) +[](https://pypi.org/project/attrs-strict/) +[](https://pypi.org/project/attrs-strict) +[](https://github.com/bloomberg/attrs-strict/actions) +[](https://github.com/psf/black) + +# attrs runtime validation + +`attrs-strict` is a Python package which contains runtime validation for +[`attrs`](https://github.com/python-attrs/attrs) data classes based on the types existing in the typing module. + + + +## Rationale + +The purpose of the library is to provide runtime validation for attributes specified in +[`attrs`](https://www.attrs.org/en/stable/) 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 +[`here`](https://pypi.org/project/typing/). + +## Quick Start + +Type enforcement is based on the `type` attribute set on any field specified in an `attrs` dataclass. If the type +argument is not specified, no validation takes place. + +`pip install attrs-strict` + +```python +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)) +``` + +```console +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. + +```python +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) +``` + +```console +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 `typing` module: `List`, `Dict`, `DefaultDict`, +`Set`, `Union`, `Tuple`, `NewType` `Callable`, `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 +`python2`. + +`Literal` only allows using instances of `int`, `str`, `bool`, `Enum` or valid `Literal` types. Type checking `Literal` +with any other type as argument raises `attrs_strict._error.UnsupportedLiteralError`. + +```python +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) +``` + +`TypeVars` or `Generics` are not supported yet but there are plans to support this in the future. + +## Building + +For development, the project uses [`tox`](http://tox.readthedocs.org/) 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 `tox` in +the root of the project. + +## Installation + +Run `pip install attrs-strict` to install the latest stable version from [PyPi](https://pypi.org/project/attrs-strict/). +Documentation is hosted on [readthedocs](https://attrs-strict.readthedocs.io/en/latest/). + +For the latest version, on github `pip install git+https://github.com/bloomberg/attrs-strict`. + + + + + +%package help +Summary: Development documents and examples for attrs-strict +Provides: python3-attrs-strict-doc +%description help + + +[](https://badge.fury.io/py/attrs-strict) +[](https://pypi.org/project/attrs-strict/) +[](https://pypi.org/project/attrs-strict) +[](https://github.com/bloomberg/attrs-strict/actions) +[](https://github.com/psf/black) + +# attrs runtime validation + +`attrs-strict` is a Python package which contains runtime validation for +[`attrs`](https://github.com/python-attrs/attrs) data classes based on the types existing in the typing module. + + + +## Rationale + +The purpose of the library is to provide runtime validation for attributes specified in +[`attrs`](https://www.attrs.org/en/stable/) 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 +[`here`](https://pypi.org/project/typing/). + +## Quick Start + +Type enforcement is based on the `type` attribute set on any field specified in an `attrs` dataclass. If the type +argument is not specified, no validation takes place. + +`pip install attrs-strict` + +```python +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)) +``` + +```console +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. + +```python +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) +``` + +```console +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 `typing` module: `List`, `Dict`, `DefaultDict`, +`Set`, `Union`, `Tuple`, `NewType` `Callable`, `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 +`python2`. + +`Literal` only allows using instances of `int`, `str`, `bool`, `Enum` or valid `Literal` types. Type checking `Literal` +with any other type as argument raises `attrs_strict._error.UnsupportedLiteralError`. + +```python +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) +``` + +`TypeVars` or `Generics` are not supported yet but there are plans to support this in the future. + +## Building + +For development, the project uses [`tox`](http://tox.readthedocs.org/) 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 `tox` in +the root of the project. + +## Installation + +Run `pip install attrs-strict` to install the latest stable version from [PyPi](https://pypi.org/project/attrs-strict/). +Documentation is hosted on [readthedocs](https://attrs-strict.readthedocs.io/en/latest/). + +For the latest version, on github `pip install git+https://github.com/bloomberg/attrs-strict`. + + + + + +%prep +%autosetup -n attrs-strict-1.0.0 + +%build +%py3_build + +%install +%py3_install +install -d -m755 %{buildroot}/%{_pkgdocdir} +if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi +if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi +if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi +if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi +pushd %{buildroot} +if [ -d usr/lib ]; then + find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/lib64 ]; then + find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/bin ]; then + find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst +fi +if [ -d usr/sbin ]; then + find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst +fi +touch doclist.lst +if [ -d usr/share/man ]; then + find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst +fi +popd +mv %{buildroot}/filelist.lst . +mv %{buildroot}/doclist.lst . + +%files -n python3-attrs-strict -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 1.0.0-1 +- Package Spec generated |