Index
47 | 48 |
49 |
50 |
51 |
52 |
53 | \
726 |
\
768 | ';
769 |
770 | var replyTemplate = '\
771 | \
727 |
\
744 | \
728 | \
729 | 
\
730 | \
731 | \
732 | 
\
733 | \
734 |
\
735 | \
736 | \
737 | 
\
738 | \
739 | \
740 | 
\
741 | \
742 |
\
743 | \
745 |
\
766 | \
767 | \ 746 | <%username%>\ 747 | \ 748 | <%time.delta%>\ 749 |
\ 750 |<#text#>
\
751 | \ 752 | \ 753 | reply ▿\ 754 | proposal ▹\ 755 | \ 756 | \ 757 | \ 760 |
\ 761 |\ 762 | <#proposal_diff#>\ 763 |\ 764 |
41 |
81 |
89 |
90 |
91 |
92 |
93 |
94 |
--------------------------------------------------------------------------------
/docs/_build/html/index.html:
--------------------------------------------------------------------------------
1 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
42 |
56 |
79 |
80 |
43 |
55 |
44 |
45 |
46 |
54 |
40 |
204 |
215 |
216 |
217 |
218 |
219 |
220 |
--------------------------------------------------------------------------------
/docs/_build/html/objects.inv:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/amirasaran/request_validator/0adb1aae3d4f32a4a8f6658e7e4f6b379545def5/docs/_build/html/objects.inv
--------------------------------------------------------------------------------
/docs/_build/html/search.html:
--------------------------------------------------------------------------------
1 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
41 |
165 |
202 |
203 |
42 |
164 |
43 |
44 |
163 |
45 |
49 | Welcome to Request Validator’s documentation!¶
46 |
47 |
48 |
50 |
57 | Indices and tables¶
51 |-
52 |
- Index 53 |
- Module Index 54 |
- Search Page 55 |
58 |
61 | Github¶
59 | 60 |
62 |
65 | request_validator¶
63 |Python Request(json) Validator
64 |
66 |
69 |
70 |
71 | how to install¶
67 |pip install request_validator
68 |
72 |
147 |
148 |
158 |
159 |
160 |
161 |
162 | How to use¶
73 |
74 |
77 | Imaging you have a json response that get from rest api server and you
75 | must validate response.
76 | sample:
78 |from request_validator.serializers import *
79 | from request_validator.fields import *
80 |
81 |
82 | class GlossDefSerializer(BaseSerializer):
83 | para = CharField()
84 | gloss_see_also = CharField(many=True, source="GlossSeeAlso")
85 |
86 |
87 | class GlossEntrySerializer(BaseSerializer):
88 | id = IntField(source="ID")
89 | sort_as = CharField(source="SortAs")
90 | gloss_term = CharField(source="GlossTerm")
91 | acronym = CharField(source="Acronym")
92 | abbrev = CharField(source="Abbrev", required=True, allow_blank=False)
93 | gloss_def = GlossDefSerializer(source="GlossDef")
94 | gloss_see = CharField(source="GlossSee")
95 |
96 |
97 | class GlossListSerializer(BaseSerializer):
98 | gloss_entry = GlossEntrySerializer(source="GlossEntry")
99 |
100 |
101 | class GlossDivSerializer(BaseSerializer):
102 | title = CharField()
103 | gloss_list = GlossListSerializer(source="GlossList")
104 |
105 |
106 | class GlossarySerializer(BaseSerializer):
107 | title = CharField()
108 | gloss_div = GlossDivSerializer(source="GlossDiv")
109 |
110 |
111 | class SampleSerializer(BaseSerializer):
112 | glossary = GlossarySerializer()
113 |
114 |
115 | sample_data = {
116 | "glossary": {
117 | "title": "example glossary",
118 | "GlossDiv": {
119 | "title": "S",
120 | "GlossList": {
121 | "GlossEntry": {
122 | "ID": 12,
123 | "SortAs": "SGML",
124 | "GlossTerm": "Standard Generalized Markup Language",
125 | "Acronym": "SGML",
126 | "Abbrev": "",
127 | "GlossDef": {
128 | "para": "A meta-markup language, used to create markup languages such as DocBook.",
129 | "GlossSeeAlso": ["GML", "XML"]
130 | },
131 | "GlossSee": "markup"
132 | }
133 | }
134 | }
135 | }
136 | }
137 |
138 |
139 | validator = SampleSerializer(data=sample_data)
140 | print('validation status:')
141 | print(validator.is_valid())
142 | print("\nvalidation errors:")
143 | print(validator.get_errors())
144 | print("\nvalidated data:")
145 | print(validator.validate_data())
146 | The above sample output:
149 |validation status:
150 | False
151 |
152 | validation errors:
153 | {'glossary': {'gloss_div': {'gloss_list': {'gloss_entry': {'abbrev': ['This field cannot be blank']}}}}}
154 |
155 | validated data:
156 | {'glossary': {'title': 'example glossary', 'gloss_div': {'title': 'S', 'gloss_list': {'gloss_entry': {'acronym': 'SGML', 'gloss_term': 'Standard Generalized Markup Language', 'gloss_def': {'gloss_see_also': ['GML', 'XML'], 'para': 'A meta-markup language, used to create markup languages such as DocBook.'}, 'gloss_see': 'markup', 'sort_as': 'SGML', 'id': 12}}}}}
157 |
48 |
91 |
99 |
100 |
101 |
102 |
103 |
104 |
--------------------------------------------------------------------------------
/docs/_build/html/searchindex.js:
--------------------------------------------------------------------------------
1 | Search.setIndex({docnames:["index"],envversion:51,filenames:["index.rst"],objects:{},objnames:{},objtypes:{},terms:{"class":0,"import":0,"true":0,The:0,abbrev:0,abov:0,acronym:0,allow_blank:0,amirasaran:0,api:0,baseseri:0,blank:0,cannot:0,charfield:0,com:0,creat:0,data:0,docbook:0,error:0,exampl:0,fals:0,field:0,from:0,gener:0,get:0,get_error:0,gloss_def:0,gloss_div:0,gloss_entri:0,gloss_list:0,gloss_se:0,gloss_see_also:0,gloss_term:0,glossari:0,glossaryseri:0,glossdef:0,glossdefseri:0,glossdiv:0,glossdivseri:0,glossentri:0,glossentryseri:0,glosslist:0,glosslistseri:0,glossse:0,glossseealso:0,glossterm:0,gml:0,have:0,http:0,imag:0,index:0,intfield:0,is_valid:0,json:0,languag:0,mani:0,markup:0,meta:0,modul:0,must:0,nvalid:0,output:0,page:0,para:0,pip:0,print:0,python:0,requir:0,respons:0,rest:0,sampl:0,sample_data:0,sampleseri:0,search:0,serial:0,server:0,sgml:0,sort_a:0,sorta:0,sourc:0,standard:0,statu:0,thi:0,titl:0,used:0,validate_data:0,xml:0,you:0},titles:["Welcome to Request Validator’s documentation!"],titleterms:{document:0,github:0,how:0,indic:0,instal:0,request:0,request_valid:0,tabl:0,use:0,valid:0,welcom:0}})
--------------------------------------------------------------------------------
/docs/conf.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | # -*- coding: utf-8 -*-
3 | #
4 | # Request Validator documentation build configuration file, created by
5 | # sphinx-quickstart on Tue Apr 4 15:20:38 2017.
6 | #
7 | # This file is execfile()d with the current directory set to its
8 | # containing dir.
9 | #
10 | # Note that not all possible configuration values are present in this
11 | # autogenerated file.
12 | #
13 | # All configuration values have a default; values that are commented out
14 | # serve to show the default.
15 |
16 | # If extensions (or modules to document with autodoc) are in another directory,
17 | # add these directories to sys.path here. If the directory is relative to the
18 | # documentation root, use os.path.abspath to make it absolute, like shown here.
19 | #
20 | # import os
21 | # import sys
22 | # sys.path.insert(0, os.path.abspath('.'))
23 |
24 |
25 | # -- General configuration ------------------------------------------------
26 |
27 | # If your documentation needs a minimal Sphinx version, state it here.
28 | #
29 | # needs_sphinx = '1.0'
30 |
31 | # Add any Sphinx extension module names here, as strings. They can be
32 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
33 | # ones.
34 | extensions = []
35 |
36 | # Add any paths that contain templates here, relative to this directory.
37 | templates_path = ['_templates']
38 |
39 | # The suffix(es) of source filenames.
40 | # You can specify multiple suffix as a list of string:
41 | #
42 | # source_suffix = ['.rst', '.md']
43 | source_suffix = '.rst'
44 |
45 | # The master toctree document.
46 | master_doc = 'index'
47 |
48 | # General information about the project.
49 | project = 'Request Validator'
50 | copyright = '2017, amir mohsen asaran'
51 | author = 'amir mohsen asaran'
52 |
53 | # The version info for the project you're documenting, acts as replacement for
54 | # |version| and |release|, also used in various other places throughout the
55 | # built documents.
56 | #
57 | # The short X.Y version.
58 | version = '1.1.0'
59 | # The full version, including alpha/beta/rc tags.
60 | release = '1.1.0'
61 |
62 | # The language for content autogenerated by Sphinx. Refer to documentation
63 | # for a list of supported languages.
64 | #
65 | # This is also used if you do content translation via gettext catalogs.
66 | # Usually you set "language" from the command line for these cases.
67 | language = None
68 |
69 | # List of patterns, relative to source directory, that match files and
70 | # directories to ignore when looking for source files.
71 | # This patterns also effect to html_static_path and html_extra_path
72 | exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
73 |
74 | # The name of the Pygments (syntax highlighting) style to use.
75 | pygments_style = 'sphinx'
76 |
77 | # If true, `todo` and `todoList` produce output, else they produce nothing.
78 | todo_include_todos = False
79 |
80 |
81 | # -- Options for HTML output ----------------------------------------------
82 |
83 | # The theme to use for HTML and HTML Help pages. See the documentation for
84 | # a list of builtin themes.
85 | #
86 | html_theme = 'alabaster'
87 |
88 | # Theme options are theme-specific and customize the look and feel of a theme
89 | # further. For a list of options available for each theme, see the
90 | # documentation.
91 | #
92 | # html_theme_options = {}
93 |
94 | # Add any paths that contain custom static files (such as style sheets) here,
95 | # relative to this directory. They are copied after the builtin static files,
96 | # so a file named "default.css" will overwrite the builtin "default.css".
97 | html_static_path = ['_static']
98 |
99 |
100 | # -- Options for HTMLHelp output ------------------------------------------
101 |
102 | # Output file base name for HTML help builder.
103 | htmlhelp_basename = 'RequestValidatordoc'
104 |
105 |
106 | # -- Options for LaTeX output ---------------------------------------------
107 |
108 | latex_elements = {
109 | # The paper size ('letterpaper' or 'a4paper').
110 | #
111 | # 'papersize': 'letterpaper',
112 |
113 | # The font size ('10pt', '11pt' or '12pt').
114 | #
115 | # 'pointsize': '10pt',
116 |
117 | # Additional stuff for the LaTeX preamble.
118 | #
119 | # 'preamble': '',
120 |
121 | # Latex figure (float) alignment
122 | #
123 | # 'figure_align': 'htbp',
124 | }
125 |
126 | # Grouping the document tree into LaTeX files. List of tuples
127 | # (source start file, target name, title,
128 | # author, documentclass [howto, manual, or own class]).
129 | latex_documents = [
130 | (master_doc, 'RequestValidator.tex', 'Request Validator Documentation',
131 | 'amir mohsen asaran', 'manual'),
132 | ]
133 |
134 |
135 | # -- Options for manual page output ---------------------------------------
136 |
137 | # One entry per manual page. List of tuples
138 | # (source start file, name, description, authors, manual section).
139 | man_pages = [
140 | (master_doc, 'requestvalidator', 'Request Validator Documentation',
141 | [author], 1)
142 | ]
143 |
144 |
145 | # -- Options for Texinfo output -------------------------------------------
146 |
147 | # Grouping the document tree into Texinfo files. List of tuples
148 | # (source start file, target name, title, author,
149 | # dir menu entry, description, category)
150 | texinfo_documents = [
151 | (master_doc, 'RequestValidator', 'Request Validator Documentation',
152 | author, 'RequestValidator', 'One line description of project.',
153 | 'Miscellaneous'),
154 | ]
155 |
156 |
157 |
158 |
--------------------------------------------------------------------------------
/docs/index.rst:
--------------------------------------------------------------------------------
1 | .. Request Validator documentation master file, created by
2 | sphinx-quickstart on Tue Apr 4 15:20:38 2017.
3 | You can adapt this file completely to your liking, but it should at least
4 | contain the root `toctree` directive.
5 |
6 | Welcome to Request Validator's documentation!
7 | =============================================
8 |
9 | .. toctree::
10 | :maxdepth: 2
11 | :caption: Contents:
12 |
13 |
14 |
15 | Indices and tables
16 | ==================
17 |
18 | * :ref:`genindex`
19 | * :ref:`modindex`
20 | * :ref:`search`
21 |
22 |
23 | Github
24 | ======
25 |
26 | https://github.com/amirasaran/request_validator
27 |
28 | request\_validator
29 | ==================
30 |
31 | Python Request(json) Validator
32 |
33 | how to install
34 | ==============
35 |
36 | ::
37 |
38 | pip install request_validator
39 |
40 | How to use
41 | ==========
42 |
43 | | Imaging you have a json response that get from rest api server and you
44 | | must validate response.
45 |
46 | **sample:**
47 |
48 | ::
49 |
50 | from request_validator.serializers import *
51 | from request_validator.fields import *
52 |
53 |
54 | class GlossDefSerializer(BaseSerializer):
55 | para = CharField()
56 | gloss_see_also = CharField(many=True, source="GlossSeeAlso")
57 |
58 |
59 | class GlossEntrySerializer(BaseSerializer):
60 | id = IntField(source="ID")
61 | sort_as = CharField(source="SortAs")
62 | gloss_term = CharField(source="GlossTerm")
63 | acronym = CharField(source="Acronym")
64 | abbrev = CharField(source="Abbrev", required=True, allow_blank=False)
65 | gloss_def = GlossDefSerializer(source="GlossDef")
66 | gloss_see = CharField(source="GlossSee")
67 |
68 |
69 | class GlossListSerializer(BaseSerializer):
70 | gloss_entry = GlossEntrySerializer(source="GlossEntry")
71 |
72 |
73 | class GlossDivSerializer(BaseSerializer):
74 | title = CharField()
75 | gloss_list = GlossListSerializer(source="GlossList")
76 |
77 |
78 | class GlossarySerializer(BaseSerializer):
79 | title = CharField()
80 | gloss_div = GlossDivSerializer(source="GlossDiv")
81 |
82 |
83 | class SampleSerializer(BaseSerializer):
84 | glossary = GlossarySerializer()
85 |
86 |
87 | sample_data = {
88 | "glossary": {
89 | "title": "example glossary",
90 | "GlossDiv": {
91 | "title": "S",
92 | "GlossList": {
93 | "GlossEntry": {
94 | "ID": 12,
95 | "SortAs": "SGML",
96 | "GlossTerm": "Standard Generalized Markup Language",
97 | "Acronym": "SGML",
98 | "Abbrev": "",
99 | "GlossDef": {
100 | "para": "A meta-markup language, used to create markup languages such as DocBook.",
101 | "GlossSeeAlso": ["GML", "XML"]
102 | },
103 | "GlossSee": "markup"
104 | }
105 | }
106 | }
107 | }
108 | }
109 |
110 |
111 | validator = SampleSerializer(data=sample_data)
112 | print('validation status:')
113 | print(validator.is_valid())
114 | print("\nvalidation errors:")
115 | print(validator.get_errors())
116 | print("\nvalidated data:")
117 | print(validator.validate_data())
118 |
119 | **The above sample output:**
120 |
121 | ::
122 |
123 | validation status:
124 | False
125 |
126 | validation errors:
127 | {'glossary': {'gloss_div': {'gloss_list': {'gloss_entry': {'abbrev': ['This field cannot be blank']}}}}}
128 |
129 | validated data:
130 | {'glossary': {'title': 'example glossary', 'gloss_div': {'title': 'S', 'gloss_list': {'gloss_entry': {'acronym': 'SGML', 'gloss_term': 'Standard Generalized Markup Language', 'gloss_def': {'gloss_see_also': ['GML', 'XML'], 'para': 'A meta-markup language, used to create markup languages such as DocBook.'}, 'gloss_see': 'markup', 'sort_as': 'SGML', 'id': 12}}}}}
--------------------------------------------------------------------------------
/docs/make.bat:
--------------------------------------------------------------------------------
1 | @ECHO OFF
2 |
3 | pushd %~dp0
4 |
5 | REM Command file for Sphinx documentation
6 |
7 | if "%SPHINXBUILD%" == "" (
8 | set SPHINXBUILD=sphinx-build
9 | )
10 | set SOURCEDIR=.
11 | set BUILDDIR=_build
12 | set SPHINXPROJ=RequestValidator
13 |
14 | if "%1" == "" goto help
15 |
16 | %SPHINXBUILD% >NUL 2>NUL
17 | if errorlevel 9009 (
18 | echo.
19 | echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
20 | echo.installed, then set the SPHINXBUILD environment variable to point
21 | echo.to the full path of the 'sphinx-build' executable. Alternatively you
22 | echo.may add the Sphinx directory to PATH.
23 | echo.
24 | echo.If you don't have Sphinx installed, grab it from
25 | echo.http://sphinx-doc.org/
26 | exit /b 1
27 | )
28 |
29 | %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
30 | goto end
31 |
32 | :help
33 | %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
34 |
35 | :end
36 | popd
37 |
--------------------------------------------------------------------------------
/request_validator/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/amirasaran/request_validator/0adb1aae3d4f32a4a8f6658e7e4f6b379545def5/request_validator/__init__.py
--------------------------------------------------------------------------------
/request_validator/fields.py:
--------------------------------------------------------------------------------
1 | from __future__ import absolute_import
2 | from .validator import *
3 |
4 |
5 | class Field(object):
6 | def __init__(self, source=None, required=False, many=False, default=None, allow_null=True):
7 | self._source = source
8 | self._data = None
9 | self.data = None
10 | self._many = many
11 | self._errors = []
12 | self._rules = {}
13 | self._required = required
14 | self._default = default
15 | if not allow_null:
16 | self.add_rule(Validator.NOT_NULL)
17 |
18 | def set_data(self, data, index):
19 | self.data = self._default
20 | self._errors = []
21 |
22 | self._data = data
23 |
24 | if not self._data:
25 | if self._required:
26 | self._errors.append("This field is required")
27 | return self
28 |
29 | if self._source in self._data:
30 | self.data = self._data[self._source]
31 | elif index in self._data:
32 | self.data = self._data[index]
33 | else:
34 | if self._required:
35 | self._errors.append("This field is required")
36 |
37 | return self
38 |
39 | def is_required(self):
40 | return self._required
41 |
42 | def add_rule(self, rule, value=None):
43 | self._rules[rule] = value
44 |
45 | def data(self):
46 | return self.data
47 |
48 | def get_errors(self):
49 | return self._errors
50 |
51 | def has_error(self):
52 | return len(self._errors) != 0
53 |
54 | def validate(self):
55 | if not self._many:
56 | for rule, value in self._rules.iteritems():
57 | validator = Validator(self.data, rule, value)
58 | if validator.validate():
59 | self.data = validator.data
60 | continue
61 | else:
62 | self._errors.append(validator.get_message())
63 | else:
64 | assert isinstance(self.data, list) or isinstance(self.data, tuple), \
65 | """ data must be list or tuple but get {data_type}""".format(
66 | data_type=type(self.data).__name__)
67 | for data in self.data:
68 | for rule, value in self._rules.iteritems():
69 | validator = Validator(data, rule, value)
70 | if validator.validate():
71 | continue
72 | else:
73 | self._errors.append(validator.get_message())
74 | return not self.has_error()
75 |
76 |
77 | class CharField(Field):
78 | def __init__(self, min_length=None, max_length=None, choices=None, allow_blank=False, *args,
79 | **kwargs):
80 | super(CharField, self).__init__(*args, **kwargs)
81 |
82 | self.add_rule(Validator.STRING)
83 |
84 | if not allow_blank:
85 | self.add_rule(Validator.NOT_BLANK)
86 |
87 | if min_length is not None:
88 | assert isinstance(min_length, int), \
89 | """min_length must be integer"""
90 | self.add_rule(Validator.MIN_LEN, min_length)
91 |
92 | if max_length is not None:
93 | assert isinstance(max_length, int), \
94 | """max_length must be integer"""
95 | self.add_rule(Validator.MAX_LEN, max_length)
96 |
97 | if choices is not None:
98 | assert isinstance(choices, list) or isinstance(choices, tuple), \
99 | """choices must be tuple or list"""
100 | self.add_rule(Validator.IN, choices)
101 |
102 |
103 | class IntField(Field):
104 | def __init__(self, min_value=None, max_value=None, choices=None, *args,
105 | **kwargs):
106 | super(IntField, self).__init__(*args, **kwargs)
107 |
108 | self.add_rule(Validator.INT)
109 |
110 | if min_value is not None:
111 | assert isinstance(min_value, int), \
112 | """min_value must be integer"""
113 | self.add_rule(Validator.MIN_VALUE, min_value)
114 |
115 | if max_value is not None:
116 | assert isinstance(max_value, int), \
117 | """max_length must be integer"""
118 | self.add_rule(Validator.MAX_LEN, max_value)
119 |
120 | if choices is not None:
121 | assert isinstance(choices, list) or isinstance(choices, tuple), \
122 | """choices must be tuple or list"""
123 | for choice in choices:
124 | assert isinstance(choice, int), \
125 | """
126 | choices must be list or tuple of integer but get {data_type}
127 | """.format(data_type=type(choice).__name_)
128 | self.add_rule(Validator.IN, choices)
129 |
130 |
131 | class IntegerField(IntField):
132 | pass
133 |
134 |
135 | class FloatField(Field):
136 | def __init__(self, min_value=None, max_value=None, choices=None, *args,
137 | **kwargs):
138 | super(FloatField, self).__init__(*args, **kwargs)
139 |
140 | self.add_rule(Validator.FLOAT)
141 |
142 | if min_value is not None:
143 | assert isinstance(min_value, float), \
144 | """min_value must be integer"""
145 | self.add_rule(Validator.MIN_VALUE, min_value)
146 |
147 | if max_value is not None:
148 | assert isinstance(max_value, float), \
149 | """max_length must be integer"""
150 | self.add_rule(Validator.MAX_LEN, max_value)
151 |
152 | if choices is not None:
153 | assert isinstance(choices, list) or isinstance(choices, tuple), \
154 | """choices must be tuple or list"""
155 | for choice in choices:
156 | assert isinstance(choice, float), \
157 | """
158 | choices must be list or tuple of integer but get {data_type}
159 | """.format(data_type=type(choice).__name_)
160 | self.add_rule(Validator.IN, choices)
161 |
162 |
163 | class RegexField(CharField):
164 | def __init__(self, pattern, *args, **kwargs):
165 | super(RegexField, self).__init__(*args, **kwargs)
166 |
167 | self.add_rule(Validator.REGEX, pattern)
168 |
169 |
170 | class DateField(Field):
171 | def __init__(self, format=None, convert_to_date=False, *args, **kwargs):
172 | super(DateField, self).__init__(*args, **kwargs)
173 | if format:
174 | self._format = format
175 | else:
176 | self._format = "%Y-%m-%d"
177 |
178 | self.add_rule(Validator.DATE, {"format": self._format, "convert_to_date": convert_to_date})
179 |
180 |
181 | class DateTimeField(Field):
182 | def __init__(self, format=None, convert_to_datetime=False, *args, **kwargs):
183 | super(DateTimeField, self).__init__(*args, **kwargs)
184 | if format:
185 | self._format = format
186 | else:
187 | self._format = "%Y-%m-%dT%H:%M:%S"
188 |
189 | self.add_rule(Validator.DATETIME, {"format": self._format, "convert_to_datetime": convert_to_datetime})
190 |
191 |
192 | class BooleanField(Field):
193 | def __init__(self, *args, **kwargs):
194 | super(BooleanField, self).__init__(*args, **kwargs)
195 | self.add_rule(Validator.BOOLEAN)
196 |
197 |
198 | class ListField(Field):
199 | def __init__(self, *args, **kwargs):
200 | super(ListField, self).__init__(*args, **kwargs)
201 | self.add_rule(Validator.LIST)
202 |
--------------------------------------------------------------------------------
/request_validator/serializers.py:
--------------------------------------------------------------------------------
1 | from __future__ import absolute_import
2 |
3 | import copy
4 |
5 | from .fields import Field
6 |
7 |
8 | class BaseSerializer(object):
9 | def __init__(self, data=None, source=None, required=True, force_valid=False):
10 | self._initial_data = data
11 | self._source = source
12 | self._required = required
13 | self._force_valid = force_valid
14 | self._errors = None
15 | self._validated_data = None
16 |
17 | def get_errors(self):
18 | return self._errors
19 |
20 | def validate_data(self):
21 | return self._validated_data
22 |
23 | def has_error(self):
24 | return len(self._errors) != 0
25 |
26 | @property
27 | def errors(self):
28 | return self.get_errors()
29 |
30 |
31 | class Serializer(BaseSerializer):
32 | def __init__(self, *args, **kwargs):
33 | super(Serializer, self).__init__(*args, **kwargs)
34 | self._validated_data = {}
35 | self._errors = {}
36 | self._default = {}
37 | self._all_fields_valid = True
38 |
39 | def validate_data(self):
40 | if not (self._force_valid and self.has_error()) and self._all_fields_valid:
41 | return self._validated_data
42 | return {}
43 |
44 | def __new__(cls, *args, **kwargs):
45 | many = kwargs.pop("many", False)
46 | cls.fields()
47 | if many:
48 | if hasattr(cls, "Meta") and hasattr(cls.Meta, "list_serializer"):
49 | return cls.Meta.list_serializer(cls, *args, **kwargs)
50 | return ListSerializer(cls, *args, **kwargs)
51 | else:
52 | return object.__new__(cls, *args, **kwargs)
53 |
54 | @classmethod
55 | def fields(cls):
56 | if "_fields_dict" not in cls.__dict__:
57 | cls._fields_dict = {}
58 | for field in cls._get_fields():
59 | if field in cls.__dict__:
60 | cls._fields_dict[field] = getattr(cls, field)
61 | if hasattr(cls, field):
62 | delattr(cls, field)
63 |
64 | if len(cls._get_classes()) > 1:
65 | cls._fields_dict.update(cls._get_parent().fields())
66 |
67 | return cls._fields_dict
68 |
69 | @classmethod
70 | def _get_fields(cls):
71 | if '_fields' not in cls.__dict__:
72 | cls._fields = []
73 | for field in set(dir(cls)) - set(dir(cls._get_parent())):
74 | if not isinstance(getattr(cls, field), (Field, BaseSerializer)):
75 | continue
76 | cls._fields.append(field)
77 |
78 | if len(cls._get_classes()) > 1:
79 | cls._fields = cls._fields + cls._get_parent()._get_fields()
80 |
81 | return cls._fields
82 |
83 | @classmethod
84 | def _get_classes(cls):
85 | if "_base_classes" not in cls.__dict__:
86 | the_class = cls
87 | cls._base_classes = []
88 | while True:
89 | bases = the_class.__bases__
90 | if len(bases) == 0:
91 | break
92 | assert len(bases) == 1, """ can not use multiple extend"""
93 | the_class = bases[0]
94 | cls._base_classes.append(the_class)
95 | if the_class == Serializer:
96 | break
97 |
98 | return cls._base_classes
99 |
100 | @classmethod
101 | def _get_parent(cls):
102 | return cls._get_classes()[0]
103 |
104 | def _get_field(self, key):
105 | return copy.deepcopy(getattr(self, '_fields_dict')[key])
106 |
107 | @property
108 | def data(self):
109 | data = self.validate_data()
110 | for key, value in self.fields().items():
111 | if key not in data:
112 | data[key] = value._default
113 | return data
114 |
115 | def add_error(self, index, value):
116 | self._errors[index] = value
117 |
118 | def is_valid(self):
119 | validated_data, serializer_validated = self._validate(self._initial_data)
120 | self._validated_data = validated_data
121 | return not self.has_error()
122 |
123 | def _validate(self, initial_data):
124 | serializer_validated = True
125 | validate_data = {}
126 | errors, initial_data = self._check_user_validation(initial_data)
127 |
128 | if len(errors) != 0:
129 | self._all_fields_valid = False
130 | for error in errors:
131 | for key, value in error.iteritems():
132 | self.add_error(key, value)
133 |
134 | for attr in self.fields():
135 | field = self._get_field(attr)
136 | if isinstance(field, Field):
137 | field.set_data(initial_data, attr)
138 | if field.has_error():
139 | self._all_fields_valid = False
140 | serializer_validated = False
141 | self.add_error(attr, field.get_errors())
142 | continue
143 | if not field.validate():
144 | serializer_validated = False
145 | self.add_error(attr, field.get_errors())
146 | continue
147 | validate_data[attr] = field.data
148 | elif isinstance(field, Serializer):
149 | field.set_initial_data(initial_data, attr)
150 | if field.has_error():
151 | self._all_fields_valid = False
152 | serializer_validated = False
153 | self.add_error(attr, field.get_errors())
154 | continue
155 | elif not field.is_valid():
156 | serializer_validated = False
157 | self.add_error(attr, field.get_errors())
158 | validate_data[attr] = field.validate_data()
159 | continue
160 | elif isinstance(field, ListSerializer):
161 | field.set_initial_data(initial_data, attr)
162 | if field.has_error():
163 | self._all_fields_valid = False
164 | serializer_validated = False
165 | self.add_error(attr, field.get_errors())
166 | continue
167 | elif not field.is_valid():
168 | serializer_validated = False
169 | self.add_error(attr, field.get_errors())
170 | validate_data[attr] = field.validate_data()
171 | continue
172 | return validate_data, serializer_validated
173 |
174 | def _check_user_validation(self, data):
175 | try:
176 | before_validation = self.validate(data)
177 | return [], before_validation
178 | except ValidationError as e:
179 | return e.details, data
180 |
181 | def validate(self, attr):
182 | return attr
183 |
184 | @property
185 | def is_all_fields_valid(self):
186 | return self._all_fields_valid
187 |
188 | def set_initial_data(self, data, index):
189 | self._initial_data = None
190 | if not data:
191 | return self
192 |
193 | if self._source in data:
194 | self._initial_data = data[self._source]
195 | elif index in data:
196 | self._initial_data = data[index]
197 | else:
198 | if self._required:
199 | self.add_error(index, "This field is required")
200 | return self
201 |
202 |
203 | class ListSerializer(BaseSerializer):
204 | def __init__(self, serializer, *args, **kwargs):
205 | super(ListSerializer, self).__init__(*args, **kwargs)
206 |
207 | kwargs.pop("data", False)
208 | self._serializer = serializer
209 | self._validated_data = []
210 | self._errors = []
211 | self._args = args
212 | self._kwargs = kwargs
213 | self._data = []
214 | self._default = []
215 | self._allow_null = True
216 |
217 | def add_error(self, value):
218 | self._errors.append(value)
219 |
220 | def _can_null(self):
221 | return self._allow_null and self._initial_data is None
222 |
223 | def is_valid(self):
224 | assert isinstance(self._initial_data, (list, tuple)) or self._initial_data is None, \
225 | """ _initial_data must be list or tuple but get {data_type}""".format(
226 | data_type=type(self._initial_data).__name__)
227 |
228 | if self._initial_data is not None:
229 | for initial_data in self._initial_data:
230 | serializer = self._serializer(data=initial_data, *self._args, **self._kwargs)
231 | if serializer.is_valid():
232 | self._validated_data.append(serializer.validate_data())
233 | self._data.append(serializer.data)
234 | else:
235 | self.add_error(serializer.get_errors())
236 | if not self._force_valid and serializer.validate_data():
237 | self._validated_data.append(serializer.validate_data())
238 | self._data.append(serializer.data)
239 | else:
240 | self.add_error("can not be null !")
241 |
242 | return not self.has_error()
243 |
244 | @property
245 | def data(self):
246 | return self._data
247 |
248 | def set_initial_data(self, data, index):
249 | self._initial_data = self._default
250 | if not data:
251 | return self
252 |
253 | if self._source in data:
254 | self._initial_data = data[self._source]
255 | elif index in data:
256 | self._initial_data = data[index]
257 | else:
258 | if self._required:
259 | self.add_error("This field is required")
260 | return self
261 |
262 |
263 | class ValidationError(Exception):
264 | def __init__(self, details):
265 |
266 | self.details = []
267 | if not isinstance(details, list):
268 | details = [details]
269 | for detail in details:
270 | if not isinstance(detail, dict):
271 | self.details.append({'non_field_error': str(detail)})
272 | else:
273 | self.details.append(detail)
--------------------------------------------------------------------------------
/request_validator/validator.py:
--------------------------------------------------------------------------------
1 | import six
2 | from __builtin__ import unicode, long
3 | from decimal import Decimal
4 |
5 |
6 | class Validator(object):
7 | NOT_NULL = 'not_null'
8 | NOT_BLANK = 'not_blank'
9 | INT = "int"
10 | FLOAT = "float"
11 | STRING = "string"
12 | REGEX = "regex"
13 | DATE = "date"
14 | DATETIME = "datetime"
15 | MAX_LEN = "max_len"
16 | MIN_LEN = "min_len"
17 | MAX_VALUE = "max_value"
18 | MIN_VALUE = "min_value"
19 | IN = "in"
20 | BOOLEAN = "boolean"
21 | LIST = "list"
22 |
23 | _MESSAGES = {
24 | NOT_NULL: "This field cannot be null",
25 | NOT_BLANK: "This field cannot be blank",
26 | INT: "This field must be integer but get {data_type}",
27 | FLOAT: "This field must be float {data_type}",
28 | STRING: "This field must be string but get {data_type}",
29 | MAX_LEN: "This field must be larger than {len} characters",
30 | MIN_LEN: "This field must be smaller than {len} characters",
31 | MAX_VALUE: "This field must be larger than {len}",
32 | MIN_VALUE: "This field must be smaller than {len}",
33 | IN: "This field must be choice from ({choices})",
34 | REGEX: "This field must be valid in pattern ({pattern})",
35 | DATE: "This field must be valid date (format='{date_format}') but given data is {data}",
36 | DATETIME: "This field must be valid datetime (format='{date_format}') but given data is {data}",
37 | BOOLEAN: "This field must be boolean bug given {data_type}",
38 | LIST: "This field must be list bug given {data_type}"
39 | }
40 |
41 | def __init__(self, data, validator, value=None):
42 | self.data = data
43 | self._validator = "check_{}".format(validator)
44 | self._value = value
45 | self.error = ""
46 |
47 | def get_message(self):
48 | return self.error
49 |
50 | def validate(self):
51 | return getattr(self, self._validator)()
52 |
53 | def check_not_null(self):
54 | if self.data is not None:
55 | return True
56 | self.error = self._MESSAGES[self.NOT_NULL]
57 | return False
58 |
59 | def check_not_blank(self):
60 | if self.data != "":
61 | return True
62 | self.error = self._MESSAGES[self.NOT_BLANK]
63 | return False
64 |
65 | def check_int(self):
66 | if isinstance(self.data, int):
67 | return True
68 | if type(self.data) is long:
69 | self.data = int(self.data)
70 | return True
71 | if type(self.data) is Decimal:
72 | self.data = int(self.data)
73 | return True
74 | if isinstance(self.data, (str, unicode)):
75 | import re
76 | if re.match(r"\d+", self.data):
77 | self.data = int(self.data)
78 | return True
79 | if self.data is None:
80 | return True
81 | self.error = self._MESSAGES[self.INT].format(data_type=type(self.data).__name__)
82 | return False
83 |
84 | def check_float(self):
85 | if isinstance(self.data, float):
86 | return True
87 | if type(self.data) is Decimal:
88 | self.data = float(self.data)
89 | return True
90 | if isinstance(self.data, int):
91 | self.data = float(self.data)
92 | return True
93 | if self.data is None:
94 | return True
95 | self.error = self._MESSAGES[self.FLOAT].format(data_type=type(self.data).__name__)
96 | return False
97 |
98 | def check_string(self):
99 | if isinstance(self.data, (str, unicode)):
100 | return True
101 | if self.data is None:
102 | return True
103 |
104 | self.error = self._MESSAGES[self.STRING].format(data_type=type(self.data).__name__)
105 | return False
106 |
107 | def check_max_len(self):
108 | if len(self.data) <= self._value:
109 | return True
110 | self.error = self._MESSAGES[self.MAX_LEN].format(len=self._value)
111 | return False
112 |
113 | def check_min_len(self):
114 | if len(self.data) >= self._value:
115 | return True
116 | self.error = self._MESSAGES[self.MIN_LEN].format(len=self._value)
117 | return False
118 |
119 | def check_max_value(self):
120 | if self.data <= self._value:
121 | return True
122 | self.error = self._MESSAGES[self.MAX_VALUE].format(len=self._value)
123 | return False
124 |
125 | def check_min_value(self):
126 | if self.data >= self._value:
127 | return True
128 | self.error = self._MESSAGES[self.MIN_VALUE].format(len=self._value)
129 | return False
130 |
131 | def check_in(self):
132 | if self.data in self._value:
133 | return True
134 | self.error = self._MESSAGES[self.IN].format(choices=",".join(self._value))
135 | return False
136 |
137 | def check_regex(self):
138 | import re
139 | if re.match(self._value, self.data):
140 | return True
141 | self.error = self._MESSAGES[self.REGEX].format(pattern=self._value)
142 | return False
143 |
144 | def check_date(self):
145 | if isinstance(self.data, (str, unicode)):
146 | self.data = self.data.strip()
147 | import datetime
148 | if self._value['convert_to_date']:
149 | if isinstance(self.data, datetime.datetime):
150 | self.data = self.data.date()
151 | return True
152 | elif isinstance(self.data, datetime.date):
153 | return True
154 | elif isinstance(self.data, (str, unicode)):
155 | try:
156 | self.data = datetime.datetime.strptime(self.data, self._value['format']).date()
157 | return True
158 | except Exception as e:
159 | self.error = self._MESSAGES[self.DATE].format(date_format=self._value['format'],
160 | data=self.data)
161 | return False
162 | else:
163 | if isinstance(self.data, datetime.datetime):
164 | self.data = self.data.date().strftime(self._value['format'])
165 | return True
166 | elif isinstance(self.data, datetime.date):
167 | self.data = self.data.strftime(self._value['format'])
168 | return True
169 | elif isinstance(self.data, (str, unicode)):
170 | try:
171 | self.data = datetime.datetime.strptime(
172 | self.data,
173 | self._value['format']
174 | ).date().strftime(self._value['format'])
175 | return True
176 | except Exception as e:
177 | self.error = self._MESSAGES[self.DATE].format(date_format=self._value['format'],
178 | data=self.data)
179 | return False
180 | self.error = self._MESSAGES[self.DATE].format(date_format=self._value['format'], data=self.data)
181 | return False
182 |
183 | def check_datetime(self):
184 | if isinstance(self.data, (str, unicode)):
185 | self.data = self.data.strip()
186 |
187 | import datetime
188 | if self._value['convert_to_datetime']:
189 | if isinstance(self.data, datetime.datetime):
190 | return True
191 | elif isinstance(self.data, datetime.date):
192 | self.data = datetime.datetime(self.data.year, self.data.month, self.data.day)
193 | return True
194 | elif isinstance(self.data, (str, unicode)):
195 | try:
196 | self.data = datetime.datetime.strptime(self.data, self._value['format'])
197 | return True
198 | except Exception as e:
199 | self.error = self._MESSAGES[self.DATETIME].format(date_format=self._value['format'], data=self.data)
200 | return False
201 | else:
202 | if isinstance(self.data, datetime.datetime):
203 | self.data = self.data.strftime(self._value['format'])
204 | return True
205 | elif isinstance(self.data, datetime.date):
206 | self.data = datetime.datetime(self.data.year, self.data.month, self.data.day).strftime(
207 | self._value['format'])
208 | return True
209 | elif isinstance(self.data, (str, unicode)):
210 | self.data = datetime.datetime.strptime(
211 | self.data,
212 | self._value['format']
213 | ).strftime(self._value['format'])
214 | try:
215 | self.data = datetime.datetime.strptime(
216 | self.data,
217 | self._value['format']
218 | ).strftime(self._value['format'])
219 | return True
220 | except Exception as e:
221 | self.error = self._MESSAGES[self.DATETIME].format(date_format=self._value['format'], data=self.data)
222 | return False
223 | self.error = self._MESSAGES[self.DATETIME].format(date_format=self._value['format'], data=self.data)
224 | return False
225 |
226 | def check_boolean(self):
227 | if isinstance(self.data, bool):
228 | return True
229 | self.error = self._MESSAGES[self.BOOLEAN].format(data_type=type(self.data).__name__)
230 |
231 | return False
232 |
233 | def check_list(self):
234 | if isinstance(self.data, list):
235 | return True
236 | self.error = self._MESSAGES[self.LIST].format(data_type=type(self.data).__name__)
237 |
238 | return False
239 |
--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [bdist_wheel]
2 | # This flag says that the code is written to work on both Python 2 and Python
3 | # 3. If at all possible, it is good practice to do this. If you cannot, you
4 | # will need to generate wheels for each Python version that you support.
5 | universal=1
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | """
2 | See:
3 | https://github.com/amirasaran/request_validator
4 | """
5 |
6 | # Always prefer setuptools over distutils
7 | from setuptools import setup, find_packages
8 | # To use a consistent encoding
9 | from codecs import open
10 | from os import path
11 |
12 | here = path.abspath(path.dirname(__file__))
13 |
14 | # Get the long description from the README file
15 | with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
16 | long_description = f.read()
17 |
18 | setup(
19 | name='request-validator',
20 | version='1.5.0',
21 | description='Python request validator',
22 | long_description=long_description,
23 | url='https://github.com/amirasaran/request_validator',
24 | author='Amir Mohsen Asaran',
25 | author_email='admin@mihanmail.com',
26 | license='MIT',
27 | classifiers=[
28 | # How mature is this project? Common values are
29 | # 3 - Alpha
30 | # 4 - Beta
31 | # 5 - Production/Stable
32 | 'Development Status :: 3 - Alpha',
33 |
34 | # Indicate who your project is intended for
35 | 'Intended Audience :: Developers',
36 | 'Topic :: Software Development :: Build Tools',
37 |
38 | # Pick your license as you wish (should match "license" above)
39 | 'License :: OSI Approved :: MIT License',
40 |
41 | # Specify the Python versions you support here. In particular, ensure
42 | # that you indicate whether you support Python 2, Python 3 or both.
43 | 'Programming Language :: Python :: 2',
44 | 'Programming Language :: Python :: 2.7',
45 | 'Programming Language :: Python :: 3',
46 | 'Programming Language :: Python :: 3.3',
47 | 'Programming Language :: Python :: 3.4',
48 | 'Programming Language :: Python :: 3.5',
49 | ],
50 | packages=['request_validator'],
51 | # What does your project relate to?
52 | keywords='request validator',
53 | )
54 |
--------------------------------------------------------------------------------
49 |
79 |
89 |
90 |
50 |
78 |
51 |
52 |
77 | Search
53 |
54 |
55 |
60 | 56 | Please activate JavaScript to enable the search 57 | functionality. 58 |
59 |61 | From here you can search these documents. Enter your search 62 | words into the box below and click "search". Note that the search 63 | function will automatically search for all of the words. Pages 64 | containing fewer words won't appear in the result list. 65 |
66 | 71 | 72 |
73 |
74 |
75 |
76 |
\ 689 | Sort by:\ 690 | best rated\ 691 | newest\ 692 | oldest\ 693 |
\ 694 |\ 698 |
Add a comment\ 700 | (markup):
\ 701 |``code``, \ 704 | code blocks:::and an indented block after blank line