Metadata-Version: 2.0
Name: schematics-factory
Version: 0.1.0
Summary: Convenient anonymous and nested models using dict literal syntax for Schematics.
Home-page: https://github.com/douglas-treadwell/schematics-factory
Author: Douglas Treadwell
Author-email: douglas.treadwell@gmail.com
License: MIT
Keywords: schematics,validation,schema,model,models,modelling,object,objects
Platform: UNKNOWN
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Requires-Dist: schematics

Schematics Factory
==================


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

It's sometimes inconvenient to define
named [Schematics](https://github.com/schematics/schematics)
Models, especially when those models are deeply nested.

Example:

```
class InnerModel(Model):
    inner_bool = BooleanType()


class MiddleModel(Model):
    middle_int = IntType()
    middle_nested = ModelType(InnerModel)


class OuterModel(Model):
    outer_str = StringType()
    outer_nested = ModelType(MiddleModel)


model_instance = OuterModel(input_)
model_instance.validate()
```

So, this library provides a convenient syntax for defining
deeply nested Models.

```
from schematics_factory import model

OuterModel = model({
    'outer_str': StringType(),
    'outer_nested': ModelType(model({
        'middle_int': IntType(),
        'middle_nested': ModelType(model({
            'inner_bool': BooleanType()
        }))
    }))
})

model_instance = OuterModel(input_)
model_instance.validate()
```

The model() function can also be imported as _model_factory_.

Alternative Syntax
------------------

Schema factory arguments can also be supplied as keyword
arguments rather than a dictionary.

```
Person = model(name=StringType(), age=IntType())

person = Person(dict(name='Test', age=27))

person.validate()
```

For nested Models, a concise __nested()__ convenience function
is provided to replace ModelType(model(...)) with nested(...).
The nested() function can also be imported as _nested_model_.

```
from schematics_factory import model, nested

Person = model(name=StringType(), pet=nested(name=StringType()))

person = Person(dict(name='Test', pet=dict(name='Rover')))

person.validate()
```

Nested models can also be provided as plain dictionary literals.

```
Person = model(name=StringType(), pet=dict(name=StringType()))

person = Person(dict(name='Test', pet=dict(name='Rover')))

person.validate()
```

Or equivalently...

```
Person = model({
    'name': StringType(),
    'pet': {
        'name': StringType()
    }
})

person = Person({
    'name': 'Test',
    'pet': {
        'name': 'Rover'
    }
})

person.validate()
```


