Convert a JSON schema to a python class

Question

Is there a python library for converting a JSON schema to a python class definition, similar to jsonschema2pojo -- https://github.com/joelittlejohn/jsonschema2pojo -- for Java?

Solution 1

So far the closest thing I've been able to find is warlock, which advertises this workflow:

Build your schema

>>> schema = {
    'name': 'Country',
    'properties': {
        'name': {'type': 'string'},
        'abbreviation': {'type': 'string'},
    },
    'additionalProperties': False,
}

Create a model

>>> import warlock
>>> Country = warlock.model_factory(schema)

Create an object using your model

>>> sweden = Country(name='Sweden', abbreviation='SE')

However, it's not quite that easy. The objects that Warlock produces lack much in the way of introspectible goodies. And if it supports nested dicts at initialization, I was unable to figure out how to make them work.

To give a little background, the problem that I was working on was how to take Chrome's JSONSchema API and produce a tree of request generators and response handlers. Warlock doesn't seem too far off the mark, the only downside is that meta-classes in Python can't really be turned into 'code'.

Other useful modules to look for:

• jsonschema - (which Warlock is built on top of)
• valideer - similar to jsonschema but with a worse name.
• bunch - An interesting structure builder thats half-way between a dotdict and construct

If you end up finding a good one-stop solution for this please follow up your question - I'd love to find one. I poured through github, pypi, googlecode, sourceforge, etc.. And just couldn't find anything really sexy.

For lack of any pre-made solutions, I'll probably cobble together something with Warlock myself. So if I beat you to it, I'll update my answer. :p

Solution 2

python-jsonschema-objects is an alternative to warlock, build on top of jsonschema

python-jsonschema-objects provides an automatic class-based binding to JSON schemas for use in python.

Usage:

Sample Json Schema

schema = '''{
    "title": "Example Schema",
    "type": "object",
    "properties": {
        "firstName": {
            "type": "string"
        },
        "lastName": {
            "type": "string"
        },
        "age": {
            "description": "Age in years",
            "type": "integer",
            "minimum": 0
        },
        "dogs": {
            "type": "array",
            "items": {"type": "string"},
            "maxItems": 4
        },
        "gender": {
            "type": "string",
            "enum": ["male", "female"]
        },
        "deceased": {
            "enum": ["yes", "no", 1, 0, "true", "false"]
            }
    },
    "required": ["firstName", "lastName"]
} '''

Converting the schema object to class

 import python_jsonschema_objects as pjs
 import json
 schema = json.loads(schema)   
 builder = pjs.ObjectBuilder(schema)   
 ns = builder.build_classes()   
 Person = ns.ExampleSchema   
 james = Person(firstName="James", lastName="Bond")   
 james.lastName  
  u'Bond'  james      
 example_schema lastName=Bond age=None firstName=James  

Validation :

james.age = -2 python_jsonschema_objects.validators.ValidationError: -2 was less or equal to than 0

But problem is , it is still using draft4validation while jsonschema has moved over draft4validation , i filed an issue on the repo regarding this . Unless you are using old version of jsonschema , the above package will work as shown.

Solution 3

I just created this small project to generate code classes from json schema, even if dealing with python I think can be useful when working in business projects:

pip install jsonschema2popo

running following command will generate a python module containing json-schema defined classes (it uses jinja2 templating)

jsonschema2popo -o /path/to/output_file.py /path/to/json_schema.json

more info at: https://github.com/frx08/jsonschema2popo

Comments

[Nick Gerner]

Ditto on following up. I went through the same sources and couldn't find any acceptable solution. I even forked warlock and started working on implementing recursion in their class definition (which seems like it should be fairly easy), but gave up.

[SDani]

Worth noting that python-jsonschema-objects supports JSON Schema Draft-4

[Mikhail]

The library does what it promises, but has silly assumptions, bugs, and typos. All addressable but far from polished.

[Robert P. Goldman]

Downgraded this answer because jsonschema2popo is riddled with bugs, and seems bitrotted.

[Robert P. Goldman]

Looks like python-jsonschema-objects cannot emit class definitions in files, so it's hard to know what is going on with these, they are not easily used in type declarations, etc. It would be nice if class definitions could be written as source code.