https://github.com/moff4/schema_schecker
Another schema validator :)
https://github.com/moff4/schema_schecker
schema-validator
Last synced: 5 months ago
JSON representation
Another schema validator :)
- Host: GitHub
- URL: https://github.com/moff4/schema_schecker
- Owner: moff4
- License: mit
- Created: 2020-06-28T10:56:58.000Z (almost 6 years ago)
- Default Branch: master
- Last Pushed: 2021-03-25T12:05:50.000Z (about 5 years ago)
- Last Synced: 2025-09-29T13:02:35.698Z (9 months ago)
- Topics: schema-validator
- Language: Python
- Homepage:
- Size: 39.1 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Schema checker #
Another schema validator :)
[](https://travis-ci.org/moff4/schema_schecker)
[](https://www.codefactor.io/repository/github/moff4/schema_schecker)
[](https://codecov.io/gh/moff4/schema_schecker)
Features:
* Can validate any dict object (not only json)
* Very customizeble
## Tutorial
Base validation function:
```python
def validate(obj: dict, schema: dict) -> dict:
...
```
where
```
obj - some object
schema - schema_checker
schema ::= type of this object : list/dict/str/int/float (can be tuple of types) or "const"/"enum"
OR
schema ::= dict - {
type : type of this object : "list/tuple/dict/str/int/float or "const"
"value" : need for obj type of
- list/tuple - is schema for all elements in list
- dict - dict[key -> schema]
- const - some value to be compared with using method
- enum - list/set/dict/tuple to check if obj __contains__ in "value"
"any_key" : need for obj type of dict - schema for all keys (ignores if value is set)
"default" : default value if this object does not exists (if callable will be called)
"filter" : any of
- Callable[value -> bool] - if false then raise error
- Iterable[Callable[value -> bool]] - if any of them return false then raise error
"pre_call" : any of
- Callable[value -> value] - will be called before checking type and call filter's functions
- Iterable[Callable[value -> value]] - will call all of them
"post_call" : any of
- Callable[value -> value] - will be called after checking type and call filter's functions
- Iterable[Callable[value -> value]] - will call all of them
"blank" : raise error if value is blank
"max_length" : extra check of length (len)
"min_length" : extra check of length (len)
"unexpected" : allow unexpected keys (for dict)
"errmsg" : will be in ValueError in case of error on this level
}
```
#### Extras
##### decorator_constructor
`def decorator_constructor(getter, setter)`
`getter` must:
- take same args as the function that'll be decorated
- return dict for the schema validator
`setter` must:
- take 3 args: validated dict, source positional args as tuple, sourse keyword args as dict
- return tuple and dict for positional and keywords args for the function tha'll be decorated
returns parameterized decorator, that expects schema
##### kw_validator
`def kw_validator(schema)`
Validate only keyword args and ignores all positional
This decorator is the result of decorator_constructor
##### pos_validator
`def pos_validator(schema)`
Validate only positional args and ignores all keywords
This decorator is the result of decorator_constructor
##### args_validator
`def args_validator(pos_schema: Dict[str, Any], kw_schema: Dict[str, Any]):`
Validate both positional and keywords args
## Examples
```python
from datetime import datetime, timedelta
from schema_checker import validate, kw_validator
# validate that obj is str
validate(
obj='12345',
schema={'type': str},
) # result: '12345'
validate(
obj=12345,
schema={'type': str},
) # raise ValueError
# check if value is int and less then 5
validate(
obj={'some_key': 10},
schema={
'type': dict,
'value': {
'some_key': {
'type': int,
'filter': lambda x: x < 5,
},
}
},
) # raise ValueError
# convert obj to datetime and compare with today's date
validate(
obj='10.12.19',
schema={
'type': datetime,
'pre_call': lambda x: datetime.strptime(x, '%d.%m.%y'),
'filter': lambda x: (datetime.today() - timedelta(year=1)) <= x <= datetime.today(),
},
) # result: datetime.datetime(2019, 12, 10, 0, 0)
@kw_validator({'type': dict, 'values': {'a': str}})
def func(a):
return a
func(123) # ok
func('123') # ok
func(a='123') # ok
func(a=123) # raise ValueError
```