

Schematics – Python Data Structures for Humans - rbanffy
https://github.com/schematics/schematics

======
Ixiaus
[http://colander.readthedocs.org/en/latest/](http://colander.readthedocs.org/en/latest/)

Is really mature and I've found it to be a wonderful tool - it has an addon
called Deform for serializing forms into colander schemas but colander is not
limited to that.

I've used it for creating "schemas" for API endpoints and validating them. It
would be nice to use it DB backed ORMs but even there you're kind of covered
with a SQLAlchemy Colander attachment...

~~~
jmsdnns
Hey, one of the authors of Schematics here. I think Colander rocks. I had no
idea about it until two years into the Schematics project and we just kept
going.

Choice is good! If you dig Schematics, check out Colander too.

------
rav
With my CS background, I find this usage of "Data Structures" in the title
confusing. I was expecting some sort of visualization framework for viewing
tree/graph structures, so I think the title is a bit misleading.

~~~
kps
I thought it was going to be about data structures for circuit design.

------
calpaterson
This seems like a more developed version of voluptuous (a validation library):

[https://github.com/alecthomas/voluptuous](https://github.com/alecthomas/voluptuous)

Voluptuous is perfect for putting as validation in from of a JSON API. Not
sure what I would use schematics for

------
kanzure
Cool. What about using traitlets to get a larger type library? For example,
see: [https://github.com/kanzure/modelo](https://github.com/kanzure/modelo)

Also, do you have any thoughts about hooking something like this up to
sqlalchemy?

~~~
jmsdnns
There is a project on the Schematics org page for using with sqlalchemy. I
haven't used it myself, but I would look there first.

[https://github.com/schematics/schemalchemy](https://github.com/schematics/schemalchemy)

------
reinhardt
More Python data validation packages here: [https://github.com/vinta/awesome-
python#data-validation](https://github.com/vinta/awesome-python#data-
validation). Personally I dig Valideer.

------
webmdee
I don't fully understand the purpose of this

~~~
ryanknapp
Schematics makes it easy to specify an API interface. It will let you bind /
coerce json to your types, and then validate that the provided json bound
exactly (no extra fields, no missing required fields, custom validators). We
also extended it to provide a polymorphic type that will bind to a class based
on a discriminator value in the json (based on an old gist from one of the
schematics contributors). The roles definition also allows you to provide
different serialized views of a model (though whether the model should be
aware of that concern is questionable, but a nice shortcut).

We use schematics to back the data on our domain models. It provides models
that are separate from persistence models that live in the data / client layer
(database or external service bound), and gives you a few nice things for free
(like validation) and you can attach behavior to them.

The only things I would like to see added are:

    
    
      - A native polymorphic type (we're going to try and submit a pull request with our implementation within the next month)
    
      - Roles (lists of fields that are output) optionally separated from the models.
    
      - Support for redefining a model (currently it is difficult to add a self referencing field and have schematics pick it up for you, or add fields through mixins).

------
88e282102ae2e5b
How does the implementation of OrderedDict differ from the one in the standard
library?

~~~
jmsdnns
It may be similar now. It was borrowed from Django before there was one in the
stllib

