limone 0.1a5

声明性创建内容类型

可以使用装饰器从架构定义中声明性生成内容类型。以下是一个示例，摘自Colander文档

import colander

class Friend(colander.TupleSchema):
    rank = colander.SchemaNode(colander.Int(),
                              validator=colander.Range(0, 9999))
    name = colander.SchemaNode(colander.String())

class Phone(colander.MappingSchema):
    location = colander.SchemaNode(colander.String(),
                                  validator=colander.OneOf(['home', 'work']))
    number = colander.SchemaNode(colander.String())

class Friends(colander.SequenceSchema):
    friend = Friend()

class Phones(colander.SequenceSchema):
    phone = Phone()

class Person(colander.MappingSchema):
    name = colander.SchemaNode(colander.String())
    age = colander.SchemaNode(colander.Int(),
                             validator=colander.Range(0, 200))
    friends = Friends()
    phones = Phones()

创建Person内容类型的最简单方法是添加limone.content_schema装饰器

import colander
import limone

... <elided for brevity>

@limone.content_schema
class Person(colander.MappingSchema):
    name = etc...

然后可以像往常一样创建Person实例

jack = Person(
    name='Jack',
    age=52,
    friends=[
        (1, 'Fred'),
        (2, 'Barney')
    ],
    phones=[
        {'location': 'home',
         'number': '555-1212'},
    ])

将值赋给属性会触发Colander架构验证。例如，当将值300赋给age时

jack.age = 300

会引发一个colander.Invalid异常

colander.Invalid: {'age': u'300 is greater than maximum value 200'}

在实例化内容类型时，必须提供所有必需属性的值

fred = Person()

引发

colander.Invalid: {'age': u'Required', 'name': u'Required'}

用架构装饰类

在某些情况下，您可能希望将类与其模式分开定义。为此，您可以使用 limone.content_type 装饰器。假设我们不是直接将 Person 模式转换为内容类型，而是有一个 HRPerson 类，它扩展了我们想用作内容类型的假设的 HRRecord 类

@limone.content_type(Person)
class HRPerson(HRRecord):
    pass

fred = HRPerson(name='Fred', age=54)

注意 被装饰的类必须有一个无参构造函数。

命令式创建内容类型

上面的例子使用声明式风格创建内容类型。使用 make_content_type 函数，我们也可以命令式地生成新内容类型。假设 HRPerson 已被定义为一个类，上面的例子可以写成

content_type = limone.make_content_type(Person, 'Person', bases=(HRPerson,))
fred = content_type(name='Joe', age=54)

make_content_type 函数的完整签名是

make_content_type(schema, name, module=None, bases=(object,))

• schema 是用于生成类的 Colander 模式。

• name 参数的值将被分配给生成的类的 __name__ 属性。如果添加到注册表中，该名称也将用作稍后查找内容类型的键。（参见 使用 Limone 注册表。）

• 如果指定，module 将用于设置生成的类的 __module__ 属性。

• bases 可以指定为元组，表示生成的类的超类。 注意 第一个基类必须有一个无参构造函数。

使用 Limone 注册表

可以使用 limone.Registry 实例来跟踪可用的内容类型。要使内容类型可通过导入钩子提供，需要一个 limone.Registry 实例。（参见 使用导入钩子。）

registry = limone.Registry()
registry.regsister_content_type(Person)

content_type = registry.get_content_type('Person')
joe = content_type(name='Joe', age=54)

for content_type in registry.get_content_types():
    print content_type.__name__, content_type

Person <class 'Person'>

import limone
import myapp.models

registry = limone.Registry()
registry.scan(myapp.models)

import pickle

content_type = make_content_type(PersonSchema, 'Person', bases=(HRPerson,))
fred = content_type(name='Fred', age=54)
fred2 = pickle.loads(pickle.dumps(fred))
assert fred is not fred2
assert fred.serialize() == fred2.serialize()

pickle.PicklingError: Can't pickle <class 'Person'>: it's not found as __main__.Person

import pickle

registry = limone.Registry()
registry.register_content_type(Person)
registry.hook_import()

content_type = make_content_type(PersonSchema, 'Person', bases=(HRPerson,))
fred = content_type(name='Fred', age=54)
fred2 = pickle.loads(pickle.dumps(fred))
assert fred is not fred2
assert fred.serialize() == fred2.serialize()

registry.unhook_import()

hook_import(module='__limone__')

from __limone__ import Person
fred = Person(name='Fred', age=54)

使用Colander Appstruct

内容类型的实例可以被转换为它们的Colander appstruct表示。

jack = Person(
    name='Jack',
    age=52,
    friends=[
        (1, 'Fred'),
        (2, 'Barney')
    ],
    phones=[
        {'location': 'home',
         'number': '555-1212'},
    ])

from pprint import pprint
pprint(jack.appstuct())

生成此输出

{'age': 52,
 'friends': [(1, u'Fred'), (2, u'Barney')],
 'name': u'Jack',
 'phones': [{'location': u'home', 'number': u'555-1212'}]}

可以从appstruct创建一个新的实例。

jack = Person.from_appstruct(
    {'age': 52,
     'friends': [(1, u'Fred'), (2, u'Barney')],
     'name': u'Jack',
     'phones': [{'location': u'home', 'number': u'555-1212'}]})

可以使用部分appstruct来更新实例。

jack.update_from_appstruct({'age': 53})

使用Colander的序列化/反序列化

可以使用Colander的序列化来序列化内容类型的实例。

jack = Person(
    name='Jack',
    age=52,
    friends=[
        (1, 'Fred'),
        (2, 'Barney')
    ],
    phones=[
        {'location': 'home',
         'number': '555-1212'},
    ])

from pprint import pprint
pprint(jack.serialize())

生成此输出

{'age': '52',
 'friends': [('1', u'Fred'), ('2', u'Barney')],
 'name': u'Jack',
 'phones': [{'location': u'home', 'number': u'555-1212'}]}

注意，Colander的序列化是一种中间格式。所有标量值都序列化为字符串，但序列、元组和映射分别作为列表、元组和字典返回。这种中间形式可以很容易地输入到其他序列化器中，如json，以生成序列化的字节序列。

可以通过Colander的反序列化实例化实例。

jack = Person.deserialize(
    {'age': '52',
     'friends': [('1', u'Fred'), ('2', u'Barney')],
     'name': u'Jack',
     'phones': [{'location': u'home', 'number': u'555-1212'}]})

反序列化也可以用于更新现有实例。

jack.deserialize_update({'age': '53'})

Limone的变更日志

0.1a5（2011-09-01）

• 添加了将实例转换为Colander appstruct的公共API。