معرفی شرکت ها
chainable-validators-0.8.2
تبلیغات ما
مشتریان به طور فزاینده ای آنلاین هستند. تبلیغات می تواند به آنها کمک کند تا کسب و کار شما را پیدا کنند.
مشاهده بیشتر
تبلیغات ما
مشتریان به طور فزاینده ای آنلاین هستند. تبلیغات می تواند به آنها کمک کند تا کسب و کار شما را پیدا کنند.
مشاهده بیشتر
تبلیغات ما
مشتریان به طور فزاینده ای آنلاین هستند. تبلیغات می تواند به آنها کمک کند تا کسب و کار شما را پیدا کنند.
مشاهده بیشتر
تبلیغات ما
مشتریان به طور فزاینده ای آنلاین هستند. تبلیغات می تواند به آنها کمک کند تا کسب و کار شما را پیدا کنند.
مشاهده بیشتر
تبلیغات ما
مشتریان به طور فزاینده ای آنلاین هستند. تبلیغات می تواند به آنها کمک کند تا کسب و کار شما را پیدا کنند.
مشاهده بیشترتوضیحات
Python data validation framework that uses chainable validator
| ویژگی | مقدار |
|---|---|
| سیستم عامل | - |
| نام فایل | chainable-validators-0.8.2 |
| نام | chainable-validators |
| نسخه کتابخانه | 0.8.2 |
| نگهدارنده | [] |
| ایمیل نگهدارنده | [] |
| نویسنده | Outernet Inc |
| ایمیل نویسنده | apps@outernet.is |
| آدرس صفحه اصلی | https://github.com/Outernet-Project/chainable-validators |
| آدرس اینترنتی | https://pypi.org/project/chainable-validators/ |
| مجوز | GPLv3 |
====================
Chainable Validators
====================
This package contains a set of simple functions to facilitate creation of
chainable validator methods for developing data validation schemata.
Although it provides a few validation function, it's main purpose is
extensibility.
Installing
==========
The PyPI package name is ``chainable-validators``. You can install the package
using ``pip`` or ``easy_install``::
pip install chainable-validators
easy_install chainable-validators
Basic concepts
==============
The basis of all validation are chainable validators (validation functions) and
the validation chains which are created using ``make_chain()`` calls.
The chainable validators are found in the ``validators.validators`` module. For
convenience, they can be imported directly from the ``validators`` package::
>>> from validators import required, istype, gte
The chainable validators can be used stand-alone or as part of a chain. For
standalone usage, pass the value to the validator. ::
>>> required(None)
Traceback (most recent call last):
...
ValueError: required value missing
Some validators are parametric. They are first invoked with a parameter, and
the return value is then used as a chainable validator. ::
>>> isint = istype(int)
>>> isint('foo')
Traceback (most recent call last):
...
ValueError: not int
To build a chain of desired validators, we first compile a list of chainable
validators::
>>> from validators import make_chain
>>> fns = [required, istype(int), gte(2)]
>>> chain = make_chain(fns)
>>> chain(None)
Traceback (most recent call last):
...
ValueError: required value missing
>>> chain('1')
Traceback (most recent call last):
...
ValueError: not int
>>> chain(1)
Traceback (most recent call last):
...
ValueError: value too small
>>> chain(3)
3
The validators in the chain are invoked in order until the last one is called,
or ``ValueError`` or ``validators.ReturnEarly`` is raised. When no exceptions
are raised, the return value of the last chainable validator is returned. In
case ``ReturnEarly`` is raised, it is not propagated to the chain's caller, but
instead the original value is returned.
List of built-in validators
===========================
The following is a list of built-in vaidators.
Validators can be parametric or simple. Simple validators can be used directly.
Parametric validators take an argument and return a chainable validator
functions.
In the list below, if you encounter a validator that looks like ``foo(bar)``,
it's a parametric validator.
- ``optional(default=None)`` - interrupts validation chain if value is None or
a user-supplied default value
- ``required`` - rejects None
- ``nonemtpy`` - rejects empty sequences (string, list, dict)
- ``boolean`` - reject non-boolean values (other than True, False, 1, and 0)
- ``istype(t)`` - rejects values that are not of type ``t``
- ``isin(collection)`` - rejects values that are not in ``collection``
(collection is a sequence such as string, list, or dict)
- ``gte(num)`` - rejects values that are not greater than or equal to ``num``
- ``lte(num)`` - rejects values that are not less than or equal to ``num``
- ``match(regex)`` - rejects values that do not match the ``regex`` object
(``regex`` object is a valid ``re.RegExp`` instance or object with a
``match()`` method)
- ``url`` - rejects values that are not URLs
- ``timestamp(fmt)`` - rejects values that cannot be converted to ``datetime``
using ``datetime.strptime()`` and given format string
Helper functions
================
There are a few helper functions that help you modify the behavior or one or
more functions in the chain.
- ``OR(*fns)`` - rejects value if and only if all of the functions passed to it
fail to validate, otherwise passes
- ``NOT(fn)`` - reverses the behavior of ``fn``
For example::
>>> my_chain = [foo, OR(bar, baz), NOT(fam)]
This chain will validate using ``foo`` first, then either ``bar`` or ``baz``
(whichever passes), then ``fam``, reversing the results of ``fam`` (if it
raises, then the validation will succeed and vice versa).
Spec validator
==============
Another helper function, that is not mentioned in the previous section, is
``spec_validator()`` factory function. It takes a spec, which is a dict mapping
key/attribute names to chains and returns a validator function that validates
objects.
Let's take a look at an example, and then explain things as we go::
>>> import re
>>> from validator import *
>>> spec = {
... 'foo': [required, istype(int)],
... 'bar': [optional, match(re.compile(r'te.*')],
... 'baz': [optional, boolean]
... }
Each key in spec represents the key we expect to find in the object. The key
could be a dictionary key, list/tuple index, or an object attribute. It could
also be an arbitrary value based on which the value will be extracted.
The way keys map to values is defined by a key function which can be passed
using the ``key`` argument. This function must accept a spec key name and
return a function that returns the value given an object. The default key
function is ``operator.itemgetter``. For example, if we have an object that as
attributes we want to validate, we could create the validator like so::
>>> import operator
>>> attr_validator = spec_validator(spec, key=operator.attrgetter)
Each key maps to an iterable which represents the validator chain. Chains are
applied to values matching the key.
The ``spec_validator()`` function returns a validator function. ::
>>> validator = spec_validator(spec)
When passed the object to be validated, the validator function returns a dict
which maps keys to any ``ValueError`` exceptions raised by the individual
chains. If data is valid, the dict is empty. ::
>>> data = {'foo': 1, 'bar': 'test', 'baz': None}
>>> validator(data)
{}
>>> data['foo'] = None
>>> validator(data)
{'foo': ValueError('required value is missing')}
Thanks to this behavior, you can test whether object is valid, by testing if
the returned dict is empty.
Writing your own validators
===========================
It is possible to write your own validators. To write a simple chainable
validator, use the ``validators.chain.chainable`` decorator. ::
>>> from validators import chainable
>>> @chainable
... def my_validator(s):
... if not s.startswith('foo'):
... raise ValueError('does not start with foo')
... return s
...
>>> my_validator('foobar')
'foobar'
>>> my_validator('barfoo')
Traceback (most recent call last):
...
ValueError: does not start with foo
To write a parametric validator, define the chainable validator in a closure::
>>> def my_parametric(start):
... @chainable
... def validator(s):
... if not s.startswith(start):
... raise ValueError('does not sart with {}'.format(start))
... return s
... return validator
...
>>> validator = my_parametric('baz')
>>> validator('bazfoo')
'bazfoo'
>>> validator('foo')
Traceback (most recent call last):
...
ValueError: does not sart with baz
Now you can use these validators in chains like other validators.
Reporting bugs
==============
Please report any bugs or feature requests to the `issue tracker`_.
.. _issue tracker: https://github.com/Outernet-Project/chainable-validators/issues
نحوه نصب
نصب پکیج whl chainable-validators-0.8.2:
pip install chainable-validators-0.8.2.whl
نصب پکیج tar.gz chainable-validators-0.8.2:
pip install chainable-validators-0.8.2.tar.gz