jazzband/jsonmodels jazzband/jsonmodels

  • Stars
    star
    328
  • Rank 123,915 (Top 3 %)
  • Language
    Python
  • License
    BSD 3-Clause "New...
  • Created about 10 years ago
  • Updated 4 months ago
Twitter logo Share LinkedIn logo Share Facebook logo Share
jazzband/jsonmodels
github

jazzband

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

jsonmodels is library to make it easier for you to deal with structures that are converted to, or read from JSON.

JSON models

Jazzband Tests PyPI Coverage

jsonmodels is library to make it easier for you to deal with structures that are converted to, or read from JSON.

Features

  • Fully tested with Python 3.7+.

  • Support for PyPy 3.8 (see implementation notes in docs for more details).

  • Create Django-like models:

    from jsonmodels import models, fields, errors, validators


class Cat(models.Base):

    name = fields.StringField(required=True)
    breed = fields.StringField()
    love_humans = fields.IntField(nullable=True)


class Dog(models.Base):

    name = fields.StringField(required=True)
    age = fields.IntField()


class Car(models.Base):

    registration_number = fields.StringField(required=True)
    engine_capacity = fields.FloatField()
    color = fields.StringField()


class Person(models.Base):

    name = fields.StringField(required=True)
    surname = fields.StringField(required=True)
    nickname = fields.StringField(nullable=True)
    car = fields.EmbeddedField(Car)
    pets = fields.ListField([Cat, Dog], nullable=True)

  • Access to values through attributes:

    >>> cat = Cat()
>>> cat.populate(name='Garfield')
>>> cat.name
'Garfield'
>>> cat.breed = 'mongrel'
>>> cat.breed
'mongrel'

  • Validate models:

    >>> person = Person(name='Chuck', surname='Norris')
>>> person.validate()
None

>>> dog = Dog()
>>> dog.validate()
*** ValidationError: Field "name" is required!

  • Cast models to python struct and JSON:

    >>> cat = Cat(name='Garfield')
>>> dog = Dog(name='Dogmeat', age=9)
>>> car = Car(registration_number='ASDF 777', color='red')
>>> person = Person(name='Johny', surname='Bravo', pets=[cat, dog])
>>> person.car = car
>>> person.to_struct()
{
    'car': {
        'color': 'red',
        'registration_number': 'ASDF 777'
    },
    'surname': 'Bravo',
    'name': 'Johny',
    'nickname': None,
    'pets': [
        {'name': 'Garfield'},
        {'age': 9, 'name': 'Dogmeat'}
    ]
}

>>> import json
>>> person_json = json.dumps(person.to_struct())

  • You don't like to write JSON Schema? Let jsonmodels do it for you:

    >>> person = Person()
>>> person.to_json_schema()
{
    'additionalProperties': False,
    'required': ['surname', 'name'],
    'type': 'object',
    'properties': {
        'car': {
            'additionalProperties': False,
            'required': ['registration_number'],
            'type': 'object',
            'properties': {
                'color': {'type': 'string'},
                'engine_capacity': {'type': ''},
                'registration_number': {'type': 'string'}
            }
        },
        'surname': {'type': 'string'},
        'name': {'type': 'string'},
        'nickname': {'type': ['string', 'null']}
        'pets': {
            'items': {
                'oneOf': [
                    {
                        'additionalProperties': False,
                        'required': ['name'],
                        'type': 'object',
                        'properties': {
                            'breed': {'type': 'string'},
                            'name': {'type': 'string'}
                        }
                    },
                    {
                        'additionalProperties': False,
                        'required': ['name'],
                        'type': 'object',
                        'properties': {
                            'age': {'type': 'number'},
                            'name': {'type': 'string'}
                        }
                    },
                    {
                        'type': 'null'
                    }
                ]
            },
            'type': 'array'
        }
    }
}

  • Validate models and use validators, that affect generated schema:

    >>> class Person(models.Base):
...
...     name = fields.StringField(
...         required=True,
...         validators=[
...             validators.Regex('^[A-Za-z]+$'),
...             validators.Length(3, 25),
...         ],
...     )
...     age = fields.IntField(
...         nullable=True,
...         validators=[
...             validators.Min(18),
...             validators.Max(101),
...         ]
...     )
...     nickname = fields.StringField(
...         required=True,
...         nullable=True
...     )
...

>>> person = Person()
>>> person.age = 11
>>> person.validate()
*** ValidationError: '11' is lower than minimum ('18').
>>> person.age = None
>>> person.validate()
None

>>> person.age = 19
>>> person.name = 'Scott_'
>>> person.validate()
*** ValidationError: Value "Scott_" did not match pattern "^[A-Za-z]+$".

>>> person.name = 'Scott'
>>> person.validate()
None

>>> person.nickname = None
>>> person.validate()
*** ValidationError: Field is required!

>>> person.to_json_schema()
{
    "additionalProperties": false,
    "properties": {
        "age": {
            "maximum": 101,
            "minimum": 18,
            "type": ["number", "null"]
        },
        "name": {
            "maxLength": 25,
            "minLength": 3,
            "pattern": "/^[A-Za-z]+$/",
            "type": "string"
        },
        "nickname": {,
            "type": ["string", "null"]
        }
    },
    "required": [
        "nickname",
        "name"
    ],
    "type": "object"
}

    You can also validate scalars, when needed:

    >>> class Person(models.Base):
...
...     name = fields.StringField(
...         required=True,
...         validators=[
...             validators.Regex('^[A-Za-z]+$'),
...             validators.Length(3, 25),
...         ],
...     )
...     age = fields.IntField(
...         nullable=True,
...         validators=[
...             validators.Min(18),
...             validators.Max(101),
...         ]
...     )
...     nickname = fields.StringField(
...         required=True,
...         nullable=True
...     )
...

>>> def only_odd_numbers(item):
... if item % 2 != 1:
...    raise validators.ValidationError("Only odd numbers are accepted")
...
>>> class Person(models.Base):
... lucky_numbers = fields.ListField(int, item_validators=[only_odd_numbers])
... item_validator_str = fields.ListField(
...        str,
...        item_validators=[validators.Length(10, 20), validators.Regex(r"\w+")],
...        validators=[validators.Length(1, 2)],
...    )
...
>>> Person.to_json_schema()
{
    "type": "object",
    "additionalProperties": false,
    "properties": {
        "item_validator_str": {
            "type": "array",
            "items": {
                "type": "string",
                "minLength": 10,
                "maxLength": 20,
                "pattern": "/\\w+/"
            },
            "minItems": 1,
            "maxItems": 2
        },
        "lucky_numbers": {
            "type": "array",
            "items": {
                "type": "number"
            }
        }
    }
}

(Note that only_odd_numbers did not modify schema, since only class based validators are able to do that, though it will still work as expected in python. Use class based validators that can be expressed in json schema if you want to be 100% correct on schema side.)

  • Lazy loading, best for circular references:

    >>> class Primary(models.Base):
...
...     name = fields.StringField()
...     secondary = fields.EmbeddedField('Secondary')

>>> class Secondary(models.Base):
...
...    data = fields.IntField()
...    first = fields.EmbeddedField('Primary')

    You can use either Model, full path path.to.Model or relative imports .Model or ...Model.

  • Using definitions to generate schema for circular references:

    >>> class File(models.Base):
...
...     name = fields.StringField()
...     size = fields.FloatField()

>>> class Directory(models.Base):
...
...     name = fields.StringField()
...     children = fields.ListField(['Directory', File])

>>> class Filesystem(models.Base):
...
...     name = fields.StringField()
...     children = fields.ListField([Directory, File])

>>> Filesystem.to_json_schema()
{
    "type": "object",
    "properties": {
        "name": {"type": "string"}
        "children": {
            "items": {
                "oneOf": [
                    "#/definitions/directory",
                    "#/definitions/file"
                ]
            },
            "type": "array"
        }
    },
    "additionalProperties": false,
    "definitions": {
        "directory": {
            "additionalProperties": false,
            "properties": {
                "children": {
                    "items": {
                        "oneOf": [
                            "#/definitions/directory",
                            "#/definitions/file"
                        ]
                    },
                    "type": "array"
                },
                "name": {"type": "string"}
            },
            "type": "object"
        },
        "file": {
            "additionalProperties": false,
            "properties": {
                "name": {"type": "string"},
                "size": {"type": "number"}
            },
            "type": "object"
        }
    }
}

  • Dealing with schemaless data

(Plese note that using schemaless fields can cause your models to get out of control - especially if you are the one responsible for data schema. On the other hand there is usually the case when incomming data are with no schema defined and schemaless fields are the way to go.)

>>> class Event(models.Base):
...
...     name = fields.StringField()
...     size = fields.FloatField()
...     extra = fields.DictField()

>>> Event.to_json_schema()
{
    "type": "object",
    "additionalProperties": false,
    "properties": {
        "extra": {
            "type": "object"
        },
        "name": {
            "type": "string"
        },
        "size": {
            "type": "float"
        }
    }
}

DictField allow to pass any dict of values ("type": "object"), but note, that it will not make any validation on values except for the dict type.

  • Compare JSON schemas:

    >>> from jsonmodels.utils import compare_schemas
>>> schema1 = {'type': 'object'}
>>> schema2 = {'type': 'array'}
>>> compare_schemas(schema1, schema1)
True
>>> compare_schemas(schema1, schema2)
False

More

For more examples and better description see full documentation: http://jsonmodels.rtfd.org.

More Repositories

1

django-debug-toolbar

A configurable set of panels that display various debug information about the current request/response.
Python
7,858
star
2

pip-tools

A set of tools to keep your pinned Python dependencies fresh.
Python
7,398
star
3

tablib

Python Module for Tabular Datasets in XLS, CSV, JSON, YAML, &c.
Python
4,500
star
4

django-silk

Silky smooth profiling for Django
Python
4,210
star
5

djangorestframework-simplejwt

A JSON Web Token authentication plugin for the Django REST Framework.
Python
3,765
star
6

django-taggit

Simple tagging for django
Python
3,205
star
7

django-oauth-toolkit

OAuth2 goodies for the Djangonauts!
Python
3,021
star
8

django-redis

Full featured redis cache backend for Django.
Python
2,773
star
9

django-model-utils

Django model mixins and utilities.
Python
2,577
star
10

django-push-notifications

Send push notifications to mobile devices through GCM or APNS in Django.
Python
2,210
star
11

django-simple-history

Store model history and view/revert changes from admin site.
Python
2,083
star
12

django-widget-tweaks

Tweak the form field rendering in templates, not in python-level form definitions. CSS classes and HTML attributes can be altered.
Python
2,019
star
13

sorl-thumbnail

Thumbnails for Django
Python
1,717
star
14

django-constance

Dynamic Django settings.
Python
1,643
star
15

django-two-factor-auth

Complete Two-Factor Authentication for Django providing the easiest integration into most Django projects.
Python
1,590
star
16

django-polymorphic

Improved Django model inheritance with automatic downcasting
Python
1,577
star
17

django-pipeline

Pipeline is an asset packaging library for Django.
Python
1,489
star
18

dj-database-url

Use Database URLs in your Django Application.
Python
1,439
star
19

django-axes

Keep track of failed login attempts in Django-powered sites.
Python
1,356
star
20

django-tinymce

TinyMCE integration for Django
JavaScript
1,231
star
21

prettytable

Display tabular data in a visually appealing ASCII table format
Python
1,223
star
22

django-admin2

Extendable, adaptable rewrite of django.contrib.admin
Python
1,182
star
23

django-analytical

Analytics services for Django projects
Python
1,174
star
24

django-smart-selects

chained and grouped selects for django forms
Python
1,094
star
25

django-waffle

A feature flipper for Django
Python
1,075
star
26

django-configurations

A helper for organizing Django project settings by relying on well established programming patterns.
Python
1,067
star
27

django-rest-knox

Authentication Module for django rest auth
Python
1,057
star
28

django-defender

A simple super fast django reusable app that blocks people from brute forcing login attempts
Python
997
star
29

django-auditlog

A Django app that keeps a log of changes made to an object.
Python
990
star
30

django-payments

Universal payment handling for Django.
Python
964
star
31

django-hosts

Dynamic and static host resolving for Django. Maps hostnames to URLconfs.
Python
942
star
32

django-nose

Django test runner using nose
Python
882
star
33

django-dbbackup

Management commands to help backup and restore your project database and media files
Python
879
star
34

geojson

Python bindings and utilities for GeoJSON
Python
876
star
35

django-floppyforms

Full control of form rendering in the templates.
Python
836
star
36

django-newsletter

An email newsletter application for the Django web application framework, including an extended admin interface, web (un)subscription, dynamic e-mail templates, an archive and HTML email support.
Python
825
star
37

django-avatar

A Django app for handling user avatars.
Python
797
star
38

django-formtools

A set of high-level abstractions for Django forms
Python
735
star
39

django-user-sessions

Extend Django sessions with a foreign key back to the user, allowing enumerating all user's sessions.
Python
586
star
40

django-admin-sortable

Generic drag-and-drop ordering for objects and tabular inlines in Django Admin
Python
557
star
41

django-invitations

Generic invitations app for Django
Python
530
star
42

django-sortedm2m

A transparent sorted ManyToMany field for django.
Python
508
star
43

django-recurrence

Utility for working with recurring dates in Django.
Python
460
star
44

django-categories

This app attempts to provide a generic category system that multiple apps could use. It uses MPTT for the tree storage and provides a custom admin for better visualization (copied and modified from feinCMS).
Python
455
star
45

django-robots

A Django app for managing robots.txt files following the robots exclusion protocol
Python
451
star
46

django-embed-video

Django app for easy embedding YouTube and Vimeo videos and music from SoundCloud.
Python
383
star
47

wagtailmenus

An app to help you manage and render menus in your Wagtail projects more effectively
Python
380
star
48

django-downloadview

Serve files with Django.
Python
357
star
49

django-queued-storage

Provides a proxy for Django storage backends that allows you to upload files locally and eventually serve them remotely
Python
314
star
50

django-permission

[Not maintained] An enhanced permission system which support object permission in Django
Python
302
star
51

django-eav2

Django EAV 2 - EAV storage for modern Django
Python
297
star
52

django-revproxy

Reverse Proxy view that supports all HTTP methods, Diazo transformations and Single Sign-On.
Python
290
star
53

django-authority

A Django app that provides generic per-object-permissions for Django's auth app and helpers to create custom permission checks.
Python
286
star
54

django-simple-menu

Simple, yet powerful, code-based menus for Django applications
Python
258
star
55

django-dbtemplates

Django template loader for database stored templates with extensible cache backend
JavaScript
250
star
56

django-mongonaut

Built from scratch to replicate some of the Django admin functionality and add some more, to serve as an introspective interface for Django and Mongo.
Python
240
star
57

django-fsm-log

Automatic logging for Django FSM
Python
235
star
58

django-cookie-consent

Reusable application for managing various cookies and visitors consent for their use in Django project.
Python
210
star
59

django-celery-monitor

Celery Monitoring for Django
Python
191
star
60

django-ddp

Django/PostgreSQL implementation of the Meteor server.
Python
167
star
61

icalevents

Python module for iCal URL/file parsing and querying.
Python
153
star
62

docopt-ng

Humane command line arguments parser. Now with maintenance, typehints, and complete test coverage.
Python
149
star
63

django-voting

A generic voting application for Django
Python
93
star
64

django-ical

iCal feeds for Django based on Django's syndication feed framework.
Python
89
star
65

django-flatblocks

django-chunks + headerfield + variable chunknames + "inclusion tag" == django-flatblocks
Python
82
star
66

django-redshift-backend

Redshift database backend for Django
Python
80
star
67

pathlib2

Backport of pathlib aiming to support the full stdlib Python API.
Python
80
star
68

website

Code for the Jazzband website
Python
63
star
69

django-sorter

A helper app for sorting objects in Django templates.
Python
53
star
70

django-discover-jenkins

A streamlined fork of django-jenkins designed to work with the default test command and the discover runner
Python
49
star
71

contextlib2

contextlib2 is a backport of the standard library's contextlib module to earlier Python versions.
Python
37
star
72

django-fernet-encrypted-fields

Python
35
star
73

imaplib2

Fork of Piers Lauder's imaplib2 library for Python.
Python
31
star
74

help

Use this repo to get help from the roadies
27
star
75

.github

Community health and config files for Jazzband
7
star
76

django-postgres-utils

Django app providing additional lookups and functions for PostgreSQL
Python
7
star
77

admin

Some admin files for Jazzband
3
star
78

actions

Various GitHub actions for Jazzband projects
1
star