class Token(dr.Ann):
raw = dr.Text()
norm = dr.Text()
pos = dr.Field()
lemma = dr.Field()
span = dr.Slice()
tidx = dr.Field()
class Entity(dr.Ann):
token_span = dr.Slice(Token)
type = dr.Field()
def __repr__(self):
return 'Entity(type={0!r}, token_span={1}:{2})'.format(
self.type, self.token_span.start, self.token_span.stop)
class MyDoc(dr.Doc):
b = dr.Field()
a = dr.Field()
_c = dr.Field(serial='c')
sl = dr.Slice()
anns = dr.Store(MyAnn)
more_anns = dr.Store(MyAnn)
specialised_repr_anns = dr.Store(SpecialisedReprAnn)
class Token(dr.Ann):
span = dr.Slice()
raw = dr.Field()
norm = dr.Field()
def __repr__(self):
return 'Token(norm={0!r}, span={1}:{2})'.format(
self.norm, self.span.start, self.span.stop)
class SliceAnnot(dr.Ann):
span = dr.Slice('MyAnnot')
name = dr.Field()
def __repr__(self):
return '{}(span={}, name={})'.format(self.__class__.__name__,
self.span, self.name)
class Meta:
name = 'SliceAnnot'
def test_use(self):
Foo = dr.make_ann('Foo',
'a',
'b',
'c',
'd',
e=dr.Slice(),
__module__='SerialTest.test_use')
class Doc(dr.Doc):
foos = dr.Store(Foo)
class Meta:
name = 'SerialTest.test_use.Doc'
d = Doc()
d.foos.create(a=1, b=2, c=3, d=4, e=None)
d.foos.create(a=4, b=3, c=2, d=1, e=slice(10, 21))
d.foos.create(x='y')
self.assertEqual(len(d.foos), 3)
d = write_read(d, Doc)
self.assertEqual(len(d.foos), 3)
f1, f2, f3 = d.foos
self.assertEqual(f1.a, 1)
self.assertEqual(f1.b, 2)
self.assertEqual(f1.c, 3)
self.assertEqual(f1.d, 4)
self.assertIsNone(f1.e)
self.assertEqual(f2.a, 4)
self.assertEqual(f2.b, 3)
self.assertEqual(f2.c, 2)
self.assertEqual(f2.d, 1)
self.assertEqual(f2.e, slice(10, 21))
self.assertIsNone(f3.a)
self.assertIsNone(f3.b)
self.assertIsNone(f3.c)
self.assertIsNone(f3.d)
self.assertIsNone(f3.e)
def test_define(self):
Foo = dr.make_ann('Foo',
'a',
'b',
'c',
'd',
e=dr.Slice(),
__module__='SerialTest.test_define')
self.assertEqual(len(Foo._dr_fields), 5)
self.assertIn('a', Foo._dr_fields)
self.assertIsInstance(Foo._dr_fields['a'], dr.Field)
self.assertIn('b', Foo._dr_fields)
self.assertIsInstance(Foo._dr_fields['b'], dr.Field)
self.assertIn('c', Foo._dr_fields)
self.assertIsInstance(Foo._dr_fields['c'], dr.Field)
self.assertIn('d', Foo._dr_fields)
self.assertIsInstance(Foo._dr_fields['d'], dr.Field)
self.assertIn('e', Foo._dr_fields)
self.assertIsInstance(Foo._dr_fields['e'], dr.Slice)
class Token(dr.Ann):
span = dr.Slice()
raw = dr.Field()
class Paragraph(dr.Ann):
span = dr.Slice(Sentence)
class Sent(dr.Ann):
span = dr.Slice(Token)
number = dr.Field()
class Section(dr.Ann):
title = dr.Field()
span = dr.Slice(Token)
class Sentence(dr.Ann):
span = dr.Slice(Token)
class Link(dr.Ann):
span = dr.Slice(Token)
anchor = dr.Field()
target = dr.Field()
class Token(dr.Ann):
span = dr.Slice()
norm = dr.Text()
empty = dr.Field()
class Section(dr.Ann):
span = dr.Slice(Token)
class NamedEntity(dr.Ann):
span = dr.Slice(Token)
label = dr.Field()
class SuperSliceAnnot(dr.Ann):
slice_span = dr.Slice('SliceAnnot')
class Meta:
name = 'SuperSliceAnnot'