tinyschema 0.2.1

schema definition

The way of schema definition is like a below sample.

import tinyschema as t

class Point(t.Schema):
    x = t.column(t.IntegerField)
    y = t.column(t.IntegerField)
    z = t.column(t.IntegerField, required=False)

Accessing field with dot-access, like a plain python object. But a returned object is wrapped by Field object.

Field object has these members.

• name – name of field (system value)

• value – value of field

So this Point schema accessing a field like a below.

pt = Point(x=10, y=20)

print(pt.x.name)   # => x
print(pt.x.value)  # => 10

class Point(t.Schema):
    x = t.column(t.IntegerField, label=u"x-coordinate", class_="hidden")

pt = Point(x=10, y=20)

print(pt.x.label)  # => x-coordinate
print(pt.x.class_) # => "hidden"

schema validation

Schema has a behavior of schema-validation. schema-validation is format checking.

• filtering expected values only.

• checking type of value.

• converting value if need.

params = {"x": "10", "y": "20", "foo": "foo"}
pt = Point.fromdict(params)
print(pt.validate())  # => OrderedDict([('x', 10), ('y', 20), ('z', None)])

schema-validation is run by calling validate() method. In above code, “foo” value is not member of Point schema, so validated value does not include a value name of foo. And a column-z has required=False option, because of this, a passed value that doesn’t have a value name of z, converted value is None.

params = {"x": "aa"}
pt = Point.fromdict(params)
pt.validate()
# tinyschema.Failure: <Failure errors=defaultdict(<class 'list'>, {'y': ['required'], 'x': ['aa is not int']})>

Adding field validation

Adding field validation example is here.(using oneOf validator)

class Signal(t.Schema):
    color = t.column(t.TextField, t.OneOf(["red", "blue", "yellow"]))

# success version
signal = Signal(color="red")
data = signal.validate()
print(data["color"])  # => "red"

# failure version
try:
    signal2 = Signal(color="green")
    data = signal2.validate()
except t.Failure as e:
    print(e)
   # <Failure errors=defaultdict(<class 'list'>, {'color': ['green is not in red, blue, yellow']})>

default validator are below.

• Any, Regex, Email, Range, Length, OneOf, Subset, URL

default type of field.

• IntegerField, FloatField, BooleanField, TextField, ChoicesField, PositiveIntegerField

more complex structure

tinyschema support more complex structure like a dict-tree, sequence, or combination of one.

class Pair(t.Schema):
    l = t.column(t.Container(Point), class_="left")
    r = t.column(t.Container(Point), class_="right")

params = {
    "l": {"x": "10", "y": "20", "foo": "foo"},
    "r": {"x": "100", "y": "20"},
}

pair = Pair.fromdict(params)

import pprint
pprint.pprint(pair.validate())
# {'l': OrderedDict([('x', 10), ('y', 20), ('z', None)]),
#  'r': OrderedDict([('x', 100), ('y', 20), ('z', None)])}

pair.l.value.x.name # => x
pair.l.value.x.value # => 10

class PointList(t.Schema):
    points = t.column(t.Collection(Point))

params = {
    "points": [{"x": "10", "y": "20"}, {"x": "20", "y": "20"}, {"x": "30", "y": "20"}, ]
}

plist = PointList.fromdict(params)

import pprint
pprint.pprint(plist.validate())
# {'points': [OrderedDict([('x', 10), ('y', 20), ('z', None)]),
#             OrderedDict([('x', 20), ('y', 20), ('z', None)]),
#             OrderedDict([('x', 30), ('y', 20), ('z', None)])]}

data validation

data-validation is a checking about a relation of each data.

(TODO: gentle example)

from tinyschema.datavalidation import ValidationObject, multi, Invalid, single, share


class PointValidation(ValidationObject):
    def __init__(self, limit):
        self.limit = limit

    @multi(["x", "z"])
    def equals(self, x, z):
        if x != z:
            raise Invalid("not equal")

    @share(single("x"), single("y"), single("z"))
    def limit(self, value):
        if value > self.limit:
            raise Invalid("too large")

validate = PointValidation(limit=100)

print(validate(Point(x=10, y=20)))  # => OrderedDict([('x', 10), ('y', 20), ('z', None)])

print(validate(Point(x=10, y=20, z=10)))  # => OrderedDict([('x', 10), ('y', 20), ('z', 10)])

print(validate(Point(x=10, y=20, z=1000)))
# tinyschema.Failure: <Failure errors=defaultdict(<class 'list'>, {'z': ['too large'], 'x': ['not equal']})>

print(validate(Point(x="aa")))
# tinyschema.Failure: <Failure errors=defaultdict(<class 'list'>, {'x': ['aa is not int'], 'y': ['required']})>