def test_naming_list_list(): # make sure nested Slots-users don't bork for name, root_flat, leaf_flat in ((u'l', u'l', u'l_0_l2_0_s'), (None, u'', u'0_l2_0_s')): schema = List.named(name).of(List.named(u'l2').of(String.named(u's'))) root = schema([u'x']) leaf = root[0][0] assert root.fq_name() == u'.' assert root.flattened_name() == root_flat assert root.el(u'.') is root assert leaf.fq_name() == u'.0.0' assert leaf.flattened_name() == leaf_flat assert root.el(u'.0.0') is leaf assert root.el(u'0.0') is leaf assert leaf.el(u'.0.0') is leaf with pytest.raises(LookupError): leaf.el(u'0') with pytest.raises(LookupError): leaf.el(u's') assert leaf.el(u'.') is root assert root.el([u'0', u'0']) is leaf
def test_mixed_all_children(): data = {u'A1': u'1', u'A2': u'2', u'A3': {u'A3B1': {u'A3B1C1': u'1', u'A3B1C2': u'2'}, u'A3B2': {u'A3B2C1': u'1'}, u'A3B3': [[u'A3B3C0D0', u'A3B3C0D1'], [u'A3B3C1D0', u'A3B3C1D1'], [u'A3B3C2D0', u'A3B3C2D1']]}} schema = ( Dict.named(u'R').of( String.named(u'A1'), String.named(u'A2'), Dict.named(u'A3').of( Dict.named(u'A3B1').of( String.named(u'A3B1C1'), String.named(u'A3B1C2')), Dict.named(u'A3B2').of( String.named(u'A3B2C1')), List.named(u'A3B3').of( List.named(u'A3B3Cx').of( String.named(u'A3B3x')))))) top = schema(data) names = list(e.name for e in top.all_children) assert set(names[0:3]) == set([u'A1', u'A2', u'A3']) assert set(names[3:6]) == set([u'A3B1', u'A3B2', u'A3B3']) assert set(names[6:12]) == set([u'A3B1C1', u'A3B1C2', u'A3B2C1', u'A3B3Cx']) assert set(names[12:]) == set([u'A3B3x']) assert len(names[12:]) == 6
def form(): schema = Dict.named(u'field0').of( String.named(u'field1'), String.named(u'field2'), List.named(u'field3').of(String.named(u'field4')), List.named(u'field5').of( List.named(u'field6').of(String.named(u'field7')))) element = schema({ u'field1': u'val1', u'field2': u'val2', u'field3': [u'val3'], u'field5': [[u'val4']] }) element.set_prefix(u'form') return {'form': element, 'bound': element.bind}
def form(): schema = Dict.named(u'field0').of( String.named(u'field1'), String.named(u'field2'), List.named(u'field3').of(String.named(u'field4')), List.named(u'field5').of( List.named(u'field6').of(String.named(u'field7')))) element = schema( {u'field1': u'val1', u'field2': u'val2', u'field3': [u'val3'], u'field5': [[u'val4']]}) element.set_prefix(u'form') return {'form': element, 'bound': element.bind}
def test_access(): pairs = ((u'l_0_i', u'10'), (u'l_1_i', u'11'), (u'l_2_i', u'12'),) schema = List.named(u'l').of(Integer.named(u'i')) el = schema.from_flat(pairs) elements = list(Integer.named(u'i')(val) for val in (u'10', u'11', u'12')) assert len(el) == 3 assert el[0] == elements[0] assert el[1] == elements[1] assert el[2] == elements[2] assert el[0].value == 10 assert el[:0] == elements[:0] assert el[:1] == elements[:1] assert el[0:5] == elements[0:5] assert el[-2:-1] == elements[-2:-1] assert el[0] in el assert elements[0] in el assert u'10' in el assert 10 in el assert el.count(elements[0]) == 1 assert el.count(u'10') == 1 assert el.count(10) == 1 assert el.index(elements[0]) == 0 assert el.index(u'10') == 0 assert el.index(10) == 0
def test_no_duplicates_list_anon_dict(): nd = NotDuplicated(failure=u'%(container_label)s %(position)s') schema = (List.named('test'). of(Dict.of(Integer.named('x'), Integer.named('y')). using(validators=[nd]))) _test_no_duplicates(schema, {'x': 1, 'y': 2}, {'x': 3, 'y': 4})
def test_set_flat_linear(): pairs = [(u'l_0_i', 1), (u'l_1_i', 2), (u'l_2_i', 3)] schema = List.named(u'l').of(Integer.named(u'i')) el = schema.from_flat(pairs) eq_(len(el), len(pairs)) eq_(el.value, list(pair[1] for pair in pairs))
def test_set_flat_miss(): pairs = [(u'l_galump', u'3'), (u'l_snorgle', u'4')] schema = List.named(u'l').of(Integer.named(u'i')) el = schema.from_flat(pairs) eq_(len(el), 0) eq_(el.value, [])
def test_reverse(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([2, 1]) assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')] el.reverse() assert el.value == [1, 2] assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')]
def test_set_flat_linear(): pairs = [(u'l_0_i', 1), (u'l_1_i', 2), (u'l_2_i', 3)] schema = List.named(u'l').of(Integer.named(u'i')) el = schema.from_flat(pairs) eq_(len(el), len(pairs)) eq_(el.value, list(pair[1] for pair in pairs))
def test_set_flat_miss(): pairs = [(u'l_galump', u'3'), (u'l_snorgle', u'4')] schema = List.named(u'l').of(Integer.named(u'i')) el = schema.from_flat(pairs) eq_(len(el), 0) eq_(el.value, [])
def test_reverse(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([2, 1]) assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')] el.reverse() assert el.value == [1, 2] assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')]
def test_values_equal_resolution(): v = ValuesEqual('x', '/sub/xx') el = form(dict(x='a', sub=dict(xx='a'))) assert v.validate(el, None) v = ValuesEqual('/x', 'xx') el = form(dict(x='a', sub=dict(xx='a'))) assert v.validate(el['sub'], None) # unhashable v = ValuesEqual('a', 'b') schema = Dict.of(List.named('a').of(String.named('x')), List.named('b').of(String.named('x'))) el = schema(dict(a=['a', 'b'], b=['a', 'b'])) assert v.validate(el, None) el = schema(dict(a=['a', 'b'], b=['x', 'y'])) assert not v.validate(el, None)
def test_values_equal_resolution(): v = ValuesEqual('x', '/sub/xx') el = form(dict(x='a', sub=dict(xx='a'))) assert v.validate(el, None) v = ValuesEqual('/x', 'xx') el = form(dict(x='a', sub=dict(xx='a'))) assert v.validate(el['sub'], None) # unhashable v = ValuesEqual('a', 'b') schema = Dict.of(List.named('a').of(String.named('x')), List.named('b').of(String.named('x'))) el = schema(dict(a=['a', 'b'], b=['a', 'b'])) assert v.validate(el, None) el = schema(dict(a=['a', 'b'], b=['x', 'y'])) assert not v.validate(el, None)
def test_slots(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([1, 2]) assert len(list(el._slots)) == 2 for slot in el._slots: # don't really care what it says, just no crashy. assert repr(slot) assert [slot.value for slot in el._slots] == [1, 2]
def test_slots(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([1, 2]) assert len(list(el._slots)) == 2 for slot in el._slots: # don't really care what it says, just no crashy. assert repr(slot) assert [slot.value for slot in el._slots] == [1, 2]
def test_sort(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([2, 1]) el.sort(key=lambda el: el.value) assert el.value == [1, 2] assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')] el.sort(key=lambda el: el.value, reverse=True) assert el.value == [2, 1] assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')]
def test_sort(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema([2, 1]) el.sort(key=lambda el: el.value) assert el.value == [1, 2] assert el.flatten() == [(u'l_0_i', u'1'), (u'l_1_i', u'2')] el.sort(key=lambda el: el.value, reverse=True) assert el.value == [2, 1] assert el.flatten() == [(u'l_0_i', u'2'), (u'l_1_i', u'1')]
def test_set_flat_anonymous_dict(): pairs = ((u'l_0_x', u'x0'), (u'l_0_y', u'y0'), (u'l_1_x', u'x1'), (u'l_1_y', u'y1'), (u'l_2_x', u'x2'), ) schema = List.named(u'l').of(String.named(u'x'), String.named(u'y')) el = schema.from_flat(pairs) eq_(len(el), 3) eq_(el[0].value, dict((k[-1], v) for k, v in pairs[0:2])) eq_(el[1].value, dict((k[-1], v) for k, v in pairs[2:4])) eq_(el[2].value, {u'x': u'x2', u'y': None})
def test_mutation(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema() new_element = Integer.named(u'i') def order_ok(): slot_names = list(_.name for _ in el._slots) for idx, name in enumerate(slot_names): assert name == str(idx).decode('ascii') assert not el order_ok() # FIXME:? seems to want parsable data, not elements el.append(new_element(u'0')) assert el.value == [0] order_ok() el.append(u'123') assert el.value == [0, 123] order_ok() el.extend([u'4', u'5']) assert el.value == [0, 123, 4, 5] order_ok() el[0] = u'3' assert el.value == [3, 123, 4, 5] order_ok() el.insert(0, u'2') assert el.value == [2, 3, 123, 4, 5] order_ok() v = el.pop() assert v.value == 5 assert not v.parent order_ok() v = el.pop(0) assert v.value == 2 assert el.value == [3, 123, 4] order_ok() el.remove(u'3') assert el.value == [123, 4] order_ok() del el[:] assert el.value == [] order_ok()
def test_mutation(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema() new_element = Integer.named(u'i') def order_ok(): slot_names = list(_.name for _ in el._slots) for idx, name in enumerate(slot_names): assert name == str(idx).decode('ascii') assert not el order_ok() # FIXME:? seems to want parsable data, not elements el.append(new_element(u'0')) assert el.value == [0] order_ok() el.append(u'123') assert el.value == [0, 123] order_ok() el.extend([u'4', u'5']) assert el.value == [0, 123, 4, 5] order_ok() el[0] = u'3' assert el.value == [3, 123, 4, 5] order_ok() el.insert(0, u'2') assert el.value == [2, 3, 123, 4, 5] order_ok() v = el.pop() assert v.value == 5 assert not v.parent order_ok() v = el.pop(0) assert v.value == 2 assert el.value == [3, 123, 4] order_ok() el.remove(u'3') assert el.value == [123, 4] order_ok() del el[:] assert el.value == [] order_ok()
def test_set_flat_unpruned(): pairs = [(u'l_0_i', u'0'), (u'l_2_i', u''), (u'l_3_i', u'3')] schema = List.named(u'l').of(Integer.named(u'i')).using(prune_empty=False) el = schema.from_flat(pairs) eq_(len(el), 4) eq_(el.value, [0, None, None, 3]) schema2 = schema.using(maximum_set_flat_members=2) el = schema2.from_flat(pairs) eq_(len(el), 2) eq_(el.value, [0, None])
def test_naming_list_list(): # make sure nested Slots-users don't bork for name, root_flat, leaf_flat in ((u'l', u'l', u'l_0_l2_0_s'), (None, u'', u'0_l2_0_s')): schema = List.named(name).of(List.named(u'l2').of(String.named(u's'))) root = schema([u'x']) leaf = root[0][0] assert root.fq_name() == u'.' assert root.flattened_name() == root_flat assert root.el(u'.') is root assert leaf.fq_name() == u'.0.0' assert leaf.flattened_name() == leaf_flat assert root.el(u'.0.0') is leaf assert root.el(u'0.0') is leaf assert leaf.el(u'.0.0') is leaf assert_raises(LookupError, leaf.el, u'0') assert_raises(LookupError, leaf.el, u's') assert leaf.el(u'.') is root assert root.el([u'0', u'0']) is leaf
def test_set_flat_unpruned(): pairs = [(u'l_0_i', u'0'), (u'l_2_i', u''), (u'l_3_i', u'3')] schema = List.named(u'l').of(Integer.named(u'i')).using(prune_empty=False) el = schema.from_flat(pairs) eq_(len(el), 4) eq_(el.value, [0, None, None, 3]) schema2 = schema.using(maximum_set_flat_members=2) el = schema2.from_flat(pairs) eq_(len(el), 2) eq_(el.value, [0, None])
def test_set_flat_pruned(): # pruned won't insert empty elements for a skipped index or empty rhs pairs = [(u'l_0_i', u'0'), (u'l_2_i', u''), (u'l_3_i', u'3')] schema = List.named(u'l').of(Integer.named(u'i')) el = schema.from_flat(pairs) eq_(len(el), 2) eq_(el.value, [0, 3]) schema2 = schema.using(maximum_set_flat_members=1) el = schema2.from_flat(pairs) eq_(len(el), 1) eq_(el.value, [0])
def test_set_flat_pruned(): # pruned won't insert empty elements for a skipped index or empty rhs pairs = [(u'l_0_i', u'0'), (u'l_2_i', u''), (u'l_3_i', u'3')] schema = List.named(u'l').of(Integer.named(u'i')) el = schema.from_flat(pairs) eq_(len(el), 2) eq_(el.value, [0, 3]) schema2 = schema.using(maximum_set_flat_members=1) el = schema2.from_flat(pairs) eq_(len(el), 1) eq_(el.value, [0])
def test_mixed_all_children(): data = { u'A1': u'1', u'A2': u'2', u'A3': { u'A3B1': { u'A3B1C1': u'1', u'A3B1C2': u'2' }, u'A3B2': { u'A3B2C1': u'1' }, u'A3B3': [[u'A3B3C0D0', u'A3B3C0D1'], [u'A3B3C1D0', u'A3B3C1D1'], [u'A3B3C2D0', u'A3B3C2D1']] } } schema = (Dict.named(u'R').of( String.named(u'A1'), String.named(u'A2'), Dict.named(u'A3').of( Dict.named(u'A3B1').of(String.named(u'A3B1C1'), String.named(u'A3B1C2')), Dict.named(u'A3B2').of(String.named(u'A3B2C1')), List.named(u'A3B3').of( List.named(u'A3B3Cx').of(String.named(u'A3B3x')))))) top = schema(data) names = list(e.name for e in top.all_children) assert set(names[0:3]) == set([u'A1', u'A2', u'A3']) assert set(names[3:6]) == set([u'A3B1', u'A3B2', u'A3B3']) assert set(names[6:12]) == set( [u'A3B1C1', u'A3B1C2', u'A3B2C1', u'A3B3Cx']) assert set(names[12:]) == set([u'A3B3x']) assert len(names[12:]) == 6
def test_set_flat_scalar(): pairs = [(u'l', u'1')] schema = List.named(u'l').of(Integer.named(u'i')) el = schema() canary = [] def setter(self, value): canary.append(value) return type(el).set(self, value) el.set = setter.__get__(el, type(el)) el.set_flat(pairs) eq_(len(el), 0) eq_(el.value, []) eq_(canary, [])
def test_set_default_int(): def factory(count, **kw): return List.named(u'l').using(default=count, **kw).of( String.named(u's').using(default=u'val')) schema = factory(3) el = schema() eq_(len(el), 0) eq_(el.value, []) el = schema() el.set_default() eq_(len(el), 3) eq_(el.value, [u'val'] * 3) el.append(None) eq_(len(el), 4) eq_(el[-1].value, None) el[-1].set_default() eq_(el[-1].value, u'val') el = schema([u'a', u'b']) eq_(len(el), 2) eq_(el.value, [u'a', u'b']) el.set_default() eq_(len(el), 3) eq_(el.value, [u'val'] * 3) schema0 = factory(0) el = schema0() el.set_default() eq_(len(el), 0) eq_(el.value, []) def calculated_default(element): assert isinstance(element, List) return 2 schemaf = List.named(u'l').using(default_factory=calculated_default).of( String.named(u's').using(default=u'val')) el = schemaf() el.set_default() eq_(len(el), 2) eq_(el.value, [u'val'] * 2)
def test_mutate_slices(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema() canary = [] el.extend([u'3', u'4']) canary.extend([3, 4]) el[0:1] = [u'1', u'2', u'3'] canary[0:1] = [1, 2, 3] eq_(el.value, [1, 2, 3, 4]) eq_(canary, [1, 2, 3, 4]) del el[2:] del canary[2:] assert el.value == [1, 2] assert canary == [1, 2]
def test_mutate_slices(): schema = List.named(u'l').of(Integer.named(u'i')) el = schema() canary = [] el.extend([u'3', u'4']) canary.extend([3, 4]) el[0:1] = [u'1', u'2', u'3'] canary[0:1] = [1, 2, 3] eq_(el.value, [1, 2, 3, 4]) eq_(canary, [1, 2, 3, 4]) del el[2:] del canary[2:] assert el.value == [1, 2] assert canary == [1, 2]
class Schema(Form): i1 = Integer.using(default=0) d1 = Dict.of( Integer.named('d1i1').using(default=1), Integer.named('d1i2').using(default=2)) l1 = List.using(default=2).of(Integer.named('l1i1').using(default=3)) l2 = List.using(default=3).of( Integer.named('l2i1').using(default=4), Integer.named('l2i2').using(default=5)) l3 = List.using(default=2).of( List.named('l3l1').using(default=2).of(Integer.using(default=6))) a1 = Array.using(default=[10, 11, 12, 13, 14, 15]).of(Integer) dt1 = DateYYYYMMDD.using(default=date.today())
def test_naming_list(): for name, root_flat, leaf_flat in ((u'l', u'l', u'l_0_s'), (None, u'', u'0_s')): schema = List.named(name).of(String.named(u's')) root = schema([u'x']) leaf = root[0] assert root.fq_name() == u'.' assert root.flattened_name() == root_flat assert root.el(u'.') is root assert leaf.fq_name() == u'.0' assert leaf.flattened_name() == leaf_flat assert root.el(u'.0') is leaf assert root.el(u'0') is leaf assert leaf.el(u'.0') is leaf assert_raises(LookupError, leaf.el, u'0') assert_raises(LookupError, leaf.el, u's') assert leaf.el(u'.') is root assert root.el([u'0']) is leaf
def test_naming_list(): for name, root_flat, leaf_flat in ((u'l', u'l', u'l_0_s'), (None, u'', u'0_s')): schema = List.named(name).of(String.named(u's')) root = schema([u'x']) leaf = root[0] assert root.fq_name() == u'.' assert root.flattened_name() == root_flat assert root.el(u'.') is root assert leaf.fq_name() == u'.0' assert leaf.flattened_name() == leaf_flat assert root.el(u'.0') is leaf assert root.el(u'0') is leaf assert leaf.el(u'.0') is leaf assert_raises(LookupError, leaf.el, u'0') assert_raises(LookupError, leaf.el, u's') assert leaf.el(u'.') is root assert root.el([u'0']) is leaf
def validated_list(*validators): return List.named(u'outer').of( String.named(u'inner')).using(validators=validators)
def factory(count, **kw): return List.named(u'l').using(default=count, **kw).of( String.named(u's').using(default=u'val'))
def test_no_duplicates_list_dict(): nd = NotDuplicated(failure=u'%(container_label)s %(position)s') schema = (List.named(u'test').of( Dict.named(u'xyz').of(Integer.named(u'x'), Integer.named(u'y')).using(validators=[nd]))) _test_no_duplicates(schema, {u'x': 1, u'y': 2}, {u'x': 3, u'y': 4})
def test_set_flat_unnamed_child(): schema = List.named(u's').of(String) pairs = [(u's_0', u'abc'), (u's_1', u'def')] bogus = [(u's', u'xxx')] _assert_set_flat(schema, pairs, bogus)
def validated_list(*validators): return List.named('outer').of(String.named('inner')).using( validators=validators)
PhoneNumberDict = Dict.of( String.named('label'), String.named('number') ) class Address(Form): street = String city = String country = String phone_numbers = List.of(PhoneNumber).using(default=1) AddressDict = Dict.of( String.named('street'), String.named('city'), String.named('country'), List.named('phone_numbers').of(PhoneNumber) ) class ContactForm(Form): name = String.validated_by(Present()) addresses = Address.using(default=1) GuardianContentSearch = Dict.of( String.named('q').using(label='Search' ).validated_by(Converted()), String.named('tag').using(label='Tag filter', optional=True ).validated_by(Converted()), String.named('section').using(label='Section filter', optional=True ).validated_by(Converted()), DateYYYYMMDD.named('from-date').using(label='From Date filter', optional=True
re.compile(value, re.U) valid = True except re.error: valid = False if not valid: element.add_error("Subscription has invalid value.") return valid common_meta = ( String.named(keys.ITEMID).validated_by(itemid_validator), String.named(keys.REVID).validated_by(revid_validator), String.named(keys.PARENTID).validated_by(uuid_validator).using(optional=True), String.named(keys.WIKINAME).using(strip=False).validated_by(wikiname_validator), String.named(keys.NAMESPACE).using(strip=False).validated_by(namespace_validator), List.named(keys.NAME).of(String.using(strip=False).validated_by(name_validator)).using(optional=True), List.named(keys.NAME_OLD).of(String.using(strip=False).validated_by(name_validator)).using(optional=True), Integer.named(keys.MTIME).validated_by(mtime_validator), String.named(keys.ACTION).validated_by(action_validator), String.named(keys.ACL).validated_by(acl_validator), String.named(keys.COMMENT).validated_by(comment_validator), String.named(keys.ADDRESS).validated_by(address_validator), String.named(keys.HOSTNAME).validated_by(hostname_validator).using(optional=True), List.named(keys.TAGS).of(String.named('tag').validated_by(tag_validator)).using(optional=True), ) ContentMetaSchema = DuckDict.named('ContentMetaSchema').of( String.named(keys.CONTENTTYPE).validated_by(contenttype_validator), String.named(keys.USERID).validated_by(userid_validator), Integer.named(keys.SIZE).validated_by(size_validator), String.named(keys.HASH_ALGORITHM).validated_by(hash_validator),
return False common_meta = ( String.named(keys.ITEMID).validated_by(itemid_validator), String.named(keys.REVID).validated_by(revid_validator), String.named(keys.PARENTID).validated_by(uuid_validator).using(optional=True), String.named(keys.WIKINAME).using(strip=False).validated_by(wikiname_validator), String.named(keys.NAME).using(strip=False).validated_by(name_validator), String.named(keys.NAME_OLD).using(strip=False).validated_by(name_validator).using(optional=True), Integer.named(keys.MTIME).validated_by(mtime_validator), String.named(keys.ACTION).validated_by(action_validator), String.named(keys.ACL).validated_by(acl_validator), String.named(keys.COMMENT).validated_by(comment_validator), String.named(keys.ADDRESS).validated_by(address_validator), String.named(keys.HOSTNAME).validated_by(hostname_validator).using(optional=True), List.named(keys.TAGS).of(String.named('tag').validated_by(tag_validator)).using(optional=True), ) ContentMetaSchema = DuckDict.named('ContentMetaSchema').of( String.named(keys.CONTENTTYPE).validated_by(contenttype_validator), String.named(keys.USERID).validated_by(userid_validator), Integer.named(keys.SIZE).validated_by(size_validator), String.named(keys.HASH_ALGORITHM).validated_by(hash_validator), String.named(keys.DATAID).validated_by(uuid_validator).using(optional=True), # markup items may have this: List.named(keys.ITEMLINKS).of(String.named('itemlink').validated_by(wikiname_validator)).using(optional=True), List.named(keys.ITEMTRANSCLUSIONS).of(String.named('itemtransclusion').validated_by(wikiname_validator)).using(optional=True), # TODO: CONTENT validation? can we do it here? *common_meta )
if not valid: element.add_error("Subscription has invalid value.") return valid common_meta = ( String.named(keys.ITEMID).validated_by(itemid_validator), String.named(keys.REVID).validated_by(revid_validator), String.named( keys.PARENTID).validated_by(uuid_validator).using(optional=True), String.named( keys.WIKINAME).using(strip=False).validated_by(wikiname_validator), String.named( keys.NAMESPACE).using(strip=False).validated_by(namespace_validator), List.named(keys.NAME).of( String.using(strip=False).validated_by(name_validator)).using( optional=True), List.named(keys.NAME_OLD).of( String.using(strip=False).validated_by(name_validator)).using( optional=True), Integer.named(keys.MTIME).validated_by(mtime_validator), String.named(keys.ACTION).validated_by(action_validator), String.named(keys.ACL).validated_by(acl_validator), String.named(keys.COMMENT).validated_by(comment_validator), String.named(keys.ADDRESS).validated_by(address_validator), String.named( keys.HOSTNAME).validated_by(hostname_validator).using(optional=True), List.named(keys.TAGS).of( String.named('tag').validated_by(tag_validator)).using(optional=True), )
def factory(count, **kw): return List.named(u'l').using(default=count, **kw).of( String.named(u's').using(default=u'val'))
def validated_string(*validators): return List.named(u'test').of( String.using(name=u'foo', validators=validators))
def test_set_flat_unnamed_child(): schema = List.named(u's').of(String) pairs = [(u's_0', u'abc'), (u's_1', u'def')] bogus = [(u's', u'xxx')] _assert_set_flat(schema, pairs, bogus)
def validated_string(*validators): return List.named('test').of(String.using(name=u'foo', validators=validators))