Simple Model

SimpleModel offers a simple way to handle data using classes instead of a plenty of lists and dicts.

It has simple objectives:

• Define models and its fields easily using class attributes, type annotations or tuples (whatever suits your needs)
• Support for field validation, cleaning and type conversion
• Easy model conversion to dict

Quickstart

Installing

Open your favorite shell and run the following command:

pip install pysimplemodel

Example

Define your models using type annotations:

fromsimple_modelimportModelclassPerson(Model):
age: intheight: floatis_active: bool=Truename: str

Simple model automatically creates an initializer for your model and you all set to create instances:

>>person=Person(age=18, height=1.67, name='John Doe')>>person.name'John Doe'

As you have noticed we haven't informed a value for field is_active, but the model was still created. That's because we've set a default value of True for it and the model takes care of assigning it automatically to the field:

>>person.is_activeTrue

Simple model also offers model validation. Empty fields are considered invalid and will raise errors upon validation. Let's perform some tests using the previous Person model:

>>person=Person()>>print(person.name)
None>>person.validate()
Traceback (mostrecentcalllast):
...
EmptyField: 'height'fieldcannotbeempty

Let's say we want the height and age fields to be optional, that can be achieved with the following piece of code:

fromsimple_modelimportModelclassPerson(Model):
age: int=Noneheight: float=Noneis_active: bool=Truename: str

Now let's test it:

>>person=Person(name='Jane Doe', is_active=False)>>person.is_activeFalse>>person.validate()
True

The last line won't raise an exception which means the model instance is valid! In case you need the validation to return True or False instead of raising an exception that's possible by doing the following:

>>person.validate(raise_exception=False)
True

You can also add custom validations by writing class methods prefixed by validate followed by the attribute name, e.g.

classPerson:
age: intheight: floatname: strdefvalidate_age(self, age):
ifage<0orage>150:
raiseValidationError('Invalid value for age {!r}'.format(age))
returnagedefvalidate_height(self, height):
ifheight<=0:
raiseValidationError('Invalid value for height {!r}'.format(age))
returnheight

Let's test it:

>>person=Person(name='John Doe', age=190)>>person.validate()
Traceback (mostrecentcalllast):
...
ValidationError: Invalidvalueforage190>>other_person=Person(name='Jane Doe', height=-1.67)
>>other_person.validate()
Traceback (mostrecentcalllast):
...
ValidationError: Invalidvalueforheight-1.67

It is important to note that models don't validate types. Currently types are used for field value conversion.

The validate method also supports cleaning the field values by defining custom transformations in the validate_ methods:

classPerson:
age: intname: strdefvalidate_name(self, name):
returnname.strip()
>>>person=Person(age=18.0, name='John Doe ')
>>>person.name'John Doe '>>person.age18.0>>>person.validate()
>>>person.name'John Doe'>>>person.age# all attributes are converted to its type before cleaning18# converted from float (18.0) to int (18)

Finally, simple model allows you to easily convert your model to dict type using the function to_dict():

>>>to_dict(person)
{
'age': 18,
'name': 'John Doe'
}

Documentation

Docs on simple-model.rtfd.io